create-hq 6.0.0 → 10.0.0

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

@@ -1,27 +0,0 @@
-{
-  "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

@@ -1,70 +0,0 @@
-# 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

@@ -1,62 +0,0 @@
-# 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

@@ -1,51 +0,0 @@
-#!/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

@@ -1,109 +0,0 @@
-#!/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

@@ -1,122 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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

@@ -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"]
-}