create-hq 6.0.0 → 10.0.0

package/template/workers/dev-team/task-executor/src/skills/analyze-issue.ts

@@ -1,219 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-interface Story {
-  id: string;
-  title: string;
-  description?: string;
-  acceptance_criteria: string[];
-  priority: number;
-  passes: boolean;
-  worker_hints?: string[];
-}
-
-interface AnalyzeOptions {
-  issue: string;
-  project: string;
-  repo?: string;
-}
-
-export interface AnalysisResult {
-  issue: string;
-  title: string;
-  workers: string[];
-  sequence: Array<{ worker: string; phase: string }>;
-  estimated_files: string[];
-  complexity: 'simple' | 'medium' | 'complex';
-  reasoning: string;
-}
-
-// Worker detection patterns
-const WORKER_PATTERNS: Record<string, string[]> = {
-  'backend-dev': ['api', 'endpoint', 'route', 'server', 'middleware', 'controller'],
-  'database-dev': ['database', 'schema', 'migration', 'table', 'query', 'sql'],
-  'frontend-dev': ['component', 'ui', 'page', 'form', 'button', 'modal', 'react', 'next'],
-  'motion-designer': ['animation', 'transition', 'motion', 'polish', 'effect', 'visual'],
-  'infra-dev': ['ci/cd', 'deploy', 'pipeline', 'docker', 'kubernetes', 'terraform'],
-  'qa-tester': ['test', 'coverage', 'accessibility', 'a11y', 'e2e', 'integration'],
-  'architect': ['architecture', 'design', 'refactor', 'restructure', 'pattern'],
-};
-
-// Standard worker sequences
-const SEQUENCES: Record<string, string[]> = {
-  'api': ['backend-dev', 'qa-tester'],
-  'api-with-db': ['architect', 'database-dev', 'backend-dev', 'qa-tester'],
-  'frontend': ['frontend-dev', 'qa-tester'],
-  'frontend-polished': ['frontend-dev', 'motion-designer', 'qa-tester'],
-  'fullstack': ['architect', 'database-dev', 'backend-dev', 'frontend-dev', 'qa-tester'],
-  'infra': ['architect', 'infra-dev', 'qa-tester'],
-};
-
-export async function analyzeIssue(options: AnalyzeOptions): Promise<AnalysisResult | null> {
-  const { issue, project, repo } = options;
-
-  // Find PRD
-  const prdPath = path.join(process.cwd(), '..', '..', '..', 'projects', project, 'prd.json');
-
-  if (!fs.existsSync(prdPath)) {
-    console.error(`PRD not found at ${prdPath}`);
-    return null;
-  }
-
-  const prd = JSON.parse(fs.readFileSync(prdPath, 'utf-8'));
-
-  // Find the issue
-  let story: Story | null = null;
-  for (const epic of prd.epics) {
-    for (const s of epic.stories) {
-      if (s.id === issue) {
-        story = s;
-        break;
-      }
-    }
-  }
-
-  if (!story) {
-    console.error(`Issue ${issue} not found in PRD`);
-    return null;
-  }
-
-  console.log(`\n=== Analysis: ${issue} ===\n`);
-  console.log(`Title: ${story.title}`);
-  if (story.description) {
-    console.log(`Description: ${story.description}`);
-  }
-
-  // Check for explicit worker hints
-  let workers: string[] = [];
-  let reasoning = '';
-
-  if (story.worker_hints && story.worker_hints.length > 0) {
-    workers = story.worker_hints;
-    reasoning = 'Using explicit worker_hints from PRD';
-    console.log(`\nUsing worker_hints: ${workers.join(', ')}`);
-  } else {
-    // Auto-detect workers
-    const text = `${story.title} ${story.description || ''} ${story.acceptance_criteria.join(' ')}`.toLowerCase();
-
-    const detectedWorkers: Set<string> = new Set();
-    const detectedPatterns: string[] = [];
-
-    for (const [worker, patterns] of Object.entries(WORKER_PATTERNS)) {
-      for (const pattern of patterns) {
-        if (text.includes(pattern)) {
-          detectedWorkers.add(worker);
-          detectedPatterns.push(`"${pattern}" → ${worker}`);
-          break;
-        }
-      }
-    }
-
-    // Always add qa-tester at the end if not present
-    if (!detectedWorkers.has('qa-tester')) {
-      detectedWorkers.add('qa-tester');
-    }
-
-    workers = Array.from(detectedWorkers);
-    reasoning = `Detected patterns: ${detectedPatterns.join(', ')}`;
-
-    console.log('\nDetected patterns:');
-    for (const p of detectedPatterns) {
-      console.log(`  - ${p}`);
-    }
-  }
-
-  // Order workers properly
-  const orderedWorkers = orderWorkers(workers);
-
-  // Build sequence with descriptions
-  const sequence = orderedWorkers.map(worker => ({
-    worker,
-    phase: getPhaseDescription(worker, story!.title),
-  }));
-
-  // Estimate complexity
-  const complexity = estimateComplexity(sequence.length, story.acceptance_criteria.length);
-
-  // Estimate files (placeholder - would need repo analysis)
-  const estimated_files = estimateFiles(workers, repo);
-
-  const result: AnalysisResult = {
-    issue,
-    title: story.title,
-    workers: orderedWorkers,
-    sequence,
-    estimated_files,
-    complexity,
-    reasoning,
-  };
-
-  console.log(`\nRecommended sequence:`);
-  for (let i = 0; i < sequence.length; i++) {
-    console.log(`  ${i + 1}. ${sequence[i].worker}: ${sequence[i].phase}`);
-  }
-
-  console.log(`\nEstimated files: ${estimated_files.join(', ')}`);
-  console.log(`Complexity: ${complexity}`);
-
-  console.log('\n[Human approval required]');
-  console.log('Confirm sequence? [y/n/modify]');
-
-  return result;
-}
-
-function orderWorkers(workers: string[]): string[] {
-  const order = [
-    'architect',
-    'database-dev',
-    'backend-dev',
-    'frontend-dev',
-    'motion-designer',
-    'infra-dev',
-    'qa-tester',
-    'code-reviewer',
-  ];
-
-  return workers.sort((a, b) => {
-    const aIndex = order.indexOf(a);
-    const bIndex = order.indexOf(b);
-    return (aIndex === -1 ? 99 : aIndex) - (bIndex === -1 ? 99 : bIndex);
-  });
-}
-
-function getPhaseDescription(worker: string, issueTitle: string): string {
-  const descriptions: Record<string, string> = {
-    'architect': `Design approach for: ${issueTitle}`,
-    'database-dev': `Schema changes for: ${issueTitle}`,
-    'backend-dev': `Implement backend for: ${issueTitle}`,
-    'frontend-dev': `Build UI for: ${issueTitle}`,
-    'motion-designer': `Add polish/animations for: ${issueTitle}`,
-    'infra-dev': `Configure infrastructure for: ${issueTitle}`,
-    'qa-tester': `Verify: ${issueTitle}`,
-    'code-reviewer': `Review changes for: ${issueTitle}`,
-  };
-  return descriptions[worker] || `Execute: ${issueTitle}`;
-}
-
-function estimateComplexity(phases: number, criteria: number): 'simple' | 'medium' | 'complex' {
-  const score = phases + criteria / 2;
-  if (score <= 3) return 'simple';
-  if (score <= 6) return 'medium';
-  return 'complex';
-}
-
-function estimateFiles(workers: string[], repo?: string): string[] {
-  // Placeholder - would analyze repo in production
-  const files: string[] = [];
-
-  if (workers.includes('backend-dev')) {
-    files.push('src/api/*.ts');
-  }
-  if (workers.includes('database-dev')) {
-    files.push('src/db/*.ts', 'migrations/*.sql');
-  }
-  if (workers.includes('frontend-dev')) {
-    files.push('src/components/*.tsx', 'src/pages/*.tsx');
-  }
-
-  return files.length > 0 ? files : ['(analysis requires --repo)'];
-}

