@wazir-dev/cli 1.0.0 → 1.2.0

package/tooling/src/guards/phase-prerequisite-guard.js

@@ -0,0 +1,127 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { readYamlFile } from '../loaders.js';
+import { getRunPaths, readPhaseExitEvents } from '../capture/store.js';
+
+export function evaluateScopeCoverageGuard(payload) {
+  const { input_item_count: inputCount, plan_task_count: planCount, user_approved_reduction: userApproved } = payload;
+
+  const safeInputCount = inputCount ?? 0;
+  const safePlanCount = planCount ?? 0;
+
+  if (safeInputCount === 0) {
+    return {
+      allowed: true,
+      reason: 'No input items to check against.',
+      input_count: safeInputCount,
+      plan_count: safePlanCount,
+    };
+  }
+
+  if (safePlanCount >= safeInputCount) {
+    return {
+      allowed: true,
+      reason: `Plan covers all input items (${safePlanCount} tasks >= ${safeInputCount} items).`,
+      input_count: safeInputCount,
+      plan_count: safePlanCount,
+    };
+  }
+
+  if (userApproved === true) {
+    return {
+      allowed: true,
+      reason: `User explicitly approved scope reduction (${safePlanCount} tasks < ${safeInputCount} items).`,
+      input_count: safeInputCount,
+      plan_count: safePlanCount,
+    };
+  }
+
+  return {
+    allowed: false,
+    reason: `Scope reduction detected: plan has ${safePlanCount} tasks but input has ${safeInputCount} items. User approval required.`,
+    input_count: safeInputCount,
+    plan_count: safePlanCount,
+  };
+}
+
+export function evaluatePhasePrerequisiteGuard(payload) {
+  const { run_id: runId, phase, state_root: stateRoot, project_root: projectRoot } = payload;
+
+  if (!runId) {
+    throw new Error('run_id is required');
+  }
+
+  if (!phase) {
+    throw new Error('phase is required');
+  }
+
+  if (!stateRoot) {
+    throw new Error('state_root is required');
+  }
+
+  if (!projectRoot) {
+    throw new Error('project_root is required');
+  }
+
+  const runPaths = getRunPaths(stateRoot, runId);
+
+  if (!fs.existsSync(runPaths.statusPath)) {
+    throw new Error(`status.json not found for run ${runId}`);
+  }
+
+  const manifestPath = path.join(projectRoot, 'wazir.manifest.yaml');
+  const manifest = readYamlFile(manifestPath);
+  const prerequisites = manifest.phase_prerequisites?.[phase];
+
+  if (!prerequisites || (Object.keys(prerequisites).length === 0)) {
+    return {
+      allowed: true,
+      reason: `No prerequisites defined for phase ${phase}.`,
+    };
+  }
+
+  const requiredArtifacts = prerequisites.required_artifacts ?? [];
+  const requiredPhaseExits = prerequisites.required_phase_exits ?? [];
+
+  const missingArtifacts = [];
+  for (const artifact of requiredArtifacts) {
+    const artifactPath = path.join(runPaths.runRoot, artifact);
+    if (!fs.existsSync(artifactPath)) {
+      missingArtifacts.push(artifact);
+    }
+  }
+
+  const completedPhases = readPhaseExitEvents(runPaths);
+  const missingPhaseExits = [];
+  for (const requiredPhase of requiredPhaseExits) {
+    if (!completedPhases.includes(requiredPhase)) {
+      missingPhaseExits.push(requiredPhase);
+    }
+  }
+
+  // OR-logic for resumed runs: if all artifacts exist, pass even without phase_exit events.
+  // Artifacts are the hard evidence; phase_exits are supplementary.
+  // But if artifacts are missing, phase_exits alone are not sufficient.
+  if (missingArtifacts.length === 0) {
+    return {
+      allowed: true,
+      reason: `All prerequisite artifacts present for phase ${phase}.`,
+    };
+  }
+
+  const reasons = [];
+  if (missingArtifacts.length > 0) {
+    reasons.push(`Missing artifacts: ${missingArtifacts.join(', ')}`);
+  }
+  if (missingPhaseExits.length > 0) {
+    reasons.push(`Missing phase exits: ${missingPhaseExits.join(', ')}`);
+  }
+
+  return {
+    allowed: false,
+    reason: reasons.join('. '),
+    missing_artifacts: missingArtifacts.length > 0 ? missingArtifacts : undefined,
+    missing_phase_exits: missingPhaseExits.length > 0 ? missingPhaseExits : undefined,
+  };
+}

