SERVICES DOCUMENTATION

async assistInitConfig(input: {
  userDescription: string;
  aiOptions?: AIOptions;
  streamingOptions?: StreamingOptions;
}): Promise<{
  projectName: string;
  aiProvider: string;
  aiModel: string;
  frontend?: string;
  backend?: string;
  database?: string;
  auth?: boolean;
  reasoning: string;
}>

const recommendation = await workflowAIAssistant.assistInitConfig({
  userDescription: "A real-time collaboration platform for remote development teams with video calls, code sharing, and project management features. Need to handle high concurrency and support multiple file formats.",
  aiOptions: {
    aiProvider: "anthropic",
    aiModel: "claude-3-5-sonnet"
  },
  streamingOptions: {
    onChunk: (chunk) => process.stdout.write(chunk),
    onFinish: () => console.log("\nRecommendation complete!")
  }
});

console.log("Recommended stack:");
console.log(`- Project: ${recommendation.projectName}`);
console.log(`- AI Provider: ${recommendation.aiProvider}`);
console.log(`- AI Model: ${recommendation.aiModel}`);
console.log(`- Frontend: ${recommendation.frontend}`);
console.log(`- Backend: ${recommendation.backend}`);
console.log(`- Database: ${recommendation.database}`);
console.log(`- Auth: ${recommendation.auth}`);
console.log(`\nReasoning: ${recommendation.reasoning}`);

const recommendation = await workflowAIAssistant.assistInitConfig({
  userDescription: "Simple blog API with user authentication and CRUD operations"
});

console.log(`AI recommends: ${recommendation.frontend || 'no frontend'} + ${recommendation.backend || 'no backend'}`);
console.log(`Using ${recommendation.aiProvider}/${recommendation.aiModel} for AI operations`);

const recommendation = await workflowAIAssistant.assistInitConfig({
  userDescription: "Enterprise-grade analytics dashboard with real-time data visualization and predictive analytics",
  aiOptions: {
    aiProvider: "openai",
    aiModel: "gpt-4o",
    aiKey: process.env.OPENAI_API_KEY
  }
});

console.log("Using GPT-4o for enterprise recommendations");
console.log(`Recommended database: ${recommendation.database}`);

async assistPRDCreation(input: {
  userDescription: string;
  aiOptions?: AIOptions;
  streamingOptions?: StreamingOptions;
}): Promise<string>

const prdContent = await workflowAIAssistant.assistPRDCreation({
  userDescription: "Mobile fitness tracking app with social features, workout plans, progress tracking, nutrition logging, and integration with wearable devices. Target audience includes fitness enthusiasts and casual users.",
  aiOptions: {
    aiProvider: "anthropic",
    aiModel: "claude-3-5-sonnet"
  },
  streamingOptions: {
    onChunk: (chunk) => process.stdout.write(chunk),
    onFinish: () => console.log("\nPRD generation complete!")
  }
});

console.log(`Generated PRD with ${prdContent.length} characters`);
if (prdContent.length > 0) {
  await fs.writeFile("./generated-prd.md", prdContent);
  console.log("PRD saved to generated-prd.md");
} else {
  console.error("PRD generation failed - empty result");
}

const simplePRD = await workflowAIAssistant.assistPRDCreation({
  userDescription: "Todo list application with categories, due dates, priorities, and reminders"
});

if (simplePRD) {
  console.log("Quick PRD generated:", simplePRD.substring(0, 100) + "...");
  console.log(`Total length: ${simplePRD.length} characters`);
} else {
  console.error("Failed to generate PRD");
}

async assistPRDRefinement(input: {
  currentPRD: string;
  userFeedback: string;
  aiOptions?: AIOptions;
  streamingOptions?: StreamingOptions;
}): Promise<string>

const refinedPRD = await workflowAIAssistant.assistPRDRefinement({
  currentPRD: existingPRDContent,
  userFeedback: `Add more technical specifications including:
1. API endpoints and data models
2. Security requirements and authentication flow
3. Performance benchmarks and scalability targets
4. Deployment architecture and infrastructure requirements`,
  aiOptions: {
    aiProvider: "anthropic",
    aiModel: "claude-3-5-sonnet"
  },
  streamingOptions: {
    onChunk: (chunk) => process.stdout.write(chunk),
    onFinish: () => console.log("\nRefinement complete!")
  }
});