package/template/workers/dev-team/task-executor/src/skills/execute.ts

@@ -1,132 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { analyzeIssue, AnalysisResult } from './analyze-issue';
-import { validateCompletion } from './validate-completion';
-
-interface ExecuteOptions {
-  issue: string;
-  project: string;
-  repo?: string;
-  skipValidation?: boolean;
-}
-
-interface ExecutionPhase {
-  worker: string;
-  description: string;
-  status: 'pending' | 'running' | 'completed' | 'failed';
-  result?: string;
-  error?: string;
-}
-
-interface ExecutionState {
-  issue: string;
-  project: string;
-  phases: ExecutionPhase[];
-  currentPhase: number;
-  learnings: Array<{ type: string; content: string }>;
-  startTime: Date;
-}
-
-export async function execute(options: ExecuteOptions): Promise<void> {
-  const { issue, project, repo, skipValidation } = options;
-
-  console.log(`\n=== Executing ${issue} ===\n`);
-
-  // Step 1: Analyze issue
-  console.log('Analyzing issue...');
-  const analysis = await analyzeIssue({ issue, project, repo });
-
-  if (!analysis) {
-    console.error('Failed to analyze issue');
-    process.exit(1);
-  }
-
-  // Step 2: Present plan
-  console.log('\nPlanned execution:');
-  for (let i = 0; i < analysis.sequence.length; i++) {
-    const phase = analysis.sequence[i];
-    console.log(`  ${i + 1}. ${phase.worker}: ${phase.phase}`);
-  }
-
-  console.log(`\nComplexity: ${analysis.complexity}`);
-  console.log(`Estimated files: ${analysis.estimated_files.join(', ')}`);
-
-  console.log('\n[Human approval required]');
-  console.log('Approve plan? [y/n/modify]');
-  console.log('(In production, this waits for human input)\n');
-
-  // Step 3: Execute phases
-  const state: ExecutionState = {
-    issue,
-    project,
-    phases: analysis.sequence.map(s => ({
-      worker: s.worker,
-      description: s.phase,
-      status: 'pending' as const,
-    })),
-    currentPhase: 0,
-    learnings: [],
-    startTime: new Date(),
-  };
-
-  for (let i = 0; i < state.phases.length; i++) {
-    state.currentPhase = i;
-    const phase = state.phases[i];
-
-    console.log(`\n--- Phase ${i + 1}/${state.phases.length} ---`);
-    console.log(`Spawning ${phase.worker}: ${phase.description}`);
-    console.log('\n[Human approval required]');
-    console.log('Approve? [y/inject context/skip]');
-
-    // Mark as running
-    phase.status = 'running';
-
-    // In production, this would spawn the worker via Task tool
-    console.log(`\n[Would spawn ${phase.worker} worker here]`);
-    console.log('Task tool call:');
-    console.log(JSON.stringify({
-      description: `${phase.worker}: ${phase.description}`,
-      prompt: `Execute ${phase.worker} worker for issue ${issue}...`,
-      subagent_type: 'general-purpose',
-    }, null, 2));
-
-    // Simulate completion
-    phase.status = 'completed';
-    phase.result = `Completed ${phase.description}`;
-
-    console.log(`\n${phase.worker} completed:`);
-    console.log(`  Result: ${phase.result}`);
-    console.log('\n[Human approval required]');
-    console.log('Approve changes? [y/n/rollback]');
-
-    // Step 4: Validate (if not skipped)
-    if (!skipValidation && repo) {
-      console.log('\nRunning validation...');
-      await validateCompletion({ repo });
-    }
-  }
-
-  // Step 5: Extract learnings
-  console.log('\n=== Execution Complete ===\n');
-
-  const duration = Math.round((Date.now() - state.startTime.getTime()) / 1000);
-  console.log(`Duration: ${duration}s`);
-  console.log(`Phases: ${state.phases.filter(p => p.status === 'completed').length}/${state.phases.length} completed`);
-
-  // Sample learnings
-  state.learnings.push({
-    type: 'workflow',
-    content: `Sequence ${analysis.sequence.map(s => s.worker).join(' → ')} worked well for ${issue}`,
-  });
-
-  console.log('\nLearnings extracted:');
-  for (const learning of state.learnings) {
-    console.log(`  - [${learning.type}] ${learning.content}`);
-  }
-
-  console.log('\n[Human approval required]');
-  console.log('Mark issue as passing? [y/n]');
-
-  console.log('\nTo route learnings, run:');
-  console.log(`  project-manager update-learnings --project ${project}`);
-}