package/tooling/src/hooks/routing-logic.js

@@ -0,0 +1,69 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+function firstToken(cmd) {
+  return cmd.split(/\s+/)[0] || '';
+}
+
+function hasPipe(cmd) {
+  return /(?<![\\])\|/.test(cmd);
+}
+
+function hasRedirect(cmd) {
+  return /(?<![\\])[>]/.test(cmd);
+}
+
+export function loadRoutingMatrix(projectRoot) {
+  const matrixPath = join(projectRoot, 'hooks', 'routing-matrix.json');
+  return JSON.parse(readFileSync(matrixPath, 'utf8'));
+}
+
+export function classifyCommand(cmd, matrix) {
+  const command = (cmd || '').trim();
+
+  if (!matrix) {
+    return { route: 'small', reason: 'matrix missing — safe fallback' };
+  }
+
+  // 1. Explicit context-mode marker always wins
+  if (command.includes('# wazir:context-mode')) {
+    return { route: 'large', reason: 'explicit context-mode marker' };
+  }
+
+  // 2. Check large patterns FIRST — large commands are never downgraded
+  for (const pattern of matrix.large) {
+    if (command === pattern || command.startsWith(pattern + ' ') || command.startsWith(pattern + '\t')) {
+      return { route: 'large', reason: `matched large pattern: ${pattern}` };
+    }
+  }
+
+  // 3. Passthrough marker — only honoured when command is NOT large
+  if (command.includes('# wazir:passthrough')) {
+    return { route: 'small', reason: 'explicit passthrough marker' };
+  }
+
+  // 4. Check small patterns
+  for (const pattern of matrix.small) {
+    if (command === pattern || command.startsWith(pattern + ' ') || command.startsWith(pattern + '\t')) {
+      return { route: 'small', reason: `matched small pattern: ${pattern}` };
+    }
+  }
+
+  // 5. Ambiguous heuristics
+  const heuristic = matrix.ambiguous_heuristic || {};
+
+  if (heuristic.pipe_detected && hasPipe(command)) {
+    return { route: 'ambiguous', reason: 'pipe detected' };
+  }
+  if (heuristic.redirect_detected && hasRedirect(command)) {
+    return { route: 'ambiguous', reason: 'redirect detected' };
+  }
+
+  const bin = firstToken(command);
+  if (Array.isArray(heuristic.verbose_binaries) && heuristic.verbose_binaries.includes(bin)) {
+    return { route: 'ambiguous', reason: `verbose binary: ${bin}` };
+  }
+
+  // Default: unknown commands pass through
+  return { route: 'small', reason: 'no pattern matched — default passthrough' };
+}

package/tooling/src/init/auto-detect.js

