create-hq 5.0.0

package/template/workers/dev-team/backend-dev/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@hq/backend-dev",
+  "version": "1.0.0",
+  "description": "API implementation, business logic, and server-side integrations",
+  "main": "dist/index.js",
+  "bin": {
+    "backend-dev": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "dev": "ts-node src/index.ts",
+    "mcp": "node dist/mcp-server.js"
+  },
+  "keywords": ["hq", "worker", "backend", "api", "nodejs"],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.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/backend-dev/skills/implement-endpoint.md

@@ -0,0 +1,70 @@
+# implement-endpoint
+
+Create a new API endpoint based on specification.
+
+## Arguments
+
+`$ARGUMENTS` = `--spec <method path>` (required, e.g., "POST /api/users")
+
+Optional:
+- `--repo <path>` - Target repository
+- `--types <file>` - TypeScript types file to use
+
+## Process
+
+1. **Parse Specification**
+   - Extract HTTP method
+   - Extract path and parameters
+   - Identify resource and action
+
+2. **Analyze Existing Patterns**
+   - Find API routes in repo
+   - Match naming conventions
+   - Identify auth patterns
+
+3. **Generate Implementation**
+   - Route handler
+   - Input validation
+   - Business logic call
+   - Response formatting
+   - Error handling
+
+4. **Add Tests**
+   - Unit test for handler
+   - Integration test if applicable
+
+5. **Present for Approval**
+   - Show generated code
+   - Get human approval
+
+## Output
+
+New files:
+- `src/app/api/{resource}/route.ts` (Next.js) or
+- `src/routes/{resource}.ts` (Express)
+
+Test files:
+- `src/app/api/{resource}/route.test.ts`
+
+## Example
+
+```bash
+node dist/index.js implement-endpoint --spec "POST /api/auth/login" --repo repos/my-app
+
+# Output:
+# === Implementing: POST /api/auth/login ===
+#
+# Pattern detected: Next.js App Router
+#
+# Will create:
+#   src/app/api/auth/login/route.ts
+#   src/app/api/auth/login/route.test.ts
+#
+# Implementation:
+#   - Validate email/password input
+#   - Call AuthService.login()
+#   - Return user + token
+#   - Handle errors (400, 401, 500)
+#
+# [Approve? y/n/modify]
+```

package/template/workers/dev-team/backend-dev/skills/implement-service.md

@@ -0,0 +1,62 @@
+# implement-service
+
+Create a service/business logic layer.
+
+## Arguments
+
+`$ARGUMENTS` = `--name <ServiceName>` (required)
+
+Optional:
+- `--repo <path>` - Target repository
+- `--methods <list>` - Comma-separated method names
+
+## Process
+
+1. **Analyze Requirements**
+   - Parse service name
+   - Infer domain from name
+   - Identify dependencies
+
+2. **Check Existing Services**
+   - Find service patterns
+   - Match conventions
+   - Identify shared utilities
+
+3. **Generate Service**
+   - Class/module structure
+   - Method implementations
+   - Dependency injection
+   - Type definitions
+
+4. **Add Tests**
+   - Unit tests per method
+   - Mock dependencies
+
+5. **Present for Approval**
+
+## Output
+
+New files:
+- `src/services/{name}.ts`
+- `src/services/{name}.test.ts`
+
+## Example
+
+```bash
+node dist/index.js implement-service --name "UserService" --methods "create,findById,update,delete"
+
+# Output:
+# === Implementing: UserService ===
+#
+# Methods:
+#   - create(data: CreateUserInput): Promise<User>
+#   - findById(id: string): Promise<User | null>
+#   - update(id: string, data: UpdateUserInput): Promise<User>
+#   - delete(id: string): Promise<void>
+#
+# Dependencies:
+#   - Database (Prisma/Drizzle)
+#   - EmailService (optional)
+#
+# [Approve? y/n/modify]
+```