package/template/workers/dev-team/task-executor/src/skills/report-learnings.ts

@@ -1,119 +0,0 @@
-interface Learning {
-  type: 'project' | 'pattern' | 'troubleshoot' | 'workflow';
-  category?: string;
-  content: string;
-  source?: string;
-}
-
-interface ReportOptions {
-  verbose?: boolean;
-}
-
-interface ExecutionContext {
-  task: string;
-  project: string;
-  phases: number;
-  retries: number;
-  duration: string;
-  workers: string[];
-  errors: string[];
-}
-
-export async function reportLearnings(options: ReportOptions): Promise<void> {
-  const { verbose } = options;
-
-  console.log('=== Learning Extraction ===\n');
-
-  // In production, this would receive context from execute skill
-  // For now, show the expected format and process
-
-  console.log('This skill extracts learnings from task execution.\n');
-
-  console.log('Expected input (from execute skill):');
-  const sampleContext: ExecutionContext = {
-    task: 'US-003',
-    project: 'auth-feature',
-    phases: 2,
-    retries: 0,
-    duration: '5m',
-    workers: ['backend-dev', 'qa-tester'],
-    errors: [],
-  };
-  console.log(JSON.stringify(sampleContext, null, 2));
-
-  console.log('\n' + '-'.repeat(40) + '\n');
-
-  // Learning extraction logic
-  const learnings: Learning[] = [];
-
-  // Analyze execution for learnings
-  learnings.push({
-    type: 'workflow',
-    content: `Sequence ${sampleContext.workers.join(' → ')} worked well for auth endpoints`,
-  });
-
-  if (sampleContext.retries === 0) {
-    learnings.push({
-      type: 'pattern',
-      category: 'general',
-      content: 'Clean execution with no retries indicates well-scoped task',
-    });
-  }
-
-  // Format output
-  console.log('Extracted learnings:\n');
-
-  for (let i = 0; i < learnings.length; i++) {
-    const l = learnings[i];
-    const category = l.category ? `/${l.category}` : '';
-    console.log(`${i + 1}. [${l.type}${category}]`);
-    console.log(`   ${l.content}`);
-    if (l.source) {
-      console.log(`   Source: ${l.source}`);
-    }
-    console.log();
-  }
-
-  // Routing info
-  console.log('Routing destinations:');
-  for (const l of learnings) {
-    let dest = '';
-    switch (l.type) {
-      case 'project':
-        dest = `projects/${sampleContext.project}/learnings/`;
-        break;
-      case 'pattern':
-        dest = `knowledge/dev-team/patterns/${l.category || 'general'}/`;
-        break;
-      case 'troubleshoot':
-        dest = 'knowledge/dev-team/troubleshooting/';
-        break;
-      case 'workflow':
-        dest = 'knowledge/dev-team/workflows/';
-        break;
-    }
-    console.log(`  - [${l.type}] → ${dest}`);
-  }
-
-  console.log('\n[Human approval required]');
-  console.log('Approve learnings for routing? [y/n/edit]');
-
-  console.log('\nTo route approved learnings:');
-  console.log(`  project-manager update-learnings --project ${sampleContext.project}`);
-
-  // Output format for project-manager
-  if (verbose) {
-    console.log('\n' + '-'.repeat(40));
-    console.log('\nJSON output for project-manager:');
-    console.log(JSON.stringify({
-      task: sampleContext.task,
-      project: sampleContext.project,
-      execution: {
-        phases: sampleContext.phases,
-        retries: sampleContext.retries,
-        duration: sampleContext.duration,
-      },
-      learnings,
-    }, null, 2));
-  }
-}