@@ -0,0 +1,260 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+/**
+ * Detect which AI host CLI is running this process.
+ * Checks environment variables, process ancestry, and known file markers.
+ *
+ * @returns {{ host: string, confidence: string, signals: string[] }}
+ */
+export function detectHost() {
+  const signals = [];
+
+  // Claude Code detection
+  if (process.env.CLAUDE_CODE || process.env.CLAUDE_CODE_ENTRYPOINT) {
+    signals.push('CLAUDE_CODE env var');
+    return { host: 'claude', confidence: 'high', signals };
+  }
+  if (fs.existsSync(path.join(os.homedir(), '.claude'))) {
+    signals.push('~/.claude directory exists');
+  }
+
+  // Codex detection
+  if (process.env.CODEX_CLI || process.env.OPENAI_API_KEY) {
+    signals.push('CODEX_CLI or OPENAI_API_KEY env var');
+  }
+  if (process.env.CODEX_SANDBOX_MODE) {
+    signals.push('CODEX_SANDBOX_MODE env var');
+    return { host: 'codex', confidence: 'high', signals };
+  }
+
+  // Gemini detection
+  if (process.env.GEMINI_API_KEY || process.env.GOOGLE_AI_API_KEY) {
+    signals.push('Gemini API key env var');
+  }
+  if (process.env.GEMINI_CLI) {
+    signals.push('GEMINI_CLI env var');
+    return { host: 'gemini', confidence: 'high', signals };
+  }
+
+  // Cursor detection
+  if (process.env.CURSOR_SESSION || process.env.CURSOR_TRACE_ID) {
+    signals.push('Cursor session env var');
+    return { host: 'cursor', confidence: 'high', signals };
+  }
+
+  // Fallback: check for marker files
+  const cwd = process.cwd();
+  if (fs.existsSync(path.join(cwd, '.claude', 'settings.json'))) {
+    signals.push('.claude/settings.json exists in project');
+    return { host: 'claude', confidence: 'medium', signals };
+  }
+  if (fs.existsSync(path.join(cwd, 'AGENTS.md'))) {
+    signals.push('AGENTS.md exists (Codex marker)');
+    return { host: 'codex', confidence: 'medium', signals };
+  }
+  if (fs.existsSync(path.join(cwd, 'GEMINI.md'))) {
+    signals.push('GEMINI.md exists (Gemini marker)');
+    return { host: 'gemini', confidence: 'medium', signals };
+  }
+  if (fs.existsSync(path.join(cwd, '.cursorrules'))) {
+    signals.push('.cursorrules exists (Cursor marker)');
+    return { host: 'cursor', confidence: 'medium', signals };
+  }
+
+  // Default: assume Claude Code (most common)
+  if (signals.includes('~/.claude directory exists')) {
+    return { host: 'claude', confidence: 'low', signals };
+  }
+
+  return { host: 'claude', confidence: 'low', signals: ['no host detected, defaulting to claude'] };
+}
+
+/**
+ * Auto-detect project stack from package files, config, and structure.
+ *
+ * @param {string} projectRoot
+ * @returns {{ language: string, framework: string|null, stack: string[] }}
+ */
+export function detectProjectStack(projectRoot) {
+  const stack = [];
+  let language = 'unknown';
+  let framework = null;
+
+  // Node.js / JavaScript
+  if (fs.existsSync(path.join(projectRoot, 'package.json'))) {
+    language = 'javascript';
+    stack.push('node');
+
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf8'));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+      if (allDeps.next) { framework = 'nextjs'; stack.push('next'); }
+      else if (allDeps.react) { framework = 'react'; stack.push('react'); }
+      else if (allDeps.vue) { framework = 'vue'; stack.push('vue'); }
+      else if (allDeps.angular || allDeps['@angular/core']) { framework = 'angular'; stack.push('angular'); }
+      else if (allDeps.express || allDeps.fastify || allDeps.koa) { framework = 'node-api'; stack.push('node-api'); }
+
+      if (allDeps.typescript) { language = 'typescript'; stack.push('typescript'); }
+    } catch { /* ignore parse errors */ }
+  }
+
+  // Python
+  if (fs.existsSync(path.join(projectRoot, 'pyproject.toml')) ||
+      fs.existsSync(path.join(projectRoot, 'requirements.txt')) ||
+      fs.existsSync(path.join(projectRoot, 'setup.py'))) {
+    language = 'python';
+    stack.push('python');
+
+    if (fs.existsSync(path.join(projectRoot, 'manage.py'))) { framework = 'django'; stack.push('django'); }
+  }
+
+  // Go
+  if (fs.existsSync(path.join(projectRoot, 'go.mod'))) {
+    language = 'go';
+    stack.push('go');
+  }
+
+  // Rust
+  if (fs.existsSync(path.join(projectRoot, 'Cargo.toml'))) {
+    language = 'rust';
+    stack.push('rust');
+  }
+
+  // Flutter / Dart
+  if (fs.existsSync(path.join(projectRoot, 'pubspec.yaml'))) {
+    language = 'dart';
+    framework = 'flutter';
+    stack.push('dart', 'flutter');
+  }
+
+  // Java
+  if (fs.existsSync(path.join(projectRoot, 'pom.xml')) ||
+      fs.existsSync(path.join(projectRoot, 'build.gradle'))) {
+    language = 'java';
+    stack.push('java');
+  }
+
+  return { language, framework, stack };
+}
+
+/**
+ * Infer intent from request text using keyword matching.
+ *
+ * @param {string} requestText
+ * @returns {string} One of: bugfix, refactor, docs, spike, feature
+ */
+export function inferIntent(requestText) {
+  if (!requestText) return 'feature';
+  const lower = requestText.toLowerCase();
+
+  const patterns = [
+    { keywords: ['fix', 'bug', 'broken', 'crash', 'error', 'issue', 'wrong'], intent: 'bugfix' },
+    { keywords: ['refactor', 'clean', 'restructure', 'reorganize', 'rename', 'simplify'], intent: 'refactor' },
+    { keywords: ['doc', 'document', 'readme', 'guide', 'explain'], intent: 'docs' },
+    { keywords: ['research', 'spike', 'explore', 'investigate', 'prototype'], intent: 'spike' },
+  ];
+
+  for (const { keywords, intent } of patterns) {
+    if (keywords.some((kw) => lower.includes(kw))) return intent;
+  }
+
+  return 'feature';
+}
+
+/**
+ * Parse inline depth modifiers from request text.
+ *
+ * @param {string} requestText
+ * @returns {{ depth: string, cleanedText: string }}
+ */
+export function parseDepthModifier(requestText) {
+  if (!requestText) return { depth: 'standard', cleanedText: '' };
+
+  const match = requestText.match(/^\s*(quick|deep)\s+/i);
+  if (match) {
+    return {
+      depth: match[1].toLowerCase(),
+      cleanedText: requestText.slice(match[0].length),
+    };
+  }
+
+  return { depth: 'standard', cleanedText: requestText };
+}
+
+/**
+ * Run zero-config auto-initialization.
+ * Creates .wazir directories, detects host, scans project, writes config.
+ * No interactive prompts — everything is inferred.
+ *
+ * @param {string} projectRoot
+ * @param {object} [opts]
+ * @param {object} [opts.context] - Runtime context (availableTools, etc.)
+ * @param {boolean} [opts.force] - Force reinitialize even if config exists
+ * @returns {{ config: object, host: object, stack: object, filesCreated: string[] }}
+ */
+export function autoInit(projectRoot, opts = {}) {
+  const wazirDir = path.join(projectRoot, '.wazir');
+  const configPath = path.join(wazirDir, 'state', 'config.json');
+
+  // If already initialized and not forced, return existing config
+  if (fs.existsSync(configPath) && !opts.force) {
+    const existing = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    return {
+      config: existing,
+      host: detectHost(),
+      stack: detectProjectStack(projectRoot),
+      filesCreated: [],
+      alreadyInitialized: true,
+    };
+  }
+
+  // Create directories
+  for (const dir of ['input', 'state', 'runs']) {
+    fs.mkdirSync(path.join(wazirDir, dir), { recursive: true });
+  }
+
+  const host = detectHost();
+  const stack = detectProjectStack(projectRoot);
+
+  // Detect context-mode MCP
+  const contextMode = { enabled: false, has_execute_file: false };
+  if (opts.context?.availableTools) {
+    const prefix = 'mcp__plugin_context-mode_context-mode__';
+    const hasExecute = opts.context.availableTools.includes(`${prefix}execute`);
+    const hasFetchAndIndex = opts.context.availableTools.includes(`${prefix}fetch_and_index`);
+    const hasSearch = opts.context.availableTools.includes(`${prefix}search`);
+    const hasExecuteFile = opts.context.availableTools.includes(`${prefix}execute_file`);
+    if (hasExecute && hasFetchAndIndex && hasSearch) {
+      contextMode.enabled = true;
+      contextMode.has_execute_file = hasExecuteFile;
+    }
+  } else {
+    const pluginDir = path.join(os.homedir(), '.claude', 'plugins', 'cache', 'context-mode');
+    if (fs.existsSync(pluginDir)) {
+      contextMode.enabled = true;
+      contextMode.has_execute_file = true;
+    }
+  }
+
+  // Sensible defaults — no questions
+  const config = {
+    model_mode: 'claude-only',
+    default_depth: 'standard',
+    default_intent: 'feature',
+    team_mode: 'sequential',
+    parallel_backend: 'none',
+    context_mode: contextMode,
+    detected_host: host.host,
+    detected_stack: stack,
+    auto_initialized: true,
+  };
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+
+  const filesCreated = ['.wazir/input/', '.wazir/state/', '.wazir/runs/', '.wazir/state/config.json'];
+
+  return { config, host, stack, filesCreated, alreadyInitialized: false };
+}

