cli-five 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cli-five",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Code Like I'm Five — scaffold a 5-agent VS Code Copilot team into any repo.",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -24,6 +24,7 @@ ${kleur.bold('Flags')}
   --force         Overwrite without confirmation. Dangerous. Use with --yes.
   --dry-run       Print actions without writing files
   --no-skills     Skip the skills.sh discovery step
+  --doc <file>    Read project docs to pre-fill interview (repeatable)
   --cost-mode <m> Override cost mode (premium, cheap, mixed) — skips interview question
   --cwd <path>    Run against a directory other than the current one
   --version, -v   Print version and exit
@@ -59,13 +60,14 @@ export async function run(argv) {
 }
 
 function parse(argv) {
-  const out = { _: [], yes: false, force: false, dryRun: false, skills: true, costMode: null, cwd: process.cwd() };
+  const out = { _: [], yes: false, force: false, dryRun: false, skills: true, docs: [], costMode: null, cwd: process.cwd() };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === '--yes' || a === '-y') out.yes = true;
     else if (a === '--force') out.force = true;
     else if (a === '--dry-run') out.dryRun = true;
     else if (a === '--no-skills') out.skills = false;
+    else if (a === '--doc') out.docs.push(argv[++i]);
     else if (a === '--cost-mode') out.costMode = argv[++i];
     else if (a === '--cwd') out.cwd = argv[++i];
     else if (a === '--help' || a === '-h') out._.push('help');

package/src/commands/init.mjs

@@ -1,5 +1,7 @@
 import kleur from 'kleur';
 import prompts from 'prompts';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { resolve, basename, join, extname } from 'node:path';
 import { log } from '../util/log.mjs';
 import { detect } from '../steps/detect.mjs';
 import { confirmOverwriteIfNeeded } from '../steps/confirm.mjs';
@@ -40,9 +42,30 @@ export async function init(args) {
   }
   if (!detected.hasAgents && !detected.hasCopilotInstructions) log.dim('No collisions.');
 
