gsdd-cli 0.2.0 → 0.16.1

package/bin/lib/init-flow.mjs

@@ -0,0 +1,267 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, cpSync } from 'fs';
+import { join, isAbsolute } from 'path';
+import { renderSkillContent } from './rendering.mjs';
+import { buildManifest, writeManifest } from './manifest.mjs';
+import { parseFlagValue, parseToolsFlag, parseAutoFlag } from './cli-utils.mjs';
+import { buildDefaultConfig, COST_PROFILES, RIGOR_PROFILES } from './models.mjs';
+import { installProjectTemplates, refreshTemplates } from './templates.mjs';
+import {
+  detectPlatforms,
+  getAdaptersToUpdate,
+  getPostInitRoutingLines,
+  normalizeRequestedTools,
+  resolveAdapters,
+  resolveInteractiveInitSession,
+} from './init-runtime.mjs';
+import { createInitPromptApi } from './init-prompts.mjs';
+
+function validateKindContract(adapter, cwd) {
+  if (!adapter.subagentFiles) return;
+  if (adapter.kind === 'native_capable') {
+    const missing = adapter.subagentFiles
+      .map(f => join(cwd, f))
+      .filter(p => !existsSync(p));
+    if (missing.length > 0) {
+      console.warn(
+        `[WARN] ${adapter.name} adapter (kind=native_capable) missing expected subagent files:\n` +
+        missing.map(p => `  - ${p}`).join('\n')
+      );
+    }
+  } else if (adapter.kind === 'governance_only') {
+    const unexpected = adapter.subagentFiles
+      .map(f => join(cwd, f))
+      .filter(p => existsSync(p));
+    if (unexpected.length > 0) {
+      console.warn(
+        `[WARN] ${adapter.name} adapter (kind=governance_only) unexpectedly generated subagent files:\n` +
+        unexpected.map(p => `  - ${p}`).join('\n')
+      );
+    }
+  }
+}
+
+export function createCmdInit(ctx) {
+  return async function cmdInit(...initArgs) {
+    console.log('gsdd init - setting up GSDD workflow\n');
+
+    const isAuto = parseAutoFlag(initArgs);
+    const toolsFlag = parseFlagValue(initArgs, '--tools');
+    const briefFlag = parseFlagValue(initArgs, '--brief');
+    let briefSource = null;
+
+    if (toolsFlag.invalid) {
+      console.error('ERROR: --tools requires a value. Example: gsdd init --tools claude');
+      process.exitCode = 1;
+      return;
+    }
+
+    if (briefFlag.invalid) {
+      console.error('ERROR: --brief requires a file path. Example: gsdd init --brief project-idea.md');
+      process.exitCode = 1;
+      return;
+    }
+
+    if (briefFlag.value) {
+      briefSource = isAbsolute(briefFlag.value) ? briefFlag.value : join(ctx.cwd, briefFlag.value);
+      if (!existsSync(briefSource)) {
+        console.error(`ERROR: Brief file not found: ${briefFlag.value}`);
+        process.exitCode = 1;
+        return;
+      }
+    }
+
+    const parsedTools = parseToolsFlag(initArgs);
+    if (isAuto && parsedTools.length === 0) {
+      console.error('ERROR: --auto requires --tools <platform>. Example: gsdd init --auto --tools claude');
+      process.exitCode = 1;
+      return;
+    }
+
+    const promptApi = ctx.initPromptApi || createInitPromptApi();
+    const interactiveSession = await resolveInteractiveInitSession({
+      ctx,
+      promptApi,
+      parsedTools,
+      isAuto,
+    });
+
+    const existed = existsSync(ctx.planningDir);
+    mkdirSync(join(ctx.planningDir, 'phases'), { recursive: true });
+    mkdirSync(join(ctx.planningDir, 'research'), { recursive: true });
+    console.log(existed
+      ? '  - .planning/ already exists (ensured subdirectories)'
+      : '  - created .planning/ directory structure');
+
+    installProjectTemplates(ctx);
+    await ensureConfig({
+      cwd: ctx.cwd,
+      planningDir: ctx.planningDir,
+      isAuto,
+      promptApi,
+      preselectedConfig: interactiveSession.config,
+    });
+
+    if (briefSource) {
+      cpSync(briefSource, join(ctx.planningDir, 'PROJECT_BRIEF.md'));
+      console.log('  - copied project brief to .planning/PROJECT_BRIEF.md');
+    }
+
+    generateOpenStandardSkills(ctx.cwd, ctx.workflows);
+    console.log('  - generated open-standard skills (.agents/skills/gsdd-*)');
+
+    for (const adapter of resolveAdapters(ctx.adapters, interactiveSession.adapterTargets)) {
+      adapter.generate();
+      validateKindContract(adapter, ctx.cwd);
+      console.log(`  - ${adapter.summary('generated')}`);
+    }
+
+    const manifest = buildManifest({ planningDir: ctx.planningDir, frameworkVersion: ctx.frameworkVersion });
+    writeManifest(ctx.planningDir, manifest);
+    console.log('  - wrote generation manifest');
+
+    console.log('\nGSDD initialized.');
+    printInitSummary(interactiveSession.config ?? buildDefaultConfig({ autoAdvance: isAuto }));
+    console.log('Next: run the new-project workflow to produce SPEC.md and ROADMAP.md:\n');
+    printPostInitRouting(interactiveSession.selectedRuntimes);
+  };
+}
+
+export function createCmdUpdate(ctx) {
+  return function cmdUpdate(...updateArgs) {
+    const isDry = updateArgs.includes('--dry');
+    const doTemplates = updateArgs.includes('--templates');
+
+    console.log(`gsdd update - regenerating adapter files${isDry ? ' (dry run)' : ''}\n`);
+
+    const parsedTools = parseToolsFlag(updateArgs);
+    const requested = normalizeRequestedTools(parsedTools);
+    const platforms = parsedTools.length > 0 ? requested.adapterTargets : detectPlatforms(ctx.adapters);
+
+    let updated = false;
+
+    if (doTemplates) {
+      refreshTemplates({ ...ctx, isDry });
+      updated = true;
+    }
+
+    if (platforms.length > 0 || existsSync(join(ctx.cwd, '.agents', 'skills'))) {
+      if (isDry) {
+        console.log('  - would update open-standard skills (.agents/skills/gsdd-*)');
+      } else {
+        generateOpenStandardSkills(ctx.cwd, ctx.workflows);
+        console.log('  - updated open-standard skills (.agents/skills/gsdd-*)');
+      }
+      updated = true;
+    }
+
+    for (const adapter of getAdaptersToUpdate(ctx.adapters, platforms)) {
+      if (isDry) {
+        console.log(`  - would update ${adapter.name} adapter`);
+      } else {
+        adapter.generate();
+        validateKindContract(adapter, ctx.cwd);
+        console.log(`  - ${adapter.summary('updated')}`);
+      }
+      updated = true;
+    }
+
+    if (!updated) {
+      console.log('  - no adapters found to update (run `gsdd init` first)');
+    } else if (isDry) {
+      console.log('\nDry run complete. No files were written.\n');
+    } else {
+      if (doTemplates && existsSync(ctx.planningDir)) {
+        const manifest = buildManifest({ planningDir: ctx.planningDir, frameworkVersion: ctx.frameworkVersion });
+        writeManifest(ctx.planningDir, manifest);
+        console.log('  - updated generation manifest');
+      }
+      console.log('\nAdapters updated.\n');
+    }
+  };
+}
+
+function generateOpenStandardSkills(cwd, workflows) {
+  for (const workflow of workflows) {
+    const dir = join(cwd, '.agents', 'skills', workflow.name);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, 'SKILL.md'), renderSkillContent(workflow));
+  }
+}
+
+async function ensureConfig({ cwd, planningDir, isAuto, promptApi, preselectedConfig = null }) {
+  const configFile = join(planningDir, 'config.json');
+  if (existsSync(configFile)) {
+    console.log('  - .planning/config.json already exists');
+    return;
+  }
+
+  if (preselectedConfig) {
+    writeFileSync(configFile, JSON.stringify(preselectedConfig, null, 2));
+    console.log('  - saved .planning/config.json (guided wizard)\n');
+    if (!preselectedConfig.commitDocs) ensureGitignoreEntry(cwd);
+    return;
+  }
+
+  if (isAuto) {
+    console.log('  - auto mode: writing config.json with defaults');
+    writeFileSync(configFile, JSON.stringify(buildDefaultConfig({ autoAdvance: true }), null, 2));
+    console.log('  - saved .planning/config.json (auto mode - autoAdvance enabled)\n');
+    return;
+  }
+
+  if (!process.stdin.isTTY) {
+    console.log('  - non-interactive mode detected: writing config.json with defaults');
+    writeFileSync(configFile, JSON.stringify(buildDefaultConfig(), null, 2));
+    console.log('  - saved .planning/config.json (defaults - re-run gsdd init in a terminal to customize)\n');
+    return;
+  }
+
+  const config = await promptApi.promptForConfig(cwd);
+  writeFileSync(configFile, JSON.stringify(config, null, 2));
+  console.log('  - saved .planning/config.json (guided wizard)\n');
+
+  if (!config.commitDocs) ensureGitignoreEntry(cwd);
+}
+
+function ensureGitignoreEntry(cwd) {
+  const gitignorePath = join(cwd, '.gitignore');
+  const ignoreEntry = '\n# GSDD planning docs (local only)\n.planning/\n';
+
+  if (existsSync(gitignorePath)) {
+    const existing = readFileSync(gitignorePath, 'utf-8');
+    if (!existing.includes('.planning/')) {
+      writeFileSync(gitignorePath, existing + ignoreEntry);
+      console.log('  - added .planning/ to .gitignore');
+    }
+    return;
+  }
+
+  writeFileSync(gitignorePath, ignoreEntry.trimStart());
+  console.log('  - created .gitignore with .planning/ entry');
+}
+
+function printPostInitRouting(selectedRuntimes) {
+  for (const line of getPostInitRoutingLines(selectedRuntimes)) {
+    console.log(line);
+  }
+  console.log('');
+}
+
+function printInitSummary(config) {
+  const rigor = Object.entries(RIGOR_PROFILES).find(([, profile]) => (
+    profile.researchDepth === config.researchDepth
+    && profile.workflow.research === config.workflow?.research
+    && profile.workflow.discuss === config.workflow?.discuss
+    && profile.workflow.planCheck === config.workflow?.planCheck
+    && profile.workflow.verifier === config.workflow?.verifier
+  ))?.[0] ?? 'balanced';
+  const cost = Object.entries(COST_PROFILES).find(([, profile]) => (
+    profile.modelProfile === config.modelProfile
+    && profile.parallelization === config.parallelization
+  ))?.[0] ?? 'balanced';
+
+  console.log(`Rigor: ${rigor}   Cost: ${cost}   Track .planning/ in git: ${config.commitDocs ? 'yes' : 'no'}`);
+  console.log('Workflows: new-project → plan → execute → verify → progress');
+  console.log('Edit .planning/config.json to fine-tune (verifier, gitProtocol, individual workflow flags).');
+  console.log('');
+}