package/tooling/src/init/command.js

@@ -0,0 +1,161 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { autoInit, detectHost, detectProjectStack } from './auto-detect.js';
+
+/**
+ * wazir init [--auto|--interactive|--force]
+ *
+ * Default: --auto (zero-config, no prompts, infer everything)
+ * --interactive: legacy mode with @inquirer/prompts (may fail in non-TTY)
+ * --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');
+  const isInteractive = parsed.args.includes('--interactive');
+
+  // Already initialized check
+  if (fs.existsSync(configPath) && !isForce) {
+    return {
+      exitCode: 1,
+      stderr: 'Pipeline already initialized. Use --force to reinitialize.\n',
+    };
+  }
+
+  // Interactive mode — legacy prompts (may fail in non-TTY environments like Claude Code)
+  if (isInteractive) {
+    return runInteractiveInit(parsed, context);
+  }
+
+  // Default: auto mode — zero-config
+  try {
+    const result = autoInit(cwd, { context, force: isForce });
+
+    if (result.alreadyInitialized && !isForce) {
+      return {
+        exitCode: 0,
+        stdout: `Already initialized. Host: ${result.host.host}, Stack: ${result.stack.language}\n`,
+      };
+    }
+
+    // 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 = [
+      '',
+      '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:',
+      ...result.filesCreated.map((f) => `  - ${f}`),
+      '',
+      'Next: /wazir <what you want to build>',
+      '',
+      'Power users: `wazir init --interactive` for manual config.',
+      'Override:    `wazir config set model_mode multi-tool`',
+      '',
+    ];
+
+    return { exitCode: 0, stdout: lines.join('\n') };
+  } catch (error) {
+    return { exitCode: 1, stderr: `Auto-init failed: ${error.message}\n` };
+  }
+}
+
+/**
+ * Legacy interactive init with @inquirer/prompts.
+ * Kept for power users who want manual control.
+ * Will fail in non-TTY environments (Claude Code Bash tool).
+ */
+async function runInteractiveInit(parsed, context = {}) {
+  const cwd = context.cwd ?? process.cwd();
+  const wazirDir = path.join(cwd, '.wazir');
+  const configPath = path.join(wazirDir, 'state', 'config.json');
+
+  try {
+    const { select } = await import('@inquirer/prompts');
+
+    for (const dir of ['input', 'state', 'runs']) {
+      fs.mkdirSync(path.join(wazirDir, dir), { recursive: true });
+    }
+
+    const modelMode = await select({
+      message: 'How should Wazir run in this project?',
+      choices: [
+        { name: 'Single model (Recommended)', value: 'claude-only' },
+        { name: 'Multi-model (Haiku/Sonnet/Opus routing)', value: 'multi-model' },
+        { name: 'Multi-tool (current model + external reviewers)', value: 'multi-tool' },
+      ],
+      default: 'claude-only',
+    });
+
+    let multiToolTools = [];
+    if (modelMode === 'multi-tool') {
+      const toolChoice = await select({
+        message: 'Which external tools for reviews?',
+        choices: [
+          { name: 'Codex', value: 'codex' },
+          { name: 'Gemini', value: 'gemini' },
+          { name: 'Both', value: 'both' },
+        ],
+      });
+      multiToolTools = toolChoice === 'both' ? ['codex', 'gemini'] : [toolChoice];
+    }
+
+    let codexModel = null;
+    if (multiToolTools.includes('codex')) {
+      codexModel = await select({
+        message: 'Codex model?',
+        choices: [
+          { name: 'gpt-5.3-codex-spark (Recommended)', value: 'gpt-5.3-codex-spark' },
+          { name: 'gpt-5.4', value: 'gpt-5.4' },
+        ],
+        default: 'gpt-5.3-codex-spark',
+      });
+    }
+
+    const host = detectHost();
+    const stack = detectProjectStack(cwd);
+
+    const config = {
+      model_mode: modelMode,
+      ...(modelMode === 'multi-tool' && {
+        multi_tool: {
+          tools: multiToolTools,
+          ...(codexModel && { codex: { model: codexModel } }),
+        },
+      }),
+      default_depth: 'standard',
+      default_intent: 'feature',
+      team_mode: 'sequential',
+      parallel_backend: 'none',
+      detected_host: host.host,
+      detected_stack: stack,
+    };
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+
+    return {
+      exitCode: 0,
+      stdout: `\nInitialized (${modelMode}). Host: ${host.host}. Next: /wazir <request>\n`,
+    };
+  } catch (error) {
+    if (error.name === 'ExitPromptError') {
+      return { exitCode: 130, stderr: '\nInit cancelled.\n' };
+    }
+    return { exitCode: 1, stderr: `${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;
+}