package/template/workers/dev-team/backend-dev/src/index.ts

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { implementEndpoint } from './skills/implement-endpoint';
+import { implementService } from './skills/implement-service';
+
+const program = new Command();
+
+program
+  .name('backend-dev')
+  .description('API implementation, business logic, and server-side integrations')
+  .version('1.0.0');
+
+program
+  .command('implement-endpoint')
+  .description('Create a new API endpoint')
+  .requiredOption('--spec <spec>', 'Endpoint spec (e.g., "POST /api/users")')
+  .option('--repo <path>', 'Target repository')
+  .option('--types <file>', 'TypeScript types file')
+  .action(async (options) => {
+    await implementEndpoint(options);
+  });
+
+program
+  .command('implement-service')
+  .description('Create a service/business logic layer')
+  .requiredOption('--name <name>', 'Service name')
+  .option('--repo <path>', 'Target repository')
+  .option('--methods <list>', 'Comma-separated method names')
+  .action(async (options) => {
+    await implementService(options);
+  });
+
+program
+  .command('add-middleware')
+  .description('Add Express/Next.js middleware')
+  .requiredOption('--name <name>', 'Middleware name')
+  .option('--repo <path>', 'Target repository')
+  .action(async (options) => {
+    console.log('add-middleware not yet implemented');
+  });
+
+program
+  .command('fix-backend-bug')
+  .description('Fix server-side bug')
+  .requiredOption('--issue <description>', 'Bug description')
+  .option('--repo <path>', 'Target repository')
+  .action(async (options) => {
+    console.log('fix-backend-bug not yet implemented');
+  });
+
+program.parse();

package/template/workers/dev-team/backend-dev/src/mcp-server.ts

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+
+const server = new Server(
+  { name: 'backend-dev', version: '1.0.0' },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: 'implement_endpoint',
+        description: 'Create a new API endpoint',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            spec: { type: 'string', description: 'Endpoint spec (e.g., "POST /api/users")' },
+            repo: { type: 'string', description: 'Target repository' },
+            types: { type: 'string', description: 'TypeScript types file' },
+          },
+          required: ['spec'],
+        },
+      },
+      {
+        name: 'implement_service',
+        description: 'Create a service/business logic layer',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Service name' },
+            repo: { type: 'string', description: 'Target repository' },
+            methods: { type: 'string', description: 'Comma-separated method names' },
+          },
+          required: ['name'],
+        },
+      },
+      {
+        name: 'add_middleware',
+        description: 'Add Express/Next.js middleware',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Middleware name' },
+            repo: { type: 'string', description: 'Target repository' },
+          },
+          required: ['name'],
+        },
+      },
+      {
+        name: 'fix_backend_bug',
+        description: 'Fix server-side bug',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            issue: { type: 'string', description: 'Bug description' },
+            repo: { type: 'string', description: 'Target repository' },
+          },
+          required: ['issue'],
+        },
+      },
+    ],
+  };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case 'implement_endpoint': {
+        const { implementEndpoint } = await import('./skills/implement-endpoint');
+        const result = await captureOutput(() => implementEndpoint(args as any));
+        return { content: [{ type: 'text', text: result }] };
+      }
+      case 'implement_service': {
+        const { implementService } = await import('./skills/implement-service');
+        const result = await captureOutput(() => implementService(args as any));
+        return { content: [{ type: 'text', text: result }] };
+      }
+      default:
+        return { content: [{ type: 'text', text: `Tool ${name} not yet implemented` }] };
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
+  }
+});
+
+async function captureOutput(fn: () => Promise<any>): Promise<string> {
+  const logs: string[] = [];
+  const orig = { log: console.log, error: console.error };
+  console.log = (...args) => logs.push(args.join(' '));
+  console.error = (...args) => logs.push(`ERROR: ${args.join(' ')}`);
+  try { await fn(); } finally { Object.assign(console, orig); }
+  return logs.join('\n');
+}
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch(console.error);

package/template/workers/dev-team/backend-dev/src/skills/implement-endpoint.ts