package/bin/lib/init-prompts.mjs

@@ -0,0 +1,247 @@
+import * as readline from 'readline';
+import { DEFAULT_GIT_PROTOCOL, resolveCost, resolveRigor } from './models.mjs';
+import { buildRuntimeChoices, INIT_VERSION, resolveWizardAdapterTargets } from './init-runtime.mjs';
+
+const ANSI = {
+  reset: '\x1b[0m',
+  dim: '\x1b[2m',
+  bold: '\x1b[1m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+};
+
+export function createInitPromptApi({ input = process.stdin, output = process.stdout } = {}) {
+  return {
+    async runInitWizard({ cwd, adapters }) {
+      output.write(`${ANSI.bold}${ANSI.cyan}GSDD Install Wizard${ANSI.reset}\n`);
+      output.write(`${ANSI.dim}Portable skills are always installed. Select the runtimes you want GSDD to feel native in.${ANSI.reset}\n\n`);
+
+      const runtimeChoices = buildRuntimeChoices(adapters);
+      const selectedRuntimes = await promptMultiSelect({
+        input,
+        output,
+        title: 'Step 1 of 3 - Select runtimes',
+        hint: 'Space toggles, Enter confirms.',
+        choices: runtimeChoices,
+      });
+      const installGovernance = await promptConfirm({
+        input,
+        output,
+        title: 'Step 2 of 3 - Repo-wide AGENTS.md governance',
+        prompt: 'Install repo-wide AGENTS.md rules?',
+        defaultValue: false,
+        details: [
+          'Why care: consistent behavioral discipline across sessions and mixed-runtime teams.',
+          'Why skip it: it writes to the repo root, and your selected runtimes already discover .agents/skills/ natively.',
+        ],
+      });
+      const config = await promptForConfig(cwd, { input, output });
+      return {
+        selectedRuntimes,
+        adapterTargets: resolveWizardAdapterTargets(selectedRuntimes, installGovernance),
+        config,
+      };
+    },
+    promptForConfig(cwd) {
+      return promptForConfig(cwd, { input, output });
+    },
+  };
+}
+
+export async function promptForConfig(cwd, { input = process.stdin, output = process.stdout } = {}) {
+  output.write(`\n${ANSI.bold}Step 3 of 3 - Configure planning defaults${ANSI.reset}\n`);
+
+  const rigor = await promptSingleSelect({
+    input,
+    output,
+    title: 'Rigor',
+    choices: [
+      { value: 'quick', label: 'quick', description: 'Faster setup with lighter planning rigor' },
+      { value: 'balanced', label: 'balanced', description: 'Recommended default for most projects' },
+      { value: 'thorough', label: 'thorough', description: 'Maximum research and plan review rigor' },
+    ],
+    defaultIndex: 1,
+  });
+  const cost = await promptSingleSelect({
+    input,
+    output,
+    title: 'Cost',
+    choices: [
+      { value: 'budget', label: 'budget', description: 'Lower-cost model profile and no parallelization' },
+      { value: 'balanced', label: 'balanced', description: 'Recommended cost/quality tradeoff' },
+      { value: 'quality', label: 'quality', description: 'Maximum quality with parallel work enabled' },
+    ],
+    defaultIndex: 1,
+  });
+  const commitDocs = await promptSingleSelect({
+    input,
+    output,
+    title: 'Planning docs in git',
+    choices: [
+      { value: true, label: 'yes', description: 'Track .planning/ in git.' },
+      { value: false, label: 'no', description: 'Keep .planning/ local only.' },
+    ],
+    defaultIndex: 0,
+  });
+
+  const rigorConfig = resolveRigor(rigor);
+  const costConfig = resolveCost(cost);
+
+  return {
+    ...rigorConfig,
+    ...costConfig,
+    commitDocs,
+    gitProtocol: { ...DEFAULT_GIT_PROTOCOL },
+    initVersion: INIT_VERSION,
+  };
+}
+
+export function yesNoChoices(prompt, defaultYes) {
+  return [
+    { value: true, label: 'yes', description: `${prompt} Yes.` },
+    { value: false, label: 'no', description: `${prompt} No.` },
+  ].sort((a, b) => {
+    if (defaultYes) return a.value === true ? -1 : 1;
+    return a.value === false ? -1 : 1;
+  });
+}
+
+export async function promptConfirm({ input, output, title, prompt, defaultValue, details = [] }) {
+  if (typeof input.resume === 'function') input.resume();
+  output.write(`\n${ANSI.bold}${title}${ANSI.reset}\n`);
+  for (const detail of details) {
+    output.write(`  ${ANSI.dim}${detail}${ANSI.reset}\n`);
+  }
+  const rl = readline.createInterface({ input, output });
+  const suffix = defaultValue ? '[Y/n]' : '[y/N]';
+  try {
+    const answer = await new Promise((resolve) => rl.question(`  ${prompt} ${suffix}: `, resolve));
+    const normalized = answer.trim().toLowerCase();
+    if (!normalized) return defaultValue;
+    return normalized === 'y' || normalized === 'yes';
+  } finally {
+    rl.close();
+  }
+}
+
+export async function promptSingleSelect({ input, output, title, choices, defaultIndex = 0 }) {
+  const selected = await promptChoiceList({
+    input,
+    output,
+    title,
+    choices: choices.map((choice, index) => ({
+      ...choice,
+      selected: index === defaultIndex,
+      detected: false,
+    })),
+    multi: false,
+  });
+  return selected[0];
+}
+
+export async function promptMultiSelect({ input, output, title, hint, choices }) {
+  return promptChoiceList({ input, output, title, hint, choices, multi: true });
+}
+
+export async function promptChoiceList({ input, output, title, hint = 'Use arrows to move. Enter confirms.', choices, multi }) {
+  if (typeof input.resume === 'function') input.resume();
+  readline.emitKeypressEvents(input);
+  const previousRawMode = typeof input.isRaw === 'boolean' ? input.isRaw : false;
+  if (typeof input.setRawMode === 'function') input.setRawMode(true);
+
+  let cursor = Math.max(0, choices.findIndex((choice) => choice.selected));
+  let renderedLines = 0;
+
+  const selectCursor = () => {
+    if (multi) return;
+    for (const choice of choices) choice.selected = false;
+    choices[cursor].selected = true;
+  };
+
+  const measureLines = (text) => {
+    const columns = Math.max(20, Number(output.columns) || 80);
+    const visible = stripAnsi(text);
+    return visible.split('\n').reduce((total, line) => {
+      const width = Math.max(1, line.length);
+      return total + Math.ceil(width / columns);
+    }, 0);
+  };
+
+  const render = () => {
+    if (renderedLines > 0) {
+      readline.moveCursor(output, 0, -renderedLines);
+    }
+    readline.cursorTo(output, 0);
+    readline.clearScreenDown(output);
+    const lines = [`${ANSI.bold}${title}${ANSI.reset}`];
+    if (hint) lines.push(`${ANSI.dim}${hint}${ANSI.reset}`);
+    lines.push('');
+    for (let i = 0; i < choices.length; i++) {
+      const choice = choices[i];
+      const pointer = i === cursor ? `${ANSI.green}>${ANSI.reset}` : ' ';
+      const mark = choice.selected ? `${ANSI.green}[x]${ANSI.reset}` : '[ ]';
+      const detected = choice.detected ? ` ${ANSI.dim}(detected)${ANSI.reset}` : '';
+      lines.push(`${pointer} ${mark} ${choice.label}${detected}`);
+      lines.push(`    ${ANSI.dim}${choice.description}${ANSI.reset}`);
+    }
+
+    renderedLines = 0;
+    for (const line of lines) {
+      output.write(`${line}\n`);
+      renderedLines += measureLines(line);
+    }
+  };
+
+  render();
+
+  const values = await new Promise((resolve, reject) => {
+    const cleanup = () => {
+      input.off('keypress', onKeypress);
+      if (typeof input.setRawMode === 'function') input.setRawMode(previousRawMode);
+    };
+
+    const onKeypress = (_, key = {}) => {
+      if (key.ctrl && key.name === 'c') {
+        cleanup();
+        reject(new Error('Prompt cancelled by user'));
+        return;
+      }
+      if (key.name === 'up') {
+        cursor = cursor === 0 ? choices.length - 1 : cursor - 1;
+        selectCursor();
+        render();
+        return;
+      }
+      if (key.name === 'down') {
+        cursor = cursor === choices.length - 1 ? 0 : cursor + 1;
+        selectCursor();
+        render();
+        return;
+      }
+      if (key.name === 'space') {
+        if (multi) {
+          choices[cursor].selected = !choices[cursor].selected;
+        } else {
+          for (const choice of choices) choice.selected = false;
+          choices[cursor].selected = true;
+        }
+        render();
+        return;
+      }
+      if (key.name === 'return') {
+        selectCursor();
+        cleanup();
+        resolve(choices.filter((choice) => choice.selected).map((choice) => choice.value ?? choice.id));
+      }
+    };
+
+    input.on('keypress', onKeypress);
+  });
+
+  output.write('\n');
+  return values;
+}
+
+export function stripAnsi(text) {
+  return String(text).replace(/\x1B\[[0-9;]*[A-Za-z]/g, '');
+}