@wazir-dev/cli 1.1.0 → 1.2.0

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

@@ -1,117 +1,136 @@
-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|--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');
 
-  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',
     };
   }
 
+  // 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 {
-    // Create directories
+    const { select } = await import('@inquirer/prompts');
+
     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' },
+        { 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',
     });
 
-    // Multi-tool tools (conditional)
     let multiToolTools = [];
     if (modelMode === 'multi-tool') {
       const toolChoice = await select({
-        message: 'Which external tools should Wazir use for reviews?',
+        message: 'Which external tools 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' },
+          { name: 'Codex', value: 'codex' },
+          { name: 'Gemini', value: 'gemini' },
+          { name: 'Both', 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?',
+        message: 'Codex model?',
         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' },
+          { 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',
       });
     }
 
-    // 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 host = detectHost();
+    const stack = detectProjectStack(cwd);
 
-    const depthAllows = defaultDepth === 'standard' || defaultDepth === 'deep';
-    const intentAllows = defaultIntent === 'feature' || defaultIntent === 'refactor';
-
-    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' && {
@@ -120,77 +139,18 @@ export async function runInitCommand(parsed, context = {}) {
           ...(codexModel && { codex: { model: codexModel } }),
         },
       }),
-      default_depth: defaultDepth,
-      default_intent: defaultIntent,
-      team_mode: teamMode,
-      parallel_backend: parallelBackend,
+      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');
 
-    // 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 (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');
-    }
-
-    const lines = [
-      '',
-      '\u2705 Pipeline initialized!',
-      '',
-      `  Mode:    ${modelMode}`,
-      `  Depth:   ${defaultDepth}`,
-      `  Intent:  ${defaultIntent}`,
-      `  Teams:   ${teamMode}`,
-      '',
-      'Files created:',
-      ...filesCreated.map((f) => `  - ${f}`),
-      '',
-      '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',
-      '',
-    ];
-
     return {
       exitCode: 0,
-      stdout: lines.join('\n'),
+      stdout: `\nInitialized (${modelMode}). Host: ${host.host}. Next: /wazir <request>\n`,
     };
   } catch (error) {
     if (error.name === 'ExitPromptError') {

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;
+}