if (refinedPRD !== existingPRDContent) {
  console.log(`Refined PRD length: ${refinedPRD.length} characters`);
  console.log(`Improvement: ${refinedPRD.length - existingPRDContent.length} characters added`);
  await fs.writeFile("./refined-prd.md", refinedPRD);
} else {
  console.warn("PRD was not refined (may indicate error)");
}

const specificRefinement = await workflowAIAssistant.assistPRDRefinement({
  currentPRD: basicPRD,
  userFeedback: "Focus on mobile responsiveness, offline capabilities using PWA, and accessibility features following WCAG 2.1 AA guidelines"
});

console.log("PRD refined for mobile-first approach");
console.log(`New length: ${specificRefinement.length} characters`);

let currentPRD = await fs.readFile("./draft-prd.md", "utf-8");
const improvements = [
  "Add security requirements section",
  "Include performance metrics and SLA targets",
  "Add testing and QA requirements",
  "Include deployment and monitoring specifications"
];

for (const improvement of improvements) {
  console.log(`\nApplying: ${improvement}`);
  currentPRD = await workflowAIAssistant.assistPRDRefinement({
    currentPRD: currentPRD,
    userFeedback: improvement,
    aiOptions: { aiProvider: "anthropic", aiModel: "claude-3-5-sonnet" },
    streamingOptions: {
      onChunk: (chunk) => process.stdout.write('.')
    }
  });
  console.log(" Done");
}

await fs.writeFile("./final-prd.md", currentPRD);
console.log("\nFinal PRD ready!");

async assistTaskPrioritization(input: {
  tasks: Array<{ id: string; title: string; description?: string }>;
  userGuidance: string;
  aiOptions?: AIOptions;
  streamingOptions?: StreamingOptions;
}): Promise<{
  prioritizedTasks: Array<{
    id: string;
    priority: number;
    reasoning: string;
  }>;
  recommendations: string;
}>

const tasks = [
  { id: "1", title: "Implement user authentication", description: "OAuth2 integration with JWT tokens and refresh logic" },
  { id: "2", title: "Design database schema", description: "User data, posts, relationships, and indexing strategy" },
  { id: "3", title: "Create responsive UI", description: "Mobile-first design with CSS Grid and responsive images" },
  { id: "4", title: "Setup CI/CD pipeline", description: "GitHub Actions with automated testing, linting, and deployment" },
  { id: "5", title: "Implement search functionality", description: "Full-text search with Elasticsearch integration" }
];

const prioritization = await workflowAIAssistant.assistTaskPrioritization({
  tasks: tasks,
  userGuidance: "Prioritize based on dependencies and user-facing impact. Authentication should be first, then core functionality. Infrastructure can be parallelized. Consider technical complexity and risk.",
  aiOptions: {
    aiProvider: "anthropic",
    aiModel: "claude-3-5-sonnet"
  },
  streamingOptions: {
    onChunk: (chunk) => process.stdout.write(chunk)
  }
});

console.log("Prioritized tasks:");
prioritization.prioritizedTasks
  .sort((a, b) => a.priority - b.priority)
  .forEach(task => {
    const taskDetails = tasks.find(t => t.id === task.id);
    console.log(`${task.priority}. [${task.id}] ${taskDetails?.title}`);
    console.log(`   Reasoning: ${task.reasoning}`);
  });

console.log(`\nStrategic Recommendations:\n${prioritization.recommendations}`);

const effortPrioritization = await workflowAIAssistant.assistTaskPrioritization({
  tasks: developmentTasks,
  userGuidance: "Prioritize high-effort, high-impact tasks first. Consider dependencies and technical risk. Frontend and backend should progress in parallel where possible."
});

// Sort by priority for execution order
const sortedTasks = effortPrioritization.prioritizedTasks
  .sort((a, b) => a.priority - b.priority)
  .map(pt => developmentTasks.find(t => t.id === pt.id));

