create-hq 5.0.0

package/template/workers/dev-team/project-manager/src/skills/next-issue.ts

@@ -0,0 +1,137 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+
+interface Story {
+  id: string;
+  title: string;
+  description?: string;
+  acceptance_criteria: string[];
+  priority: number;
+  passes: boolean;
+  dependsOn?: string[];
+  worker_hints?: string[];
+}
+
+interface Epic {
+  id: string;
+  title: string;
+  stories: Story[];
+}
+
+interface PRD {
+  project: string;
+  epics: Epic[];
+}
+
+interface NextIssueOptions {
+  project: string;
+  filter?: string;
+  priority?: string;
+}
+
+export async function nextIssue(options: NextIssueOptions): Promise<void> {
+  const { project, filter, priority } = options;
+
+  // Find PRD file
+  const prdPath = path.join(process.cwd(), '..', '..', '..', 'projects', project, 'prd.json');
+
+  if (!fs.existsSync(prdPath)) {
+    console.error(`PRD not found at ${prdPath}`);
+    console.log('\nTo create a new PRD, run:');
+    console.log(`  project-manager create-prd --name ${project} --input requirements.md`);
+    process.exit(1);
+  }
+
+  const prd: PRD = JSON.parse(fs.readFileSync(prdPath, 'utf-8'));
+
+  // Collect all stories with their pass status
+  const allStories: (Story & { epicId: string; epicTitle: string })[] = [];
+  for (const epic of prd.epics) {
+    for (const story of epic.stories) {
+      allStories.push({ ...story, epicId: epic.id, epicTitle: epic.title });
+    }
+  }
+
+  // Build pass map for dependency checking
+  const passMap = new Map<string, boolean>();
+  for (const story of allStories) {
+    passMap.set(story.id, story.passes);
+  }
+
+  // Filter to incomplete stories with met dependencies
+  let candidates = allStories.filter(story => {
+    if (story.passes) return false;
+
+    // Check dependencies
+    if (story.dependsOn && story.dependsOn.length > 0) {
+      for (const dep of story.dependsOn) {
+        if (!passMap.get(dep)) return false;
+      }
+    }
+
+    return true;
+  });
+
+  // Apply optional filters
+  if (priority) {
+    const priorityMap: Record<string, number> = { high: 1, medium: 2, low: 3 };
+    const priorityValue = priorityMap[priority.toLowerCase()];
+    if (priorityValue) {
+      candidates = candidates.filter(s => s.priority <= priorityValue);
+    }
+  }
+
+  if (candidates.length === 0) {
+    console.log('No eligible issues found.');
+    console.log('\nPossible reasons:');
+    console.log('  - All stories are complete (passes: true)');
+    console.log('  - Remaining stories have unmet dependencies');
+    process.exit(0);
+  }
+
+  // Score and sort candidates
+  candidates.sort((a, b) => {
+    // Priority first (lower number = higher priority)
+    if (a.priority !== b.priority) return a.priority - b.priority;
+
+    // Then by number of stories blocked by this one
+    const aBlocks = allStories.filter(s => s.dependsOn?.includes(a.id)).length;
+    const bBlocks = allStories.filter(s => s.dependsOn?.includes(b.id)).length;
+    return bBlocks - aBlocks;
+  });
+
+  // Present top candidates
+  const top = candidates.slice(0, 3);
+  const recommended = top[0];
+
+  console.log(`\n=== Next Issue Selection for ${project} ===\n`);
+  console.log(`Recommended: ${recommended.id} "${recommended.title}"`);
+  console.log(`  Epic: ${recommended.epicTitle}`);
+  console.log(`  Priority: ${recommended.priority}`);
+
+  const blocksCount = allStories.filter(s => s.dependsOn?.includes(recommended.id)).length;
+  if (blocksCount > 0) {
+    console.log(`  Blocks: ${blocksCount} other stories`);
+  }
+
+  if (recommended.worker_hints && recommended.worker_hints.length > 0) {
+    console.log(`  Workers: ${recommended.worker_hints.join(' → ')}`);
+  }
+
+  console.log('\n  Acceptance Criteria:');
+  for (const criterion of recommended.acceptance_criteria) {
+    console.log(`    - ${criterion}`);
+  }
+
+  if (top.length > 1) {
+    console.log('\nAlternatives:');
+    for (let i = 1; i < top.length; i++) {
+      const alt = top[i];
+      console.log(`  - ${alt.id}: "${alt.title}" (Priority: ${alt.priority})`);
+    }
+  }
+
+  console.log('\n[Human approval required to proceed]');
+  console.log('To execute, run task-executor with the selected issue.');
+}