@@ -0,0 +1,122 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+interface ImplementEndpointOptions {
+  spec: string;
+  repo?: string;
+  types?: string;
+}
+
+export async function implementEndpoint(options: ImplementEndpointOptions): Promise<void> {
+  const { spec, repo, types } = options;
+
+  // Parse spec: "POST /api/users"
+  const [method, endpoint] = spec.split(' ');
+  const segments = endpoint.replace('/api/', '').split('/');
+  const resource = segments[0];
+
+  console.log(`\n=== Implementing: ${spec} ===\n`);
+
+  // Detect framework
+  let framework = 'unknown';
+  if (repo) {
+    if (fs.existsSync(path.join(repo, 'src/app/api'))) {
+      framework = 'nextjs-app-router';
+    } else if (fs.existsSync(path.join(repo, 'src/pages/api'))) {
+      framework = 'nextjs-pages-router';
+    } else if (fs.existsSync(path.join(repo, 'src/routes'))) {
+      framework = 'express';
+    }
+    console.log(`Pattern detected: ${framework}`);
+  }
+
+  // Generate file paths
+  const routePath = framework === 'nextjs-app-router'
+    ? `src/app/api/${segments.join('/')}/route.ts`
+    : `src/routes/${resource}.ts`;
+
+  const testPath = routePath.replace('.ts', '.test.ts');
+
+  console.log('\nWill create:');
+  console.log(`  ${routePath}`);
+  console.log(`  ${testPath}`);
+
+  // Generate implementation
+  const code = generateEndpointCode(method, endpoint, resource, framework);
+
+  console.log('\n' + '-'.repeat(40));
+  console.log('\nGenerated code:\n');
+  console.log(code);
+
+  console.log('\n[Human approval required]');
+  console.log('Approve implementation? [y/n/modify]');
+
+  // In production, would write files after approval
+  console.log('\nOn approval, files will be written and tests run.');
+}
+
+function generateEndpointCode(method: string, endpoint: string, resource: string, framework: string): string {
+  const Resource = resource.charAt(0).toUpperCase() + resource.slice(1);
+
+  if (framework === 'nextjs-app-router') {
+    return `import { NextRequest, NextResponse } from 'next/server';
+import { z } from 'zod';
+import { ${resource}Service } from '@/services/${resource}';
+
+const ${method.toLowerCase()}Schema = z.object({
+  // Define request body schema
+});
+
+export async function ${method}(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const validated = ${method.toLowerCase()}Schema.parse(body);
+
+    const result = await ${resource}Service.${method.toLowerCase()}(validated);
+
+    return NextResponse.json(result, { status: ${method === 'POST' ? 201 : 200} });
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json(
+        { error: 'Validation failed', details: error.errors },
+        { status: 400 }
+      );
+    }
+
+    console.error('${method} ${endpoint} error:', error);
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}
+`;
+  }
+
+  // Express/generic
+  return `import { Router, Request, Response, NextFunction } from 'express';
+import { z } from 'zod';
+import { ${resource}Service } from '../services/${resource}';
+
+const router = Router();
+
+const ${method.toLowerCase()}Schema = z.object({
+  // Define request body schema
+});
+
+router.${method.toLowerCase()}('${endpoint}', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const validated = ${method.toLowerCase()}Schema.parse(req.body);
+    const result = await ${resource}Service.${method.toLowerCase()}(validated);
+    res.status(${method === 'POST' ? 201 : 200}).json(result);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return res.status(400).json({ error: 'Validation failed', details: error.errors });
+    }
+    next(error);
+  }
+});
+
+export default router;
+`;
+}

package/template/workers/dev-team/backend-dev/src/skills/implement-service.ts