-  // 4. Interview
-  log.step('3/6 Interview');
-  const answers = await interview(detected, args);
+  // 4. Input mode — docs or manual interview
+  log.step('3/6 Project info');
+  let docHints;
+
+  if (args.docs.length > 0) {
+    // --doc was passed on the CLI — validate with retry
+    docHints = loadDocs(args.docs, cwd);
+    if (docHints.files.length === 0) {
+      log.warn('None of the --doc files could be loaded.');
+    }
+  } else if (args.yes) {
+    docHints = loadDocs([], cwd);
+  } else {
+    docHints = await collectDocFiles(cwd);
+  }
+
+  if (docHints.files.length > 0 && args.docs.length > 0) {
+    log.info(`Loaded ${docHints.files.length} doc${docHints.files.length > 1 ? 's' : ''}: ${docHints.files.join(', ')}`);
+    if (docHints.projectName) log.dim(`  → project name: ${docHints.projectName}`);
+    if (docHints.oneLiner) log.dim(`  → description: ${docHints.oneLiner}`);
+  }
+
+  // 5. Interview (pre-filled from docs if available, otherwise manual)
+  const answers = await interview(detected, args, docHints);
 
   // CLI --cost-mode override
   if (args.costMode && ['premium', 'cheap', 'mixed'].includes(args.costMode)) {
@@ -106,3 +129,239 @@ function printNextSteps(answers) {
   log.raw(kleur.dim('Edit cost mode anytime by changing `model:` in .github/agents/*.agent.md.'));
   log.raw('');
 }
+
+// ── Interactive doc file collection ───────────────────────────────────
+
+const MANUAL_SENTINEL = '__manual__';
+const SKIP_SENTINEL = '__skip__';
+
+async function collectDocFiles(cwd) {
+  const { mode } = await prompts({
+    type: 'select',
+    name: 'mode',
+    message: 'How would you like to describe your project?',
+    choices: [
+      { title: 'Provide document(s)', value: 'docs', description: 'Feed existing files (README, PRD, etc.) — we extract what we can' },
+      { title: 'Answer questions', value: 'manual', description: 'Short interactive interview' },
+    ],
+    initial: 0,
+  });
+  if (mode === undefined || mode === 'manual') return loadDocs([], cwd);
+
+  // Retry loop — keep asking until we get valid files or user opts out
+  while (true) {
+    const selectedPaths = await pickFiles(cwd);
+
+    // User cancelled or chose skip
+    if (selectedPaths === null) return loadDocs([], cwd);
+
+    const hints = loadDocs(selectedPaths, cwd);
+    if (hints.files.length > 0) {
+      log.info(`Loaded ${hints.files.length} doc${hints.files.length > 1 ? 's' : ''}: ${hints.files.join(', ')}`);
+      if (hints.projectName) log.dim(`  → project name: ${hints.projectName}`);
+      if (hints.oneLiner) log.dim(`  → description: ${hints.oneLiner}`);
+      return hints;
+    }
+
+    // Nothing loaded — offer retry
+    log.warn('No valid files were loaded.');
+    const { next } = await prompts({
+      type: 'select',
+      name: 'next',
+      message: 'What would you like to do?',
+      choices: [
+        { title: 'Try selecting files again', value: 'retry' },
+        { title: 'Answer questions manually instead', value: 'manual' },
+      ],
+    });
+    if (next !== 'retry') return loadDocs([], cwd);
+  }
+}
+
+async function pickFiles(cwd) {
+  const candidates = discoverDocCandidates(cwd);
+
+  if (candidates.length > 0) {
+    const choices = [
+      ...candidates.map(f => ({ title: f, value: f })),
+      { title: kleur.dim('Type path(s) manually'), value: MANUAL_SENTINEL },
+      { title: kleur.dim('Skip — answer questions instead'), value: SKIP_SENTINEL },
+    ];
+
+    const { files } = await prompts({
+      type: 'autocompleteMultiselect',
+      name: 'files',
+      message: 'Select project documents',
+      choices,
+      hint: 'Type to filter, space to select, enter to confirm',
+      suggest: (input, choices) =>
+        choices.filter(c =>
+          c.value === MANUAL_SENTINEL || c.value === SKIP_SENTINEL ||
+          c.title.toLowerCase().includes(input.toLowerCase())
+        ),
+    });
+
+    if (!files || files.length === 0) return null;
+    if (files.includes(SKIP_SENTINEL)) return null;
+    if (!files.includes(MANUAL_SENTINEL)) return files;
+    // Fall through to manual entry
+  }
+
+  // Manual entry (also reached when no candidates found)
+  return await manualPathEntry(cwd);
+}
+
+async function manualPathEntry(cwd) {
+  const { raw } = await prompts({
+    type: 'list',
+    name: 'raw',
+    message: 'File paths (comma-separated, relative to project root)',
+    separator: ',',
+  });
+
+  const paths = (raw || []).map(p => p.trim()).filter(Boolean);
+  if (paths.length === 0) return null;
+
+  // Validate immediately so user sees which ones failed
+  const valid = [];
+  const invalid = [];
+  for (const p of paths) {
+    if (existsSync(resolve(cwd, p))) {
+      valid.push(p);
+    } else {
+      invalid.push(p);
+    }
+  }
+
+  if (invalid.length > 0) {
+    for (const p of invalid) log.warn(`Not found: ${p}`);
+  }
+
+  return valid.length > 0 ? valid : paths; // return all — loadDocs will warn again, triggers retry
+}
+
+function discoverDocCandidates(cwd) {
+  const IGNORE = new Set(['node_modules', '.git', '.github', 'dist', 'build', '.next', 'coverage', '.turbo', '.vercel']);
+  const DOC_EXTS = new Set(['.md', '.txt', '.rst', '.mdx']);
+  const DOC_NAMES = new Set(['package.json']);
+  const results = [];
+
+  function walk(dir, prefix) {
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const entry of entries) {
+      if (entry.name.startsWith('.') && entry.name !== '.github') continue;
+      if (IGNORE.has(entry.name)) continue;
+      const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        if (rel.split('/').length < 3) walk(join(dir, entry.name), rel);
+      } else {
+        const ext = extname(entry.name).toLowerCase();
+        if (DOC_EXTS.has(ext) || DOC_NAMES.has(entry.name.toLowerCase())) {
+          results.push(rel);
+        }
+      }
+    }
+  }
+
+  walk(cwd, '');
+  return results.sort();
+}
+
+// ── --doc file loading + extraction ───────────────────────────────────
+
+function loadDocs(docPaths, cwd) {
+  const empty = { files: [], projectName: '', oneLiner: '', goals: '', constraints: '', raw: '' };
+  if (!docPaths || docPaths.length === 0) return empty;
+
+  const sections = [];
+  const files = [];
+  let projectName = '';
+  let oneLiner = '';
+  let goals = '';
+  let constraints = '';
+
+  for (const rawPath of docPaths) {
+    const abs = resolve(cwd, rawPath);
+    if (!existsSync(abs)) {
+      log.warn(`--doc: file not found: ${rawPath}`);
+      continue;
+    }
+
+    let content;
+    try {
+      content = readFileSync(abs, 'utf8');
+    } catch (err) {
+      log.warn(`--doc: cannot read ${rawPath}: ${err.message}`);
+      continue;
+    }
+
+    const name = basename(abs);
+    files.push(name);
+    sections.push(`### ${name}\n\n${content.trim()}`);
+
+    // ── Heuristic extraction ──────────────────────────────────────
+    // Try package.json first (structured data)
+    if (name === 'package.json') {
+      try {
+        const pkg = JSON.parse(content);
+        if (pkg.name && !projectName) projectName = pkg.name;
+        if (pkg.description && !oneLiner) oneLiner = pkg.description;
+      } catch { /* ignore malformed JSON */ }
+      continue;
+    }
+
+    // For markdown/text files — extract from headings and first paragraph
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+
+      // First H1 → project name hint
+      if (!projectName && /^#\s+/.test(line)) {
+        projectName = line.replace(/^#+\s*/, '').trim();
+        continue;
+      }
+
+      // First non-empty paragraph after H1 → one-liner hint
+      if (projectName && !oneLiner && line && !line.startsWith('#') && !line.startsWith('```') && !line.startsWith('- ') && !line.startsWith('|')) {
+        oneLiner = line.length > 120 ? line.slice(0, 117) + '...' : line;
+        continue;
+      }
+
+      // ## Goal / ## Purpose / ## Overview → goals hint
+      if (!goals && /^##\s+(goal|purpose|overview|objective|vision)/i.test(line)) {
+        const body = collectSection(lines, i + 1);
+        if (body) goals = body;
+        continue;
+      }
+
+      // ## Constraints → constraints hint
+      if (!constraints && /^##\s+(constraint|requirement|limit|scope)/i.test(line)) {
+        const body = collectSection(lines, i + 1);
+        if (body) constraints = body;
+        continue;
+      }
+    }
+  }
+
+  return {
+    files,
+    projectName,
+    oneLiner,
+    goals,
+    constraints,
+    raw: sections.join('\n\n---\n\n'),
+  };
+}
+
+/** Collect text from startIdx until the next heading or EOF. */
+function collectSection(lines, startIdx) {
+  const out = [];
+  for (let i = startIdx; i < lines.length; i++) {
+    if (/^##?\s+/.test(lines[i]) && out.length > 0) break;
+    const trimmed = lines[i].trim();
+    if (trimmed) out.push(trimmed);
+    if (out.length >= 3) break; // Keep it short — just the first few lines
+  }
+  return out.join(' ');
+}

package/src/steps/interview.mjs

@@ -78,8 +78,8 @@ const COST_MODES = [
   { title: 'Mixed', value: 'mixed', description: 'Premium Coder + Reviewer, cheap everything else.' },
 ];
 
-export async function interview(detected, args) {
-  if (args.yes) return defaults(detected);
+export async function interview(detected, args, docHints = {}) {
+  if (args.yes) return defaults(detected, docHints);
 
   const onCancel = () => {
     throw new Error('Interview cancelled. Nothing was written.');
@@ -92,13 +92,13 @@ export async function interview(detected, args) {
         type: 'text',
         name: 'projectName',
         message: 'Project name',
-        initial: detected.projectName,
+        initial: docHints.projectName || detected.projectName,
       },
       {
         type: 'text',
         name: 'oneLiner',
         message: 'One-line description (becomes PROJECT.md vision)',
-        initial: '',
+        initial: docHints.oneLiner || '',
       },
     ],
     { onCancel },
@@ -159,11 +159,13 @@ export async function interview(detected, args) {
         type: 'text',
         name: 'goals',
         message: 'Primary goal of this project (one sentence)',
+        initial: docHints.goals || '',
       },
       {
         type: 'text',
         name: 'constraints',
         message: 'Hard constraints (perf, deps, deploy, compliance — one sentence, optional)',
+        initial: docHints.constraints || '',
       },
       {
         type: 'select',
@@ -183,30 +185,32 @@ export async function interview(detected, args) {
   );
 
   return normalize({
-    ...defaults(detected),
+    ...defaults(detected, docHints),
     ...basic,
     ...stackAnswers,
     ...rest,
     presetId: preset,
     quickstart: chosenPreset?.quickstart || '',
+    docs: docHints.raw || '',
   });
 }
 
 /** Default stack is Next.js + TypeScript when nothing detected and --yes. */
-function defaults(detected) {
+function defaults(detected, docHints = {}) {
   const hasDetected = detected.stacks.length > 0;
   const fallback = STACK_PRESETS[0]; // Next.js (TypeScript)
   return {
-    projectName: detected.projectName,
-    oneLiner: '',
+    projectName: docHints.projectName || detected.projectName,
+    oneLiner: docHints.oneLiner || '',
     stack: hasDetected ? detected.stacks.map((s) => s.label) : fallback.stack,
     frameworks: hasDetected ? [] : fallback.frameworks,
-    goals: '',
-    constraints: '',
+    goals: docHints.goals || '',
+    constraints: docHints.constraints || '',
     costMode: 'premium',
     snark: true,
     presetId: hasDetected ? 'custom' : fallback.value,
     quickstart: hasDetected ? '' : fallback.quickstart,
+    docs: docHints.raw || '',
   };
 }
 

package/src/steps/scaffold.mjs

@@ -96,6 +96,13 @@ function buildVars(a) {
     CONSTRAINTS: a.constraints || 'None declared.',
     QUICKSTART: a.quickstart || 'TODO — add install + run commands here.',
     COST_MODE: a.costMode,
+    DOCS_SECTION: a.docs ? `
+## Source Documents
+
+The following documents were provided via \`--doc\` at project init time.
+
+${a.docs}
+` : '',
     DATE: new Date().toISOString().slice(0, 10),
     PERSONA_BLOCK: a.snark ? PERSONA_BLOCK : '',
   };

package/templates/PROJECT.md.tmpl

@@ -27,6 +27,6 @@ _(populate as you discover things this project will NOT do)_
 _(populate with measurable outcomes — what does "done" look like?)_
 
 ---
-
+{{DOCS_SECTION}}
 _This file is the durable vision. It changes rarely. Day-to-day status lives in `STATE.md`._
 _Generated by `npx cli-five` on {{DATE}}._