package/template/workers/dev-team/project-manager/src/skills/project-status.ts

@@ -0,0 +1,131 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+interface Story {
+  id: string;
+  title: string;
+  passes: boolean;
+  dependsOn?: string[];
+}
+
+interface Epic {
+  id: string;
+  title: string;
+  stories: Story[];
+}
+
+interface PRD {
+  project: string;
+  epics: Epic[];
+}
+
+interface ProjectStatusOptions {
+  project: string;
+  verbose?: boolean;
+  format?: string;
+}
+
+export async function projectStatus(options: ProjectStatusOptions): Promise<void> {
+  const { project, verbose, format = 'table' } = options;
+
+  const prdPath = path.join(process.cwd(), '..', '..', '..', 'projects', project, 'prd.json');
+
+  if (!fs.existsSync(prdPath)) {
+    console.error(`PRD not found at ${prdPath}`);
+    process.exit(1);
+  }
+
+  const prd: PRD = JSON.parse(fs.readFileSync(prdPath, 'utf-8'));
+
+  // Collect all stories
+  const allStories: (Story & { epicTitle: string })[] = [];
+  for (const epic of prd.epics) {
+    for (const story of epic.stories) {
+      allStories.push({ ...story, epicTitle: epic.title });
+    }
+  }
+
+  // Calculate stats
+  const total = allStories.length;
+  const completed = allStories.filter(s => s.passes).length;
+  const pending = allStories.filter(s => !s.passes).length;
+  const percentage = Math.round((completed / total) * 100);
+
+  // Build pass map for dependency checking
+  const passMap = new Map<string, boolean>();
+  for (const story of allStories) {
+    passMap.set(story.id, story.passes);
+  }
+
+  // Find blocked stories
+  const blocked = allStories.filter(story => {
+    if (story.passes) return false;
+    if (!story.dependsOn || story.dependsOn.length === 0) return false;
+    return story.dependsOn.some(dep => !passMap.get(dep));
+  });
+
+  // Find ready stories (not passed, dependencies met)
+  const ready = allStories.filter(story => {
+    if (story.passes) return false;
+    if (!story.dependsOn || story.dependsOn.length === 0) return true;
+    return story.dependsOn.every(dep => passMap.get(dep));
+  });
+
+  // Output
+  if (format === 'json') {
+    console.log(JSON.stringify({
+      project,
+      total,
+      completed,
+      pending,
+      percentage,
+      blocked: blocked.map(s => s.id),
+      ready: ready.map(s => s.id)
+    }, null, 2));
+    return;
+  }
+
+  // Progress bar
+  const barLength = 20;
+  const filledLength = Math.round((percentage / 100) * barLength);
+  const bar = '█'.repeat(filledLength) + '░'.repeat(barLength - filledLength);
+
+  console.log(`\n=== ${project} ===`);
+  console.log(`Progress: ${bar} ${percentage}% (${completed}/${total} stories)\n`);
+
+  if (completed > 0) {
+    console.log(`✅ Completed (${completed}):`);
+    for (const story of allStories.filter(s => s.passes)) {
+      console.log(`   - ${story.id}: ${story.title}`);
+    }
+    console.log();
+  }
+
+  if (ready.length > 0) {
+    console.log(`⏳ Ready (${ready.length}):`);
+    for (const story of ready) {
+      console.log(`   - ${story.id}: ${story.title}`);
+    }
+    console.log();
+  }
+
+  if (blocked.length > 0) {
+    console.log(`🚫 Blocked (${blocked.length}):`);
+    for (const story of blocked) {
+      const blockedBy = story.dependsOn?.filter(dep => !passMap.get(dep)) || [];
+      console.log(`   - ${story.id}: ${story.title}`);
+      console.log(`     blocked by: ${blockedBy.join(', ')}`);
+    }
+    console.log();
+  }
+
+  // Next recommendation
+  if (ready.length > 0) {
+    console.log(`Next: Run task-executor on ${ready[0].id}`);
+    console.log(`  task-executor execute --issue ${ready[0].id} --project ${project}`);
+  } else if (pending > 0) {
+    console.log('⚠️  All pending stories are blocked. Resolve dependencies first.');
+  } else {
+    console.log('🎉 All stories complete!');
+  }
+}