console.log("Execution order:", sortedTasks.map(t => t?.title).join(" -> "));

// Apply priorities to actual tasks
for (const prioritized of effortPrioritization.prioritizedTasks) {
  await taskService.updateTask(prioritized.id, {
    metadata: { priority: prioritized.priority }
  });
}

const riskPrioritization = await workflowAIAssistant.assistTaskPrioritization({
  tasks: criticalPathTasks,
  userGuidance: "Prioritize by risk - address the riskiest technical challenges first. Consider areas where we have the least experience or most uncertainty. These tasks should get our best developers."
});

console.log("Risk-based execution plan:");
riskPrioritization.prioritizedTasks
  .sort((a, b) => a.priority - b.priority)
  .slice(0, 5)
  .forEach(pt => {
    const task = criticalPathTasks.find(t => t.id === pt.id);
    console.log(`${pt.priority}. ${task?.title} - HIGH RISK: ${pt.reasoning}`);
  });

async assistTaskSplitting(input: {
  taskTitle: string;
  taskContent?: string;
  userGuidance: string;
  aiOptions?: AIOptions;
  streamingOptions?: StreamingOptions;
}): Promise<string>

const splittingInstructions = await workflowAIAssistant.assistTaskSplitting({
  taskTitle: "Implement e-commerce platform",
  taskContent: "Build a full-stack e-commerce solution with payment processing via Stripe, inventory management with Redis cache, user accounts with JWT authentication, product catalog with search, order management, and admin dashboard.",
  userGuidance: "Split into frontend, backend, and database components. Include testing and deployment tasks. Focus on API development first, then frontend integration. Each subtask should be completable in 1-2 days.",
  aiOptions: {
    aiProvider: "anthropic",
    aiModel: "claude-3-5-sonnet"
  },
  streamingOptions: {
    onChunk: (chunk) => process.stdout.write(chunk),
    onFinish: () => console.log("\nSplitting instructions generated!")
  }
});

console.log("AI-generated splitting instructions:");
console.log(splittingInstructions);

// Use instructions with taskService.splitTask
if (splittingInstructions) {
  const splitResult = await taskService.splitTask(
    "task-id",
    undefined,
    splittingInstructions
  );
  console.log(`Split into ${splitResult.subtasks.length} subtasks`);
}

const featureSplitting = await workflowAIAssistant.assistTaskSplitting({
  taskTitle: "Add social features",
  userGuidance: "Split into user profiles, social connections (follow/friend), activity feeds, notifications, and messaging. Include both frontend and backend tasks for each feature. Database schema changes should be separate."
});

console.log("Feature-based splitting instructions:");
console.log(featureSplitting);
console.log(`Instructions length: ${featureSplitting.length} characters`);

const technicalSplitting = await workflowAIAssistant.assistTaskSplitting({
  taskTitle: "Build authentication system",
  taskContent: "Implement secure user authentication supporting email/password, OAuth (Google, GitHub), and magic links. Include password reset, email verification, and session management.",
  userGuidance: "Split by technical components: UI/UX pages, API endpoints, database models and migrations, security middleware, email service integration, and unit tests. Each component should be independently testable."
});

console.log("Technical component splitting instructions ready");
console.log(technicalSplitting);

// Example prompt template usage
const promptResult = PromptBuilder.buildPrompt({
  name: "project-init-suggestion",
  type: "user",
  variables: {
    USER_DESCRIPTION: input.userDescription
  }
});

if (!promptResult.success) {
  throw createStandardError(
    TaskOMaticErrorCodes.CONFIGURATION_ERROR,
    `Failed to build prompt: ${promptResult.error}`
  );
}

const systemPromptResult = PromptBuilder.buildPrompt({
  name: "project-init-suggestion",
  type: "system",
  variables: {}
});

// From PromptRegistry
const templates = [
  "project-init-suggestion",      // Stack recommendations
  "project-init-suggestion-system",
  "prd-improvement",              // PRD refinement
  "prd-improvement-system",
  "task-prioritization",          // Task ordering
  "task-prioritization-system",
  "task-splitting-assistance",    // Task breakdown
  "task-splitting-assistance-system"
];