package/template/workers/dev-team/task-executor/src/skills/validate-completion.ts

@@ -1,142 +0,0 @@
-import { execSync } from 'child_process';
-import * as path from 'path';
-
-interface ValidateOptions {
-  repo: string;
-  checks?: string;
-  strict?: boolean;
-}
-
-interface CheckResult {
-  name: string;
-  passed: boolean;
-  output: string;
-  errors: string[];
-  warnings: string[];
-}
-
-export async function validateCompletion(options: ValidateOptions): Promise<boolean> {
-  const { repo, checks, strict } = options;
-
-  const checksToRun = checks ? checks.split(',') : ['typecheck', 'lint', 'test'];
-  const results: CheckResult[] = [];
-
-  console.log('\nRunning validation checks...\n');
-
-  // Type check
-  if (checksToRun.includes('typecheck')) {
-    const result = runCheck('typecheck', 'npm run typecheck', repo);
-    results.push(result);
-    printCheckResult(result, 1, checksToRun.length);
-  }
-
-  // Lint
-  if (checksToRun.includes('lint')) {
-    const result = runCheck('lint', 'npm run lint', repo);
-    results.push(result);
-    printCheckResult(result, 2, checksToRun.length);
-  }
-
-  // Test
-  if (checksToRun.includes('test')) {
-    const result = runCheck('test', 'npm test', repo);
-    results.push(result);
-    printCheckResult(result, 3, checksToRun.length);
-  }
-
-  // Build (optional)
-  if (checksToRun.includes('build')) {
-    const result = runCheck('build', 'npm run build', repo);
-    results.push(result);
-    printCheckResult(result, checksToRun.indexOf('build') + 1, checksToRun.length);
-  }
-
-  // Summary
-  const failed = results.filter(r => !r.passed);
-  const hasWarnings = results.some(r => r.warnings.length > 0);
-
-  console.log('\n' + '='.repeat(40));
-
-  if (failed.length === 0) {
-    if (hasWarnings && strict) {
-      console.log('Overall: FAIL (strict mode, warnings present)');
-      return false;
-    }
-    console.log('Overall: PASS');
-    console.log('Ready to commit.');
-    return true;
-  } else {
-    console.log(`Overall: FAIL (${failed.length} check(s) failed)`);
-    console.log('\nFailed checks:');
-    for (const f of failed) {
-      console.log(`  - ${f.name}`);
-      for (const err of f.errors.slice(0, 5)) {
-        console.log(`    ${err}`);
-      }
-    }
-    console.log('\nFix errors and re-run validation.');
-    return false;
-  }
-}
-
-function runCheck(name: string, command: string, cwd: string): CheckResult {
-  const result: CheckResult = {
-    name,
-    passed: false,
-    output: '',
-    errors: [],
-    warnings: [],
-  };
-
-  try {
-    const output = execSync(command, {
-      cwd: path.resolve(cwd),
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-
-    result.passed = true;
-    result.output = output;
-
-    // Extract warnings from output
-    const warningLines = output.split('\n').filter(line =>
-      line.toLowerCase().includes('warning') ||
-      line.includes('⚠')
-    );
-    result.warnings = warningLines.slice(0, 10);
-
-  } catch (error: any) {
-    result.passed = false;
-    result.output = error.stdout || error.stderr || error.message;
-
-    // Extract errors from output
-    const errorLines = result.output.split('\n').filter(line =>
-      line.toLowerCase().includes('error') ||
-      line.includes('✖') ||
-      line.includes('❌')
-    );
-    result.errors = errorLines.slice(0, 10);
-  }
-
-  return result;
-}
-
-function printCheckResult(result: CheckResult, index: number, total: number): void {
-  const status = result.passed ? '✅' : '❌';
-  console.log(`[${index}/${total}] ${result.name}...`);
-  console.log(`  ${status} ${result.passed ? 'passed' : 'failed'}`);
-
-  if (result.errors.length > 0) {
-    console.log('  Errors:');
-    for (const err of result.errors.slice(0, 3)) {
-      console.log(`    ${err}`);
-    }
-  }
-
-  if (result.warnings.length > 0 && result.passed) {
-    console.log('  Warnings:');
-    for (const warn of result.warnings.slice(0, 3)) {
-      console.log(`    ${warn}`);
-    }
-  }
-}

package/template/workers/dev-team/task-executor/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "commonjs",
-    "lib": ["ES2022"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}