package/template/workers/dev-team/project-manager/src/skills/update-learnings.ts

@@ -0,0 +1,94 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+interface Learning {
+  type: 'project' | 'pattern' | 'troubleshoot' | 'workflow';
+  category?: string;
+  content: string;
+  task?: string;
+}
+
+interface UpdateLearningsOptions {
+  project?: string;
+  dryRun?: boolean;
+}
+
+const KNOWLEDGE_BASE = path.join(process.cwd(), '..', '..', '..', 'knowledge', 'dev-team');
+
+export async function updateLearnings(options: UpdateLearningsOptions): Promise<void> {
+  const { project, dryRun } = options;
+
+  // Read learnings from stdin or prompt
+  console.log('=== Update Learnings ===\n');
+  console.log('Paste learning report (JSON format), then press Ctrl+D:\n');
+
+  // In practice, this would read from stdin or a file
+  // For now, show the expected format
+  console.log('Expected format:');
+  console.log(JSON.stringify({
+    task: 'US-001',
+    learnings: [
+      { type: 'pattern', category: 'backend', content: 'Use retry wrapper for external APIs' },
+      { type: 'troubleshoot', content: 'Redis must connect before auth middleware' }
+    ]
+  }, null, 2));
+
+  console.log('\n[This skill processes learnings from task-executor]');
+  console.log('\nRouting destinations:');
+  console.log('  - project    → projects/{name}/learnings/');
+  console.log('  - pattern    → knowledge/dev-team/patterns/{category}/');
+  console.log('  - troubleshoot → knowledge/dev-team/troubleshooting/');
+  console.log('  - workflow   → knowledge/dev-team/workflows/');
+
+  if (dryRun) {
+    console.log('\n[Dry run mode - no files will be written]');
+  }
+}
+
+export function routeLearning(learning: Learning, project?: string): string {
+  const date = new Date().toISOString().split('T')[0];
+  const slug = learning.content
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .substring(0, 40);
+
+  switch (learning.type) {
+    case 'project':
+      if (!project) throw new Error('Project required for project-specific learnings');
+      return path.join('projects', project, 'learnings', `${date}-${slug}.md`);
+
+    case 'pattern':
+      const category = learning.category || 'general';
+      return path.join(KNOWLEDGE_BASE, 'patterns', category, `${slug}.md`);
+
+    case 'troubleshoot':
+      return path.join(KNOWLEDGE_BASE, 'troubleshooting', `${slug}.md`);
+
+    case 'workflow':
+      return path.join(KNOWLEDGE_BASE, 'workflows', `${slug}.md`);
+
+    default:
+      throw new Error(`Unknown learning type: ${learning.type}`);
+  }
+}
+
+export function formatLearning(learning: Learning, task?: string): string {
+  const lines = [
+    `# ${learning.content.split('.')[0]}`,
+    '',
+    `## Content`,
+    learning.content,
+    ''
+  ];
+
+  if (task) {
+    lines.push(`## Source`);
+    lines.push(`Learned from task: ${task}`);
+    lines.push('');
+  }
+
+  lines.push(`## Date`);
+  lines.push(new Date().toISOString().split('T')[0]);
+
+  return lines.join('\n');
+}

