gswd 0.1.0

package/bin/gswd-tools.cjs

@@ -0,0 +1,716 @@
+#!/usr/bin/env node
+
+/**
+ * GSWD Tools — CLI utility for GSWD workflow operations
+ *
+ * Usage: node gswd-tools.cjs <command> [args]
+ *
+ * Commands:
+ *   init [--project-slug <slug>]         Initialize STATE.json + config.json
+ *   status                               Show per-stage status
+ *   state read                           Read STATE.json
+ *   state update-stage <stage> <status>  Update stage status
+ *   state checkpoint <workflow> <id>     Write checkpoint
+ *   config read                          Read config.json gswd section
+ *   config merge [--overrides json]      Merge gswd config
+ *   render banner <name>                 Render stage banner
+ *   render checkpoint <json>             Render checkpoint box
+ *   render next-up <json>                Render Next Up block
+ *   id-allocate <type> <agent> [size]    Allocate ID range
+ *   id-ranges [type]                     Get allocated ranges
+ *   id-reset                             Reset ID registry
+ *   parse ids <file> [--type X]          Extract IDs from file
+ *   parse validate-headings <file> <type>  Validate headings
+ *   commit <message> [--files f1 f2]     Commit planning docs
+ *   imagine [@idea.md] [--auto] [--skip-research]  Run Imagine workflow
+ *   specify [--auto] [--skip-agents]     Run Specify workflow
+ *   audit [--auto-fix]                   Run Audit workflow
+ *   compile                              Run Compile workflow
+ *   bootstrap [@idea.md] [--auto] [--resume] [--skip-research] [--policy <name>]  Run full pipeline
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// ─── Module Loading ──────────────────────────────────────────────────────────
+
+/**
+ * Load a lib/ TypeScript module. Tries compiled dist/ first, falls back to
+ * tsx require hook for development.
+ */
+function loadModule(name) {
+  const distPath = path.join(__dirname, '..', 'dist', 'lib', `${name}.js`);
+  const srcPath = path.join(__dirname, '..', 'lib', `${name}.ts`);
+
+  // Try compiled dist/ first
+  try {
+    return require(distPath);
+  } catch (_e) {
+    // Fall through
+  }
+
+  // Try tsx require hook (development mode)
+  try {
+    // Register tsx if not already registered
+    if (!global.__tsxRegistered) {
+      require('tsx/cjs');
+      global.__tsxRegistered = true;
+    }
+    return require(srcPath);
+  } catch (_e) {
+    // Fall through
+  }
+
+  // Try direct require of .ts (may work with ts-node or similar)
+  try {
+    return require(srcPath);
+  } catch (e) {
+    outputError(`Failed to load module '${name}'. Run 'npm run build' or ensure tsx is installed.\n${e.message}`);
+    process.exit(1);
+  }
+}
+
+// ─── Resolve Paths ───────────────────────────────────────────────────────────
+
+const CWD = process.cwd();
+const PLANNING_DIR = path.join(CWD, '.planning');
+const GSWD_DIR = path.join(PLANNING_DIR, 'gswd');
+const STATE_PATH = path.join(GSWD_DIR, 'STATE.json');
+const CONFIG_PATH = path.join(PLANNING_DIR, 'config.json');
+
+// ─── Output Helpers ──────────────────────────────────────────────────────────
+
+function outputJson(data) {
+  process.stdout.write(JSON.stringify(data, null, 2) + '\n');
+}
+
+function outputError(message) {
+  process.stdout.write(JSON.stringify({ error: true, message }) + '\n');
+}
+
+function outputText(text) {
+  process.stdout.write(text + '\n');
+}
+
+// ─── Argument Parsing ────────────────────────────────────────────────────────
+
+const args = process.argv.slice(2);
+const command = args[0];
+const subcommand = args[1];
+
+function getFlag(flag) {
+  const idx = args.indexOf(flag);
+  if (idx === -1) return null;
+  return args[idx + 1] || null;
+}
+
+function hasFlag(flag) {
+  return args.includes(flag);
+}
+
+// ─── Command Dispatch ────────────────────────────────────────────────────────
+
+function printUsage() {
+  outputText(`GSWD Tools — CLI utility for GSWD workflow operations
+
+Usage: node gswd-tools.cjs <command> [args]
+
+Commands:
+  init [--project-slug <slug>]         Initialize STATE.json + config.json
+  status                               Show per-stage status
+  state read                           Read STATE.json
+  state update-stage <stage> <status>  Update stage status
+  state checkpoint <workflow> <id>     Write checkpoint
+  config read                          Read config.json gswd section
+  config merge [--overrides json]      Merge gswd config
+  render banner <name>                 Render stage banner
+  render checkpoint <json>             Render checkpoint box
+  render next-up <json>                Render Next Up block
+  id-allocate <type> <agent> [size]    Allocate ID range
+  id-ranges [type]                     Get allocated ranges
+  id-reset                             Reset ID registry
+  parse ids <file> [--type X]          Extract IDs from file
+  parse validate-headings <file> <type>  Validate headings
+  commit <message> [--files f1 f2]     Commit planning docs
+  imagine [@idea.md] [--auto] [--skip-research]  Run Imagine workflow
+  specify [--auto] [--skip-agents]     Run Specify workflow
+  audit [--auto-fix]                   Run Audit workflow
+  compile                              Run Compile workflow
+  bootstrap [@idea.md] [--auto] [--resume] [--skip-research] [--policy <name>]  Run full pipeline`);
+}
+
+try {
+  switch (command) {
+    case 'init':
+      handleInit();
+      break;
+    case 'status':
+      handleStatus();
+      break;
+    case 'state':
+      handleState();
+      break;
+    case 'config':
+      handleConfig();
+      break;
+    case 'render':
+      handleRender();
+      break;
+    case 'id-allocate':
+      handleIdAllocate();
+      break;
+    case 'id-ranges':
+      handleIdRanges();
+      break;
+    case 'id-reset':
+      handleIdReset();
+      break;
+    case 'parse':
+      handleParse();
+      break;
+    case 'commit':
+      handleCommit();
+      break;
+    case 'imagine':
+      handleImagine();
+      break;
+    case 'specify':
+      handleSpecify();
+      break;
+    case 'audit':
+      handleAudit();
+      break;
+    case 'compile':
+      handleCompile();
+      break;
+    case 'bootstrap':
+      handleBootstrap();
+      break;
+    case '--help':
+    case '-h':
+    case 'help':
+      printUsage();
+      break;
+    default:
+      if (!command) {
+        printUsage();
+        process.exit(1);
+      }
+      outputError(`Unknown command: ${command}`);
+      printUsage();
+      process.exit(1);
+  }
+} catch (err) {
+  outputError(err.message || String(err));
+  process.exit(1);
+}
+
+// ─── Command Handlers ────────────────────────────────────────────────────────
+
+function handleInit() {
+  const stateModule = loadModule('state');
+  const configModule = loadModule('config');
+
+  const slug = getFlag('--project-slug') || path.basename(CWD).toLowerCase().replace(/[^a-z0-9-]/g, '-');
+
+  const state = stateModule.initState(GSWD_DIR, slug);
+  configModule.mergeGswdConfig(CONFIG_PATH);
+
+  outputJson({
+    initialized: true,
+    state_path: path.relative(CWD, STATE_PATH),
+    config_path: path.relative(CWD, CONFIG_PATH),
+    project_slug: state.project_slug,
+  });
+}
+
+function handleStatus() {
+  const stateModule = loadModule('state');
+  const renderModule = loadModule('render');
+
+  const state = stateModule.readState(STATE_PATH);
+  if (!state) {
+    outputError('No STATE.json found. Run "gswd-tools.cjs init" first.');
+    process.exit(1);
+  }
+
+  const banner = renderModule.renderBanner('STATUS');
+
+  const stages = ['imagine', 'specify', 'audit', 'compile'];
+  const stageLines = stages.map(s => {
+    const status = state.stage_status[s] || 'not_started';
+    return renderModule.renderStatusLine(
+      s.charAt(0).toUpperCase() + s.slice(1),
+      status
+    );
+  });
+
+  // Calculate progress
+  const doneCount = stages.filter(s => {
+    const st = state.stage_status[s];
+    return st === 'done' || st === 'pass';
+  }).length;
+  const progressBar = renderModule.renderProgressBar(doneCount, stages.length);
+
+  const output = [
+    banner,
+    '',
+    ...stageLines,
+    '',
+    progressBar,
+    '',
+    'Quick Links:',
+    `  STATE.json: ${path.relative(CWD, STATE_PATH)}`,
+    `  Config:     ${path.relative(CWD, CONFIG_PATH)}`,
+  ].join('\n');
+
+  outputText(output);
+}
+
+function handleState() {
+  const stateModule = loadModule('state');
+
+  switch (subcommand) {
+    case 'read': {
+      const state = stateModule.readState(STATE_PATH);
+      if (!state) {
+        outputError('No valid STATE.json found.');
+        process.exit(1);
+      }
+      outputJson(state);
+      break;
+    }
+    case 'update-stage': {
+      const stage = args[2];
+      const status = args[3];
+      if (!stage || !status) {
+        outputError('Usage: state update-stage <stage> <status>');
+        process.exit(1);
+      }
+      stateModule.updateStageStatus(STATE_PATH, stage, status);
+      outputJson({ updated: true, stage, status });
+      break;
+    }
+    case 'checkpoint': {
+      const workflow = args[2];
+      const checkpointId = args[3];
+      if (!workflow || !checkpointId) {
+        outputError('Usage: state checkpoint <workflow> <checkpoint_id>');
+        process.exit(1);
+      }
+      stateModule.writeCheckpoint(STATE_PATH, workflow, checkpointId);
+      outputJson({ checkpoint_written: true, workflow, checkpoint_id: checkpointId });
+      break;
+    }
+    default:
+      outputError(`Unknown state subcommand: ${subcommand}`);
+      process.exit(1);
+  }
+}
+
+function handleConfig() {
+  const configModule = loadModule('config');
+
+  switch (subcommand) {
+    case 'read': {
+      const config = configModule.getGswdConfig(CONFIG_PATH);
+      outputJson(config);
+      break;
+    }
+    case 'merge': {
+      const overridesRaw = getFlag('--overrides');
+      let overrides;
+      if (overridesRaw) {
+        try {
+          overrides = JSON.parse(overridesRaw);
+        } catch {
+          outputError('Invalid JSON for --overrides');
+          process.exit(1);
+        }
+      }
+      configModule.mergeGswdConfig(CONFIG_PATH, overrides);
+      outputJson({ merged: true });
+      break;
+    }
+    default:
+      outputError(`Unknown config subcommand: ${subcommand}`);
+      process.exit(1);
+  }
+}
+
+function handleRender() {
+  const renderModule = loadModule('render');
+
+  switch (subcommand) {
+    case 'banner': {
+      const name = args[2];
+      if (!name) {
+        outputError('Usage: render banner <name>');
+        process.exit(1);
+      }
+      outputText(renderModule.renderBanner(name));
+      break;
+    }
+    case 'checkpoint': {
+      const jsonStr = args[2];
+      if (!jsonStr) {
+        outputError('Usage: render checkpoint <json>');
+        process.exit(1);
+      }
+      try {
+        const data = JSON.parse(jsonStr);
+        outputText(renderModule.renderCheckpoint(
+          data.type || 'Checkpoint',
+          data.context || '',
+          data.options || [],
+          data.action || 'Select an option'
+        ));
+      } catch {
+        outputError('Invalid JSON for checkpoint render');
+        process.exit(1);
+      }
+      break;
+    }
+    case 'next-up': {
+      const jsonStr = args[2];
+      if (!jsonStr) {
+        outputError('Usage: render next-up <json>');
+        process.exit(1);
+      }
+      try {
+        const data = JSON.parse(jsonStr);
+        outputText(renderModule.renderNextUp(
+          data.files || [],
+          data.next_command || '',
+          data.also_available
+        ));
+      } catch {
+        outputError('Invalid JSON for next-up render');
+        process.exit(1);
+      }
+      break;
+    }
+    default:
+      outputError(`Unknown render subcommand: ${subcommand}`);
+      process.exit(1);
+  }
+}
+
+function handleIdAllocate() {
+  const stateModule = loadModule('state');
+
+  const idType = args[1];
+  const agent = args[2];
+  const size = args[3] ? parseInt(args[3], 10) : undefined;
+
+  if (!idType || !agent) {
+    outputError('Usage: id-allocate <type> <agent> [size]');
+    process.exit(1);
+  }
+
+  const range = stateModule.allocateIdRange(STATE_PATH, idType, agent, size);
+  outputJson({ type: idType, agent, ...range });
+}
+
+function handleIdRanges() {
+  const stateModule = loadModule('state');
+  const idType = args[1] || undefined;
+  const ranges = stateModule.getIdRanges(STATE_PATH, idType);
+  outputJson(ranges);
+}
+
+function handleIdReset() {
+  const stateModule = loadModule('state');
+  stateModule.resetIdRegistry(STATE_PATH);
+  outputJson({ reset: true });
+}
+
+function handleParse() {
+  const parseModule = loadModule('parse');
+
+  switch (subcommand) {
+    case 'ids': {
+      const filePath = args[2];
+      if (!filePath) {
+        outputError('Usage: parse ids <file> [--type X]');
+        process.exit(1);
+      }
+      const resolvedPath = path.resolve(CWD, filePath);
+      if (!fs.existsSync(resolvedPath)) {
+        outputError(`File not found: ${resolvedPath}`);
+        process.exit(1);
+      }
+      const content = fs.readFileSync(resolvedPath, 'utf-8');
+      const idType = getFlag('--type') || undefined;
+      const ids = parseModule.extractIds(content, idType);
+      outputJson(ids);
+      break;
+    }
+    case 'validate-headings': {
+      const filePath = args[2];
+      const fileType = args[3];
+      if (!filePath || !fileType) {
+        outputError('Usage: parse validate-headings <file> <type>');
+        process.exit(1);
+      }
+      const resolvedPath = path.resolve(CWD, filePath);
+      if (!fs.existsSync(resolvedPath)) {
+        outputError(`File not found: ${resolvedPath}`);
+        process.exit(1);
+      }
+      const content = fs.readFileSync(resolvedPath, 'utf-8');
+      const result = parseModule.validateHeadings(content, fileType);
+      outputJson(result);
+      break;
+    }
+    default:
+      outputError(`Unknown parse subcommand: ${subcommand}`);
+      process.exit(1);
+  }
+}
+
+function handleCommit() {
+  const message = args[1];
+  if (!message) {
+    outputError('Usage: commit <message> [--files f1 f2]');
+    process.exit(1);
+  }
+
+  // Collect files to commit
+  let files = [];
+  const filesIdx = args.indexOf('--files');
+  if (filesIdx !== -1) {
+    files = args.slice(filesIdx + 1);
+  }
+
+  try {
+    if (files.length > 0) {
+      execSync(`git add ${files.map(f => `"${f}"`).join(' ')}`, {
+        cwd: CWD,
+        stdio: 'pipe',
+      });
+    }
+
+    const result = execSync(`git commit -m "${message.replace(/"/g, '\\"')}"`, {
+      cwd: CWD,
+      stdio: 'pipe',
+      encoding: 'utf-8',
+    });
+
+    // Extract commit hash
+    const hashMatch = result.match(/\[[\w-]+ ([a-f0-9]+)\]/);
+    const hash = hashMatch ? hashMatch[1] : 'unknown';
+
+    outputJson({
+      committed: true,
+      hash,
+      message,
+      files_staged: files.length > 0 ? files : 'all staged',
+    });
+  } catch (err) {
+    outputError(`Commit failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function handleImagine() {
+  const imagineModule = loadModule('imagine');
+
+  const autoMode = hasFlag('--auto');
+  const skipResearch = hasFlag('--skip-research');
+
+  // Find idea file: look for arg starting with @ or ending with .md
+  let ideaFilePath = null;
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith('--')) continue;
+    if (arg.startsWith('@')) {
+      ideaFilePath = path.resolve(CWD, arg.slice(1));
+      break;
+    }
+    if (arg.endsWith('.md')) {
+      ideaFilePath = path.resolve(CWD, arg);
+      break;
+    }
+  }
+
+  if (!ideaFilePath) {
+    // No idea file — start interactive 3-question intake
+    const readline = require('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+    rl.question('Vision -- what does it do? ', function(vision) {
+      rl.question('User -- who is it for? ', function(user) {
+        rl.question('Why now -- what is the opportunity? ', function(whyNow) {
+          rl.close();
+
+          const intakeOptions = {
+            intakeAnswers: { vision, user, whyNow },
+            autoMode,
+            skipResearch,
+            planningDir: PLANNING_DIR,
+            configPath: CONFIG_PATH,
+          };
+
+          imagineModule.runImagine(intakeOptions).then(function(result) {
+            outputJson(result);
+            if (result.status === 'error' || result.status === 'gate_failed') {
+              process.exit(1);
+            }
+          }).catch(function(err) {
+            outputError(err.message || String(err));
+            process.exit(1);
+          });
+        });
+      });
+    });
+    return;
+  }
+
+  const options = {
+    ideaFilePath,
+    autoMode,
+    skipResearch,
+    planningDir: PLANNING_DIR,
+    configPath: CONFIG_PATH,
+  };
+
+  // runImagine is async, handle with promise
+  imagineModule.runImagine(options).then(function(result) {
+    outputJson(result);
+    if (result.status === 'error' || result.status === 'gate_failed') {
+      process.exit(1);
+    }
+  }).catch(function(err) {
+    outputError(err.message || String(err));
+    process.exit(1);
+  });
+}
+
+function handleSpecify() {
+  const specifyModule = loadModule('specify');
+
+  const autoMode = hasFlag('--auto');
+  const skipAgents = hasFlag('--skip-agents');
+
+  const budgetFlag = getFlag('--integration-budget');
+  const integrationBudget = budgetFlag ? parseInt(budgetFlag, 10) : undefined;
+
+  const options = {
+    auto: autoMode,
+    skipAgents,
+    integrationBudget,
+    planningDir: PLANNING_DIR,
+    configPath: CONFIG_PATH,
+  };
+
+  // runSpecify is async, handle with promise
+  specifyModule.runSpecify(options).then(function(result) {
+    outputJson(result);
+    if (result.status === 'failed') {
+      process.exit(1);
+    }
+  }).catch(function(err) {
+    outputError(err.message || String(err));
+    process.exit(1);
+  });
+}
+
+function handleBootstrap() {
+  const bootstrapModule = loadModule('bootstrap');
+
+  const autoMode = hasFlag('--auto');
+  const resume = hasFlag('--resume');
+  const skipResearch = hasFlag('--skip-research');
+  const policyFlag = getFlag('--policy');
+
+  // Find idea file: @ prefix or .md extension (same logic as handleImagine)
+  let ideaFilePath = null;
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith('--')) continue;
+    if (arg.startsWith('@')) {
+      ideaFilePath = path.resolve(CWD, arg.slice(1));
+      break;
+    }
+    if (arg.endsWith('.md')) {
+      ideaFilePath = path.resolve(CWD, arg);
+      break;
+    }
+  }
+
+  const options = {
+    ideaFilePath,
+    auto: autoMode,
+    resume,
+    skipResearch,
+    policy: policyFlag || undefined,
+    planningDir: PLANNING_DIR,
+    configPath: CONFIG_PATH,
+  };
+
+  bootstrapModule.runBootstrap(options).then(function(result) {
+    outputJson(result);
+    if (result.status === 'failed' || result.status === 'interrupted') {
+      process.exit(1);
+    }
+  }).catch(function(err) {
+    outputError(err.message || String(err));
+    process.exit(1);
+  });
+}
+
+function handleAudit() {
+  const auditModule = loadModule('audit');
+
+  const autoFix = hasFlag('--auto-fix');
+
+  try {
+    const result = auditModule.runAuditWorkflow({
+      planningDir: PLANNING_DIR,
+      statePath: STATE_PATH,
+      autoFix,
+      maxCycles: 2,
+    });
+
+    outputJson({
+      passed: result.passed,
+      autoFixCycles: result.autoFixCycles,
+      reportPath: result.reportPath,
+    });
+
+    if (!result.passed) {
+      process.exit(1);
+    }
+  } catch (err) {
+    outputError(err.message || String(err));
+    process.exit(1);
+  }
+}
+
+function handleCompile() {
+  const compileModule = loadModule('compile');
+
+  try {
+    const result = compileModule.runCompileWorkflow({
+      planningDir: PLANNING_DIR,
+      statePath: STATE_PATH,
+    });
+
+    outputJson({
+      passed: result.passed,
+      filesWritten: result.filesWritten,
+      error: result.error,
+    });
+
+    if (!result.passed) {
+      process.exit(1);
+    }
+  } catch (err) {
+    outputError(err.message || String(err));
+    process.exit(1);
+  }
+}