@@ -0,0 +1,126 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+interface ImplementServiceOptions {
+  name: string;
+  repo?: string;
+  methods?: string;
+}
+
+export async function implementService(options: ImplementServiceOptions): Promise<void> {
+  const { name, repo, methods } = options;
+
+  const methodList = methods ? methods.split(',').map(m => m.trim()) : ['create', 'findById', 'update', 'delete'];
+
+  console.log(`\n=== Implementing: ${name} ===\n`);
+
+  // Analyze dependencies
+  const domain = name.replace('Service', '').toLowerCase();
+  const Domain = domain.charAt(0).toUpperCase() + domain.slice(1);
+
+  console.log('Methods:');
+  for (const method of methodList) {
+    const signature = getMethodSignature(method, Domain);
+    console.log(`  - ${method}${signature}`);
+  }
+
+  // Detect database
+  let db = 'unknown';
+  if (repo) {
+    if (fs.existsSync(path.join(repo, 'prisma/schema.prisma'))) {
+      db = 'prisma';
+    } else if (fs.existsSync(path.join(repo, 'drizzle.config.ts'))) {
+      db = 'drizzle';
+    }
+    console.log(`\nDatabase: ${db}`);
+  }
+
+  console.log('\nDependencies:');
+  console.log(`  - Database (${db})`);
+  console.log('  - Logger');
+
+  // Generate code
+  const code = generateServiceCode(name, Domain, methodList, db);
+
+  console.log('\n' + '-'.repeat(40));
+  console.log('\nGenerated code:\n');
+  console.log(code);
+
+  console.log('\n[Human approval required]');
+  console.log('Approve implementation? [y/n/modify]');
+}
+
+function getMethodSignature(method: string, domain: string): string {
+  switch (method) {
+    case 'create':
+      return `(data: Create${domain}Input): Promise<${domain}>`;
+    case 'findById':
+      return `(id: string): Promise<${domain} | null>`;
+    case 'findAll':
+      return `(options?: FindOptions): Promise<${domain}[]>`;
+    case 'update':
+      return `(id: string, data: Update${domain}Input): Promise<${domain}>`;
+    case 'delete':
+      return `(id: string): Promise<void>`;
+    default:
+      return `(...args: unknown[]): Promise<unknown>`;
+  }
+}
+
+function generateServiceCode(name: string, domain: string, methods: string[], db: string): string {
+  const prismaClient = db === 'prisma' ? `import { prisma } from '@/lib/prisma';` : '';
+
+  const methodImplementations = methods.map(method => {
+    switch (method) {
+      case 'create':
+        return `  async create(data: Create${domain}Input): Promise<${domain}> {
+    ${db === 'prisma' ? `return prisma.${domain.toLowerCase()}.create({ data });` : `// TODO: implement create`}
+  }`;
+      case 'findById':
+        return `  async findById(id: string): Promise<${domain} | null> {
+    ${db === 'prisma' ? `return prisma.${domain.toLowerCase()}.findUnique({ where: { id } });` : `// TODO: implement findById`}
+  }`;
+      case 'findAll':
+        return `  async findAll(options?: { skip?: number; take?: number }): Promise<${domain}[]> {
+    ${db === 'prisma' ? `return prisma.${domain.toLowerCase()}.findMany(options);` : `// TODO: implement findAll`}
+  }`;
+      case 'update':
+        return `  async update(id: string, data: Update${domain}Input): Promise<${domain}> {
+    ${db === 'prisma' ? `return prisma.${domain.toLowerCase()}.update({ where: { id }, data });` : `// TODO: implement update`}
+  }`;
+      case 'delete':
+        return `  async delete(id: string): Promise<void> {
+    ${db === 'prisma' ? `await prisma.${domain.toLowerCase()}.delete({ where: { id } });` : `// TODO: implement delete`}
+  }`;
+      default:
+        return `  async ${method}(...args: unknown[]): Promise<unknown> {
+    // TODO: implement ${method}
+    throw new Error('Not implemented');
+  }`;
+    }
+  }).join('\n\n');
+
+  return `${prismaClient}
+
+export interface ${domain} {
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+  // Add entity fields
+}
+
+export interface Create${domain}Input {
+  // Add create fields
+}
+
+export interface Update${domain}Input {
+  // Add update fields
+}
+
+class ${name} {
+${methodImplementations}
+}
+
+export const ${domain.toLowerCase()}Service = new ${name}();
+`;
+}

package/template/workers/dev-team/backend-dev/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"]
+}