package/template/workers/dev-team/project-manager/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "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"]
+}

package/template/workers/dev-team/project-manager/worker.yaml

@@ -0,0 +1,96 @@
+worker:
+  id: project-manager
+  name: "Project Manager"
+  type: OpsWorker
+  version: "1.0"
+
+execution:
+  mode: on_demand
+  max_runtime: 10m
+  retry_attempts: 1
+
+context:
+  base:
+    - workers/public/dev-team/project-manager/
+    - workers/public/dev-team/project-manager/skills/
+    - knowledge/public/dev-team/workflows/
+  dynamic:
+    - pattern: "projects/{project}/"
+      when: always
+  exclude:
+    - node_modules/
+    - dist/
+    - "*.log"
+
+verification:
+  post_execute:
+    - check: typescript
+      command: npm run typecheck
+  approval_required: true
+
+output:
+  destination: workspace/reports/dev-team/
+  format: both
+  naming: "{date}-project-manager-{skill}.{ext}"
+
+mcp:
+  server:
+    command: node
+    args:
+      - dist/mcp-server.js
+    cwd: workers/public/dev-team/project-manager
+  tools:
+    - next_issue
+    - create_prd
+    - update_learnings
+    - project_status
+
+# State Machine (Loom pattern)
+state_machine:
+  enabled: true
+  max_retries: 1
+  hooks:
+    post_execute:
+      - auto_checkpoint
+      - log_metrics
+    on_error:
+      - log_error
+      - checkpoint_error_state
+
+instructions: |
+  # Project Manager
+
+  Orchestrates project execution: PRD lifecycle, issue selection, learning aggregation.
+
+  ## Skills
+
+  | Skill | Description |
+  |-------|-------------|
+  | next-issue | Select next issue from PRD/beads to work on |
+  | create-prd | Create new PRD from requirements |
+  | update-learnings | Route learnings to appropriate knowledge locations |
+  | project-status | Show project progress and blockers |
+
+  ## CLI Usage
+
+  ```bash
+  cd workers/public/dev-team/project-manager
+  node dist/index.js next-issue --project my-feature
+  node dist/index.js create-prd --name "New Feature" --input requirements.md
+  node dist/index.js project-status --project my-feature
+  ```
+
+  ## Workflow
+
+  1. Read PRD/beads for project
+  2. Select next issue (passes=false, dependencies met)
+  3. Spawn task-executor with selected issue
+  4. Receive learnings from task-executor
+  5. Route learnings via update-learnings skill
+  6. Repeat until all issues pass
+
+  ## Human-in-the-loop
+
+  - Before issue selection: Show candidates, get approval
+  - After task completion: Show learnings, confirm routing
+  - On project completion: Summarize outcomes

package/template/workers/dev-team/qa-tester/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@hq/qa-tester",
+  "version": "1.0.0",
+  "description": "Testing, browser automation, and accessibility verification",
+  "main": "dist/index.js",
+  "bin": { "qa-tester": "dist/index.js" },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "dev": "ts-node src/index.ts",
+    "mcp": "node dist/mcp-server.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@playwright/test": "^1.57.0",
+    "@axe-core/playwright": "^4.10.0",
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.7.2",
+    "ts-node": "^10.9.2"
+  }
+}

package/template/workers/dev-team/qa-tester/skills/create-demo-account.md