interface AIOptions {
  aiProvider?: string;        // Provider selection (anthropic, openai, openrouter, etc.)
  aiModel?: string;          // Model selection
  aiKey?: string;            // API key override
  aiProviderUrl?: string;   // Custom endpoint URL
}

interface StreamingOptions {
  onChunk?: (chunk: string) => void;      // Real-time response chunks
  onFinish?: (result: any) => void;       // Completion callback
  onError?: (error: Error) => void;        // Error handling callback
}

// JSON parsing with fallback
try {
  const jsonMatch = result.match(/\{[\s\S]*\}/);
  if (!jsonMatch) {
    throw createStandardError(
      TaskOMaticErrorCodes.AI_OPERATION_FAILED,
      "No JSON found in AI response",
      {
        context: "The AI did not return a valid JSON object.",
        suggestions: [
          "Try a different model or provider.",
          "Check the prompt for clarity.",
          "Simplify the request."
        ]
      }
    );
  }
  return JSON.parse(jsonMatch[0]);
} catch (error) {
  // Return sensible defaults
  return defaultConfiguration;
}

// Step 1: Get AI recommendations for project setup
const configRecommendation = await workflowAIAssistant.assistInitConfig({
  userDescription: "AI-powered code review platform for development teams with real-time collaboration, automated analysis, and team management features. Needs to support Git integration, code diff visualization, and commenting system.",
  aiOptions: { aiProvider: "anthropic", aiModel: "claude-3-5-sonnet" },
  streamingOptions: {
    onChunk: (chunk) => process.stdout.write('.'),
    onFinish: () => console.log("\n✓ Config recommendations received")
  }
});

console.log("\nAI Recommended Stack:");
console.log(`- Project: ${configRecommendation.projectName}`);
console.log(`- Frontend: ${configRecommendation.frontend}`);
console.log(`- Backend: ${configRecommendation.backend}`);
console.log(`- Database: ${configRecommendation.database}`);
console.log(`- AI: ${configRecommendation.aiProvider}/${configRecommendation.aiModel}`);

// Step 2: Generate initial PRD
console.log("\nGenerating PRD...");
const prdContent = await workflowAIAssistant.assistPRDCreation({
  userDescription: "AI-powered code review platform with real-time collaboration, automated analysis, and team management features",
  aiOptions: { aiProvider: "anthropic", aiModel: "claude-3-5-sonnet" },
  streamingOptions: {
    onChunk: (chunk) => process.stdout.write('.'),
    onFinish: () => console.log("\n✓ PRD generated")
  }
});

// Step 3: Refine PRD based on feedback
console.log("\nRefining PRD with technical details...");
const refinedPRD = await workflowAIAssistant.assistPRDRefinement({
  currentPRD: prdContent,
  userFeedback: "Add more technical details about code analysis algorithms, integration with Git providers (GitHub, GitLab, Bitbucket), performance requirements for large repositories (>100k files), and security considerations for accessing private repositories.",
  aiOptions: { aiProvider: "anthropic", aiModel: "claude-3-5-sonnet" },
  streamingOptions: {
    onChunk: (chunk) => process.stdout.write('.'),
    onFinish: () => console.log("\n✓ PRD refined")
  }
});

console.log(`\nComplete project setup assistance completed`);
console.log(`Final PRD length: ${refinedPRD.length} characters`);

// Get all todo tasks
const tasks = await taskService.listTasks({ status: "todo" });
const taskDetails = tasks.map(task => ({
  id: task.id,
  title: task.title,
  description: task.description
}));

// Get prioritized task order
console.log("Analyzing task priorities...");
const prioritization = await workflowAIAssistant.assistTaskPrioritization({
  tasks: taskDetails,
  userGuidance: "Prioritize based on user impact, dependencies, and effort. Critical path tasks first. Consider technical risk and team expertise. Balance quick wins with important foundation work.",
  aiOptions: { aiProvider: "anthropic", aiModel: "claude-3-5-sonnet" },
  streamingOptions: {
    onChunk: (chunk) => process.stdout.write('.'),
    onFinish: () => console.log("\n✓ Prioritization complete")
  }
});

