@wazir-dev/cli 1.1.0 → 1.3.0

package/tooling/src/init/command.js

@@ -1,201 +1,69 @@
-import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { select } from '@inquirer/prompts';
 
+import { autoInit, detectHost, detectProjectStack } from './auto-detect.js';
+
+/**
+ * wazir init [--auto|--force]
+ *
+ * Default: --auto (zero-config, no prompts, infer everything)
+ * --force: reinitialize even if already initialized
+ */
 export async function runInitCommand(parsed, context = {}) {
   const cwd = context.cwd ?? process.cwd();
   const wazirDir = path.join(cwd, '.wazir');
   const configPath = path.join(wazirDir, 'state', 'config.json');
+  const isForce = parsed.args.includes('--force');
 
-  if (fs.existsSync(configPath) && !parsed.args.includes('--force')) {
+  // Already initialized check
+  if (fs.existsSync(configPath) && !isForce) {
     return {
       exitCode: 1,
       stderr: 'Pipeline already initialized. Use --force to reinitialize.\n',
     };
   }
 
+  // Auto mode — zero-config
   try {
-    // Create directories
-    for (const dir of ['input', 'state', 'runs']) {
-      fs.mkdirSync(path.join(wazirDir, dir), { recursive: true });
-    }
-
-    // Pipeline mode
-    const modelMode = await select({
-      message: 'How should Wazir run in this project?',
-      choices: [
-        { name: 'Single model (Recommended) — slash commands only', value: 'claude-only' },
-        { name: 'Multi-model — routes by complexity (Haiku/Sonnet/Opus)', value: 'multi-model' },
-        { name: 'Multi-tool — current model + external tools for reviews', value: 'multi-tool' },
-      ],
-      default: 'claude-only',
-    });
-
-    // Multi-tool tools (conditional)
-    let multiToolTools = [];
-    if (modelMode === 'multi-tool') {
-      const toolChoice = await select({
-        message: 'Which external tools should Wazir use for reviews?',
-        choices: [
-          { name: 'Codex — Send reviews to OpenAI Codex', value: 'codex' },
-          { name: 'Gemini — Send reviews to Google Gemini', value: 'gemini' },
-          { name: 'Both — Use Codex and Gemini', value: 'both' },
-        ],
-      });
-      multiToolTools = toolChoice === 'both' ? ['codex', 'gemini'] : [toolChoice];
-    }
-
-    // Codex model (conditional)
-    let codexModel = null;
-    if (multiToolTools.includes('codex')) {
-      codexModel = await select({
-        message: 'Which Codex model should Wazir use?',
-        choices: [
-          { name: 'gpt-5.3-codex-spark (Recommended) — fast, good for review loops', value: 'gpt-5.3-codex-spark' },
-          { name: 'gpt-5.4 — slower, deeper analysis for complex reviews', value: 'gpt-5.4' },
-        ],
-        default: 'gpt-5.3-codex-spark',
-      });
-    }
-
-    // Default depth
-    const defaultDepth = await select({
-      message: 'What default depth should runs use?',
-      choices: [
-        { name: 'Quick — minimal research, single-pass review', value: 'quick' },
-        { name: 'Standard (Recommended) — balanced research, multi-pass hardening', value: 'standard' },
-        { name: 'Deep — extended research, strict review thresholds', value: 'deep' },
-      ],
-      default: 'standard',
-    });
-
-    // Default intent
-    const defaultIntent = await select({
-      message: 'What kind of work does this project mostly involve?',
-      choices: [
-        { name: 'Feature (Recommended) — new functionality or enhancement', value: 'feature' },
-        { name: 'Bugfix — fix broken behavior', value: 'bugfix' },
-        { name: 'Refactor — restructure without changing behavior', value: 'refactor' },
-        { name: 'Docs — documentation only', value: 'docs' },
-        { name: 'Spike — research and exploration', value: 'spike' },
-      ],
-      default: 'feature',
-    });
-
-    // Agent Teams (conditional)
-    let teamMode = 'sequential';
-    let parallelBackend = 'none';
-
-    const depthAllows = defaultDepth === 'standard' || defaultDepth === 'deep';
-    const intentAllows = defaultIntent === 'feature' || defaultIntent === 'refactor';
+    const result = autoInit(cwd, { context, force: isForce });
 
-    if (depthAllows && intentAllows) {
-      const useTeams = await select({
-        message: 'Would you like to use Agent Teams for parallel execution?',
-        choices: [
-          { name: 'No (Recommended) — sequential, predictable, lower cost', value: 'sequential' },
-          { name: 'Yes — parallel teammates, faster but experimental (Opus only)', value: 'parallel' },
-        ],
-        default: 'sequential',
-      });
-      teamMode = useTeams;
-      parallelBackend = useTeams === 'parallel' ? 'claude_teams' : 'none';
-
-      if (teamMode === 'parallel') {
-        try {
-          execFileSync('claude', ['config', 'set', 'env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS', '1'], { stdio: 'pipe' });
-        } catch {
-          // claude CLI not available — user will need to set it manually
-        }
-      }
-    }
-
-    // Write config
-    const config = {
-      model_mode: modelMode,
-      ...(modelMode === 'multi-tool' && {
-        multi_tool: {
-          tools: multiToolTools,
-          ...(codexModel && { codex: { model: codexModel } }),
-        },
-      }),
-      default_depth: defaultDepth,
-      default_intent: defaultIntent,
-      team_mode: teamMode,
-      parallel_backend: parallelBackend,
-    };
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
-
-    // Runtime-specific setup
-    const filesCreated = ['.wazir/input/', '.wazir/state/', '.wazir/runs/', '.wazir/state/config.json'];
-
-    if (multiToolTools.includes('codex')) {
-      const content = [
-        '# Wazir Pipeline',
-        '',
-        'Agent protocols are at `~/.claude/agents/` (global).',
-        '',
-        '## Running the Pipeline',
-        '1. Clarifier: read and follow `~/.claude/agents/clarifier.md` — tasks are in `.wazir/input/`',
-        '2. Orchestrator: read and follow `~/.claude/agents/orchestrator.md` — start from task 1',
-        '3. Opus Reviewer: read and follow `~/.claude/agents/opus-reviewer.md` — run all phases',
-        '',
-        '## Review Mode',
-        'This project uses Codex as a secondary reviewer. Review artifacts are in `.wazir/reviews/`.',
-        '',
-      ].join('\n');
-      fs.writeFileSync(path.join(cwd, 'AGENTS.md'), content);
-      filesCreated.push('AGENTS.md');
+    if (result.alreadyInitialized && !isForce) {
+      return {
+        exitCode: 0,
+        stdout: `Already initialized. Host: ${result.host.host}, Stack: ${result.stack.language}\n`,
+      };
     }
 
-    if (multiToolTools.includes('gemini')) {
-      const content = [
-        '# Wazir Pipeline',
-        '',
-        'Agent protocols are at `~/.claude/agents/` (global).',
-        '',
-        '## Running the Pipeline',
-        '1. Clarifier: read and follow `~/.claude/agents/clarifier.md` — tasks are in `.wazir/input/`',
-        '2. Orchestrator: read and follow `~/.claude/agents/orchestrator.md` — start from task 1',
-        '3. Opus Reviewer: read and follow `~/.claude/agents/opus-reviewer.md` — run all phases',
-        '',
-        '## Review Mode',
-        'This project uses Gemini as a secondary reviewer. Review artifacts are in `.wazir/reviews/`.',
-        '',
-      ].join('\n');
-      fs.writeFileSync(path.join(cwd, 'GEMINI.md'), content);
-      filesCreated.push('GEMINI.md');
+    // Auto-export for detected host
+    let exportNote = '';
+    try {
+      const { buildHostExports } = await import('../export/compiler.js');
+      buildHostExports(cwd);
+      exportNote = `  Exports: generated for ${result.host.host}\n`;
+    } catch {
+      exportNote = '  Exports: skipped (run `wazir export build` manually)\n';
     }
 
     const lines = [
       '',
-      '\u2705 Pipeline initialized!',
-      '',
-      `  Mode:    ${modelMode}`,
-      `  Depth:   ${defaultDepth}`,
-      `  Intent:  ${defaultIntent}`,
-      `  Teams:   ${teamMode}`,
+      'Wazir initialized (zero-config).',
       '',
+      `  Host:    ${result.host.host} (${result.host.confidence} confidence)`,
+      `  Stack:   ${result.stack.language}${result.stack.framework ? ` / ${result.stack.framework}` : ''}`,
+      `  Mode:    ${result.config.model_mode}`,
+      `  Depth:   ${result.config.default_depth}`,
+      exportNote,
       'Files created:',
-      ...filesCreated.map((f) => `  - ${f}`),
+      ...result.filesCreated.map((f) => `  - ${f}`),
+      '',
+      'Next: /wazir <what you want to build>',
       '',
-      'You can now use:',
-      '  /wazir <your request>  \u2014 Run the full pipeline',
-      '  /clarifier             \u2014 Research, clarify, plan',
-      '  /executor              \u2014 Autonomous execution',
-      '  /reviewer              \u2014 Final review and scoring',
+      'Override: `wazir config set model_mode multi-tool`',
       '',
     ];
 
-    return {
-      exitCode: 0,
-      stdout: lines.join('\n'),
-    };
+    return { exitCode: 0, stdout: lines.join('\n') };
   } catch (error) {
-    if (error.name === 'ExitPromptError') {
-      return { exitCode: 130, stderr: '\nInit cancelled.\n' };
-    }
-    return { exitCode: 1, stderr: `${error.message}\n` };
+    return { exitCode: 1, stderr: `Auto-init failed: ${error.message}\n` };
   }
 }

package/tooling/src/input/scanner.js

@@ -0,0 +1,46 @@
+import { readdirSync, existsSync } from 'node:fs';
+import { join, resolve, basename } from 'node:path';
+
+/**
+ * Scan input directories for briefing materials.
+ * Globs input/*.md and .wazir/input/*.md (flat, not recursive).
+ * Excludes README.md.
+ *
+ * @param {string} projectRoot - Absolute path to project root
+ * @returns {Array<{path: string, auto: boolean}>} Found files with auto flag
+ */
+export function scanInputDirectories(projectRoot) {
+  const root = resolve(projectRoot);
+  const dirs = [
+    join(root, 'input'),
+    join(root, '.wazir', 'input'),
+  ];
+
+  const results = [];
+
+  for (const dir of dirs) {
+    if (!existsSync(dir)) continue;
+
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      if (!entry.name.endsWith('.md')) continue;
+      if (basename(entry.name).toLowerCase() === 'readme.md') continue;
+
+      results.push({ path: join(dir, entry.name), auto: false });
+    }
+  }
+
+  // Single file auto-use
+  if (results.length === 1) {
+    results[0].auto = true;
+  }
+
+  return results;
+}

package/tooling/src/reports/command.js

@@ -0,0 +1,103 @@
+import path from 'node:path';
+
+import { parseCommandOptions } from '../command-options.js';
+import { readYamlFile } from '../loaders.js';
+import { findProjectRoot } from '../project-root.js';
+import { resolveStateRoot } from '../state-root.js';
+import { collectPhaseMetrics, buildPhaseReport } from './phase-report.js';
+
+const USAGE = 'Usage: wazir report phase --run <run-id> --phase <phase> [--base <branch>] [--json]';
+
+function handlePhase(parsed, context = {}) {
+  const { options } = parseCommandOptions(parsed.args, {
+    boolean: ['json', 'help'],
+    string: ['run', 'phase', 'base', 'state-root'],
+  });
+
+  if (options.help) {
+    return {
+      exitCode: 0,
+      stdout: `${USAGE}\n\nGenerate a structured phase report with metrics from git, tests, and run state.\n`,
+    };
+  }
+
+  if (!options.run) {
+    return {
+      exitCode: 1,
+      stderr: `wazir report phase requires --run <id>\n${USAGE}\n`,
+    };
+  }
+
+  if (!options.phase) {
+    return {
+      exitCode: 1,
+      stderr: `wazir report phase requires --phase <phase>\n${USAGE}\n`,
+    };
+  }
+
+  const projectRoot = findProjectRoot(context.cwd ?? process.cwd());
+  const manifest = readYamlFile(path.join(projectRoot, 'wazir.manifest.yaml'));
+  const stateRoot = resolveStateRoot(projectRoot, manifest, {
+    cwd: context.cwd ?? process.cwd(),
+    override: options.stateRoot,
+  });
+
+  const metrics = collectPhaseMetrics({
+    projectRoot,
+    stateRoot,
+    runId: options.run,
+    phase: options.phase,
+    baseBranch: options.base ?? 'main',
+  });
+
+  const report = buildPhaseReport(metrics);
+
+  if (options.json) {
+    return {
+      exitCode: 0,
+      stdout: `${JSON.stringify(report, null, 2)}\n`,
+    };
+  }
+
+  // Human-readable text output
+  const lines = [
+    `Phase Report: ${report.phase} (run ${report.run_id})`,
+    `Generated: ${report.generated_at}`,
+    '',
+    'Tests:',
+    `  total: ${report.metrics.tests.total}, passed: ${report.metrics.tests.passed}, failed: ${report.metrics.tests.failed}, skipped: ${report.metrics.tests.skipped}`,
+    '',
+    'Diff:',
+    `  files changed: ${report.metrics.diff.files_changed}, insertions: ${report.metrics.diff.insertions}, deletions: ${report.metrics.diff.deletions}`,
+    '',
+    'Files:',
+    `  added: ${report.metrics.files.added.length}, modified: ${report.metrics.files.modified.length}, deleted: ${report.metrics.files.deleted.length}`,
+    '',
+    `Artifacts: ${report.metrics.artifacts.length}`,
+    `Duration: ${report.metrics.duration_seconds !== null ? `${report.metrics.duration_seconds}s` : 'N/A'}`,
+  ];
+
+  return {
+    exitCode: 0,
+    stdout: `${lines.join('\n')}\n`,
+  };
+}
+
+export function runReportCommand(parsed, context = {}) {
+  try {
+    switch (parsed.subcommand) {
+      case 'phase':
+        return handlePhase(parsed, context);
+      default:
+        return {
+          exitCode: 1,
+          stderr: `${USAGE}\n`,
+        };
+    }
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stderr: `${error.message}\n`,
+    };
+  }
+}