@@ -0,0 +1,36 @@
+# create-demo-account
+
+Create a demo account for testing purposes.
+
+## Arguments
+
+`$ARGUMENTS` = `--platform <shopify|stripe|etc>` (required)
+
+Optional:
+- `--name <string>` - Account name
+- `--project <name>` - Project context
+
+## Process
+
+1. Identify platform requirements
+2. Generate demo credentials
+3. Create account via API/UI
+4. Store credentials safely
+5. Verify account works
+
+## Output
+
+Demo account details stored in:
+`projects/{project}/test-env/demo-accounts.json`
+
+## Platforms Supported
+
+- Shopify (development store)
+- Stripe (test mode)
+- Custom platforms (via config)
+
+## Human-in-the-loop
+
+- Approve account creation
+- Confirm platform selection
+- Review stored credentials

package/template/workers/dev-team/qa-tester/skills/run-tests.md

@@ -0,0 +1,36 @@
+# run-tests
+
+Run test suite and report results.
+
+## Arguments
+
+`$ARGUMENTS` = `--suite <name>` or `--file <path>` (optional)
+
+Optional:
+- `--repo <path>` - Target repository
+- `--type <unit|e2e|all>` - Test type
+- `--watch` - Watch mode
+
+## Process
+
+1. Detect test framework (Jest, Vitest, Playwright)
+2. Run specified tests
+3. Capture results
+4. Format report
+5. Surface failures with context
+
+## Output
+
+Test report:
+```
+✅ 42 passed
+❌ 2 failed
+⏭️ 3 skipped
+
+Failed tests:
+1. src/api/auth.test.ts:42 - login should return token
+   Error: Expected 200, got 401
+
+2. src/components/Button.test.tsx:18 - renders correctly
+   Error: Snapshot mismatch
+```

package/template/workers/dev-team/qa-tester/skills/write-test.md

@@ -0,0 +1,27 @@
+# write-test
+
+Write a new test for a feature or function.
+
+## Arguments
+
+`$ARGUMENTS` = `--target <file|function>` (required)
+
+Optional:
+- `--repo <path>` - Target repository
+- `--type <unit|integration|e2e>` - Test type
+
+## Process
+
+1. Analyze target code
+2. Identify test cases
+3. Generate test file
+4. Add to test suite
+5. Verify tests pass
+
+## Output
+
+New test file with:
+- Setup/teardown
+- Happy path tests
+- Edge cases
+- Error handling tests

package/template/workers/dev-team/qa-tester/src/index.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+
+const program = new Command();
+
+program
+  .name('qa-tester')
+  .description('Testing, browser automation, and accessibility verification')
+  .version('1.0.0');
+
+program
+  .command('run-tests')
+  .description('Run test suite')
+  .option('--suite <name>', 'Test suite name')
+  .option('--file <path>', 'Specific test file')
+  .option('--repo <path>', 'Target repository')
+  .option('--type <type>', 'Test type: unit|e2e|all')
+  .option('--watch', 'Watch mode')
+  .action(async (options) => {
+    console.log('run-tests:', options);
+  });
+
+program
+  .command('write-test')
+  .description('Write new test for feature')
+  .requiredOption('--target <path>', 'Target file or function')
+  .option('--repo <path>', 'Target repository')
+  .option('--type <type>', 'Test type: unit|integration|e2e')
+  .action(async (options) => {
+    console.log('write-test:', options);
+  });
+
+program
+  .command('visual-regression')
+  .description('Run visual regression tests')
+  .option('--url <url>', 'Target URL')
+  .option('--repo <path>', 'Target repository')
+  .action(async (options) => {
+    console.log('visual-regression:', options);
+  });
+
+program
+  .command('accessibility-scan')
+  .description('Run accessibility audit')
+  .requiredOption('--url <url>', 'Target URL')
+  .option('--standard <wcag>', 'WCAG standard: 2.0|2.1|2.2')
+  .action(async (options) => {
+    console.log('accessibility-scan:', options);
+  });
+
+program
+  .command('create-demo-account')
+  .description('Create demo account for testing')
+  .requiredOption('--platform <name>', 'Platform: shopify|stripe|etc')
+  .option('--name <string>', 'Account name')
+  .option('--project <name>', 'Project context')
+  .action(async (options) => {
+    console.log('create-demo-account:', options);
+  });
+
+program.parse();