console.log("\n=== EXECUTION PLAN ===");
console.log(prioritization.recommendations);
console.log("\nTask Order:");

// Sort tasks by priority and create execution plan
const executionPlan = prioritization.prioritizedTasks
  .sort((a, b) => a.priority - b.priority);

for (const prioritizedTask of executionPlan) {
  const task = tasks.find(t => t.id === prioritizedTask.id);
  if (task) {
    console.log(`\n${prioritizedTask.priority}. ${task.title}`);
    console.log(`   Reason: ${prioritizedTask.reasoning}`);

    // Get splitting instructions for complex tasks
    if (task.estimatedEffort === "large") {
      console.log("   Generating subtask breakdown...");
      const splittingInstructions = await workflowAIAssistant.assistTaskSplitting({
        taskTitle: task.title,
        taskContent: task.description,
        userGuidance: "Split into 2-4 subtasks, each completable in 1-2 days. Include testing and documentation.",
        aiOptions: { aiProvider: "anthropic", aiModel: "claude-3-5-sonnet" }
      });

      // Apply splitting
      await taskService.splitTask(task.id, undefined, splittingInstructions);
      console.log(`   ✓ Split into subtasks`);
    }

    // Update task with priority
    await taskService.updateTask(task.id, {
      metadata: { priority: prioritizedTask.priority }
    });
  }
}

console.log("\n✓ Task execution plan ready");

let currentPRD = await fs.readFile("./draft-prd.md", "utf-8");
const feedbackRounds = [
  "Add security requirements section including authentication, authorization, and data protection",
  "Include performance benchmarks: page load <2s, API response <200ms, support 10k concurrent users",
  "Detail user experience and accessibility requirements following WCAG 2.1 AA",
  "Add integration requirements with existing systems (CRM, analytics, payment gateway)",
  "Include testing strategy covering unit, integration, E2E, and performance testing"
];

console.log(`Starting with PRD of ${currentPRD.length} characters`);
console.log(`Applying ${feedbackRounds.length} rounds of improvements...\n`);

for (let i = 0; i < feedbackRounds.length; i++) {
  console.log(`Round ${i + 1}/${feedbackRounds.length}: ${feedbackRounds[i]}`);

  currentPRD = await workflowAIAssistant.assistPRDRefinement({
    currentPRD: currentPRD,
    userFeedback: feedbackRounds[i],
    aiOptions: { aiProvider: "anthropic", aiModel: "claude-3-5-sonnet" },
    streamingOptions: {
      onChunk: (chunk) => process.stdout.write('.'),
      onFinish: () => console.log(` Done (${currentPRD.length} chars)`)
    }
  });

  // Save intermediate version
  await fs.writeFile(`./prd-refined-v${i + 1}.md`, currentPRD);
}

console.log(`\n✓ Final refined PRD ready: ${currentPRD.length} characters`);
console.log(`Final PRD saved to prd-refined-v${feedbackRounds.length}.md`);

// Template structure from PromptRegistry
{
  name: "project-init-suggestion",
  description: "Suggest project initialization configuration",
  type: "user",
  requiredVariables: ["USER_DESCRIPTION"],
  optionalVariables: [],
  promptText: PROJECT_INIT_SUGGESTION_PROMPT
}

// JSON extraction with regex
const jsonMatch = result.match(/\{[\s\S]*\}/);
if (!jsonMatch) {
  throw createStandardError(
    TaskOMaticErrorCodes.AI_OPERATION_FAILED,
    "No JSON found in AI response"
  );
}
return JSON.parse(jsonMatch[0]);

// WorkflowService integration
import { workflowAIAssistant } from '@task-o-matic/core';

// TaskService integration
import { taskService } from '@task-o-matic/core';

// PRDService integration
import { prdService } from '@task-o-matic/core';

// Combined workflow
const config = await workflowAIAssistant.assistInitConfig({...});
const prd = await workflowAIAssistant.assistPRDCreation({...});
const tasks = await prdService.parsePRD(prd, {...});
const prioritized = await workflowAIAssistant.assistTaskPrioritization({
  tasks: tasks.map(t => ({ id: t.id, title: t.title })),
  userGuidance: "Critical path first"
});