@malmhq/intermesh-cli 0.1.0

package/dist/generation/scripts/prepared-work.mjs

@@ -0,0 +1,197 @@
+import { createHash } from 'node:crypto';
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+const JSON_MEDIA = /^(application\/(?:json|[^;]+\+json))(?:;|$)/iu;
+const TEXT_MEDIA = /^text\/plain(?:;|$)/iu;
+const SAFE_SEGMENT = /^[a-z0-9][a-z0-9-]*$/u;
+
+function fail(message) {
+  throw new TypeError(message);
+}
+
+function record(value, name) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) fail(`${name} is invalid`);
+  return value;
+}
+
+function successContent(operation) {
+  const responses = record(operation.responses, 'Operation responses');
+  const successful = Object.keys(responses)
+    .filter((status) => /^2\d\d$/u.test(status))
+    .sort();
+  if (successful.length === 0) fail('Operation has no explicit successful response');
+  const mediaTypes = new Set();
+  for (const status of successful) {
+    const response = record(responses[status], `Response ${status}`);
+    const content = record(response.content, `Response ${status} content`);
+    for (const mediaType of Object.keys(content)) mediaTypes.add(mediaType.toLowerCase());
+  }
+  return [...mediaTypes].sort();
+}
+
+export function responsePattern(capability) {
+  const mediaTypes = successContent(capability.operation);
+  const kinds = new Set(
+    mediaTypes.map((mediaType) => {
+      if (JSON_MEDIA.test(mediaType)) return 'json';
+      if (TEXT_MEDIA.test(mediaType)) return 'text';
+      return 'unsupported';
+    }),
+  );
+  if (kinds.has('unsupported') || kinds.size !== 1)
+    fail(`Unsupported or mixed success response for ${capability.operation_key}`);
+  const derived = [...kinds][0];
+  if (capability.requested_response_pattern === 'file') {
+    if (
+      !capability.context_evidence.some((item) =>
+        /\b(download|save|persist|output\s+to\s+a\s+file)\b/iu.test(item.excerpt),
+      )
+    )
+      fail(`File response lacks exact business evidence: ${capability.operation_key}`);
+    return 'file';
+  }
+  return derived;
+}
+
+function slug(value) {
+  const result = value
+    .toLowerCase()
+    .trim()
+    .replaceAll(/[^a-z0-9]+/gu, '-')
+    .replaceAll(/^-|-$/gu, '');
+  if (!SAFE_SEGMENT.test(result)) fail(`Unsafe command family: ${value}`);
+  return result;
+}
+
+export function createWorkPackets(capabilities, binary) {
+  const sorted = [...capabilities].sort(
+    (a, b) =>
+      a.proposed_command.localeCompare(b.proposed_command) ||
+      a.operation_key.localeCompare(b.operation_key),
+  );
+  const families = new Map();
+  for (const capability of sorted) {
+    const family = capability.proposed_command.trim().split(/\s+/u)[0];
+    if (!family) fail('Proposed command has no family');
+    const values = families.get(family) ?? [];
+    values.push({ ...capability, response_pattern: responsePattern(capability) });
+    families.set(family, values);
+  }
+  const cli = [];
+  for (const [family, values] of [...families].sort(([a], [b]) => a.localeCompare(b))) {
+    for (let offset = 0; offset < values.length; offset += 3) {
+      const chunk = values.slice(offset, offset + 3);
+      const suffix = values.length > 3 ? `-${offset / 3 + 1}` : '';
+      const id = `${slug(family)}${suffix}`;
+      cli.push({
+        id: `cli-${id}`,
+        kind: 'cli',
+        command_family: family,
+        capabilities: chunk.map((item) => {
+          const prepared = { ...item };
+          delete prepared.requested_response_pattern;
+          return prepared;
+        }),
+        writable_paths: [
+          `package/src/commands/${id}.ts`,
+          `package/mock/routes/${id}.ts`,
+          `package/test/${id}.test.ts`,
+        ],
+        helper_signatures: [
+          "../shared/http.js: request({ baseUrl?: string, method: 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT', path: string, query?: URLSearchParams, body?: Uint8Array, mediaType?: string, timeoutMs?: number, workflow?: { summary: string, steps: Array<{ summary: string, depends_on_response?: boolean }> } }): Promise<{ body: Uint8Array; mediaType: string; status: number }>. Pass the complete workflow preview on the first request after validating all locally available inputs.",
+          '../shared/output.js: parseJson(body: Uint8Array): unknown; printSuccess(data: unknown, command: string): void',
+          '../shared/files.js: validateOutputFile(path: string): Promise<void> before the first request; saveFile(path: string, body: Uint8Array, mediaType: string): Promise<{ path: string; media_type: string }>',
+          '../shared/errors.js: throw new CliError(cliErrors.invalidInput(message)) for source-specific validation failures',
+        ],
+        focused_check: `pnpm exec tsx --test test/${id}.test.ts`,
+      });
+    }
+  }
+  return {
+    cli,
+    skill: {
+      id: 'skill-customer-workflows',
+      kind: 'skill',
+      capabilities: sorted.map((item) => item.operation_key),
+      writable_paths: [
+        'package/README.md',
+        `package/skills/${binary}-workflow/**`,
+        'package/skills/<focused-name>/SKILL.md',
+      ],
+      excluded_paths: [`package/skills/${binary}-cli-management/**`],
+      focused_check: 'validate Skill frontmatter and command names against trusted work packets',
+    },
+  };
+}
+
+function commandScaffold(packet) {
+  return `import type { Command } from 'commander';\n\n// Assigned operations: ${packet.capabilities.map((item) => item.operation_key).join(', ')}\n// Fill only this command family's customer-specific behavior.\nexport function register(program: Command): void {\n  void program;\n}\n`;
+}
+
+function mockScaffold(packet) {
+  return `import type { MockRoute } from '../types.js';\n\n// Synthetic offline routes for: ${packet.capabilities.map((item) => item.operation_key).join(', ')}\nexport const routes: MockRoute[] = [];\n`;
+}
+
+function testScaffold(packet) {
+  return `import test from 'node:test';\n\ntest.todo(${JSON.stringify(`implement focused coverage for ${packet.command_family}`)});\n`;
+}
+
+export async function scaffoldPreparedWork(packageDirectory, leadInput) {
+  const packets = leadInput.work_packets.cli;
+  await mkdir(join(packageDirectory, 'src/commands'), { recursive: true });
+  await mkdir(join(packageDirectory, 'mock/routes'), { recursive: true });
+  await mkdir(join(packageDirectory, 'test'), { recursive: true });
+  const imports = [];
+  const registrations = [];
+  const mockImports = [];
+  const mockRoutes = [];
+  for (const [index, packet] of packets.entries()) {
+    const id = packet.id.slice(4);
+    await writeFile(join(packageDirectory, `src/commands/${id}.ts`), commandScaffold(packet), {
+      flag: 'wx',
+    });
+    await writeFile(join(packageDirectory, `mock/routes/${id}.ts`), mockScaffold(packet), {
+      flag: 'wx',
+    });
+    await writeFile(join(packageDirectory, `test/${id}.test.ts`), testScaffold(packet), {
+      flag: 'wx',
+    });
+    imports.push(`import { register as register${index} } from './commands/${id}.js';`);
+    registrations.push(`  register${index}(program);`);
+    mockImports.push(`import { routes as routes${index} } from './routes/${id}.js';`);
+    mockRoutes.push(`...routes${index}`);
+  }
+  await writeFile(
+    join(packageDirectory, 'src/commands.ts'),
+    `import type { Command } from 'commander';\n${imports.join('\n')}\n\nexport function registerCommands(program: Command): void {\n${registrations.join('\n')}\n}\n`,
+  );
+  await writeFile(
+    join(packageDirectory, 'mock/routes.ts'),
+    `import type { MockRoute } from './types.js';\n${mockImports.join('\n')}\n\nexport const routes: MockRoute[] = [${mockRoutes.join(', ')}];\n`,
+  );
+  const capabilities = leadInput.capabilities
+    .map((item) => ({
+      command: item.proposed_command,
+      method: item.operation.method,
+      path: item.operation.path,
+      effect: item.effect,
+    }))
+    .sort((a, b) => a.command.localeCompare(b.command));
+  await writeFile(
+    join(packageDirectory, 'capabilities.json'),
+    `${JSON.stringify({ commands: capabilities, excluded: [] }, null, 2)}\n`,
+  );
+  const protectedFiles = ['src/commands.ts', 'mock/routes.ts', 'capabilities.json'];
+  const hashes = {};
+  for (const path of protectedFiles) {
+    const bytes = await readFile(join(packageDirectory, path));
+    hashes[path] = createHash('sha256').update(bytes).digest('hex');
+    await chmod(join(packageDirectory, path), 0o444);
+  }
+  return hashes;
+}
+
+export async function readLeadInput(path) {
+  return record(JSON.parse(await readFile(path, 'utf8')), 'Lead input');
+}