jinzd-ai-cli 0.2.26 → 0.2.28

package/dist/{server-HSGK6BPN.js → server-AVYHN2F5.js}

@@ -11,8 +11,10 @@ import {
   askUserContext,
   checkPermission,
   detectsHallucinatedFileOp,
+  formatGitContextForPrompt,
   getContentText,
   getDangerLevel,
+  getGitContext,
   getGitRoot,
   googleSearchContext,
   hadPreviousWriteToolCalls,
@@ -23,8 +25,9 @@ import {
   setContextWindow,
   setupProxy,
   spawnAgentContext,
-  truncateOutput
-} from "./chunk-BSUW2USA.js";
+  truncateOutput,
+  undoStack
+} from "./chunk-PVP4QYKG.js";
 import {
   AGENTIC_BEHAVIOR_GUIDELINE,
   CONTEXT_FILE_CANDIDATES,
@@ -36,7 +39,7 @@ import {
   PLAN_MODE_SYSTEM_ADDON,
   SKILLS_DIR_NAME,
   VERSION
-} from "./chunk-3PBMD3H6.js";
+} from "./chunk-STOS2HXS.js";
 import {
   AuthManager
 } from "./chunk-CPLT6CD3.js";
@@ -46,7 +49,7 @@ import express from "express";
 import { createServer } from "http";
 import { WebSocketServer } from "ws";
 import { join as join3, dirname, resolve as resolve2, relative } from "path";
-import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync, statSync } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { networkInterfaces } from "os";
 
 // src/web/tool-executor-web.ts
@@ -68,6 +71,8 @@ var ToolExecutorWeb = class {
   pendingBatchConfirms = /* @__PURE__ */ new Map();
   /** Publicly readable by SessionHandler to check if confirm is active */
   confirming = false;
+  /** Session-level auto-approve toggle (/yolo command) */
+  sessionAutoApprove = false;
   /** Track tool start times for duration calculation */
   toolStartTimes = /* @__PURE__ */ new Map();
   setRoundInfo(current, total) {
@@ -238,6 +243,20 @@ var ToolExecutorWeb = class {
       }
     }
     this.sendToolCallStart(call);
+    if (this.sessionAutoApprove && (dangerLevel === "write" || dangerLevel === "destructive")) {
+      try {
+        const rawContent = await tool.execute(call.arguments);
+        const content = truncateOutput(rawContent, call.name);
+        this.sendToolCallResult(call, rawContent, false);
+        runHook(this.hookConfig?.postToolExecution, { tool: call.name, status: "ok" });
+        return { callId: call.id, content, isError: false };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        this.sendToolCallResult(call, message, true);
+        runHook(this.hookConfig?.postToolExecution, { tool: call.name, status: "error" });
+        return { callId: call.id, content: message, isError: true };
+      }
+    }
     if (dangerLevel === "write" || dangerLevel === "destructive") {
       const confirmed = await this.confirm(call, dangerLevel);
       if (!confirmed) {
@@ -299,7 +318,7 @@ var ToolExecutorWeb = class {
   }
   async executeBatchFileWrites(items) {
     const calls = items.map((i) => i.call);
-    const decision = await this.batchConfirm(calls);
+    const decision = this.sessionAutoApprove ? "all" : await this.batchConfirm(calls);
     const results = [];
     for (let i = 0; i < calls.length; i++) {
       const call = calls[i];
@@ -403,12 +422,13 @@ function loadMemoryContent(configDir) {
 }
 
 // src/web/session-handler.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, appendFileSync, writeFileSync, mkdirSync } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3, appendFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from "fs";
 import { join as join2, resolve } from "path";
+import { execSync } from "child_process";
 var MAX_TOOL_ROUNDS = 25;
 var FREE_ROUND_TOOLS = /* @__PURE__ */ new Set(["write_todos"]);
 var MAX_CONSECUTIVE_FREE_ROUNDS = 5;
-var SessionHandler = class {
+var SessionHandler = class _SessionHandler {
   ws;
   config;
   providers;
@@ -1044,6 +1064,16 @@ Tokens: in=${this.sessionTokenUsage.inputTokens} out=${this.sessionTokenUsage.ou
             "  /memory              \u2014 Show persistent memory contents",
             "  /memory add <text>   \u2014 Add entry to persistent memory",
             "  /memory clear        \u2014 Clear persistent memory",
+            "  /yolo [on|off]       \u2014 Toggle session auto-approve (skip confirmations)",
+            "  /search <keyword>    \u2014 Search across all session histories",
+            "  /undo [list|<n>]     \u2014 Undo file operations",
+            "  /diff [--stats]      \u2014 Show file modifications in this session",
+            "  /checkpoint [save|restore|delete] <name> \u2014 Session checkpoints",
+            "  /fork [checkpoint]   \u2014 Fork session from checkpoint or current",
+            "  /review [--staged]   \u2014 AI code review from git diff",
+            "  /test [command]      \u2014 Run project tests",
+            "  /init [--force]      \u2014 Generate AICLI.md by scanning project",
+            "  /doctor              \u2014 Health check (API keys, config, MCP)",
             "  /help                \u2014 Show this help message",
             "",
             "\u{1F4A1} Tips:",
@@ -1132,6 +1162,370 @@ ${activated.meta.description || ""}` });
         }
         break;
       }
+      // ── /yolo ──────────────────────────────────────────────────────
+      case "yolo": {
+        const sub = args[0]?.toLowerCase();
+        if (sub === "off") {
+          this.toolExecutor.sessionAutoApprove = false;
+          this.send({ type: "info", message: "\u{1F512} Auto-approve disabled \u2014 confirmations restored for this session." });
+        } else {
+          this.toolExecutor.sessionAutoApprove = true;
+          this.send({ type: "info", message: "\u26A1 YOLO mode ON \u2014 all write/destructive tools auto-approved for this session.\nUse /yolo off to re-enable confirmations." });
+        }
+        break;
+      }
+      // ── /search ─────────────────────────────────────────────────────
+      case "search": {
+        const query = args.join(" ").trim();
+        if (!query) {
+          this.send({ type: "error", message: "Usage: /search <keyword>" });
+          break;
+        }
+        const results = this.sessions.searchMessages(query);
+        if (results.length === 0) {
+          this.send({ type: "info", message: `No sessions found containing "${query}".` });
+          break;
+        }
+        const lines = [`\u{1F50D} Found ${results.length} session(s) containing "${query}"`, ""];
+        for (const r of results) {
+          const { sessionMeta, matches } = r;
+          const dateStr = sessionMeta.updated instanceof Date ? sessionMeta.updated.toLocaleDateString() : String(sessionMeta.updated);
+          lines.push(`**${sessionMeta.id.slice(0, 8)}** [${dateStr}] ${sessionMeta.provider} / ${sessionMeta.model}`);
+          if (sessionMeta.title) lines.push(`  ${sessionMeta.title}`);
+          for (const m of matches) {
+            const icon = m.role === "user" ? "\u{1F464}" : "\u{1F916}";
+            lines.push(`  ${icon} ${m.snippet}`);
+          }
+          lines.push("");
+        }
+        lines.push("Use /session load <id> to resume a session.");
+        this.send({ type: "info", message: lines.join("\n") });
+        break;
+      }
+      // ── /undo ───────────────────────────────────────────────────────
+      case "undo": {
+        const sub = args.join(" ").trim();
+        if (sub === "list") {
+          const history = undoStack.getHistory();
+          if (history.length === 0) {
+            this.send({ type: "info", message: "Undo stack is empty." });
+            break;
+          }
+          const lines = [`\u{1F4CB} Undo Stack (${history.length} entries, newest last):`, ""];
+          history.forEach((entry, i) => {
+            const timeStr = entry.timestamp.toLocaleTimeString();
+            const typeTag = entry.isDirectory ? "[dir]" : entry.previousContent === null ? "[new]" : "[mod]";
+            lines.push(`  ${String(i + 1).padStart(3)}  ${typeTag}  ${entry.description}  ${timeStr}`);
+          });
+          this.send({ type: "info", message: lines.join("\n") });
+          break;
+        }
+        const n = sub ? parseInt(sub, 10) : 1;
+        if (isNaN(n) || n < 1) {
+          this.send({ type: "info", message: "Usage: /undo [list | <n>]" });
+          break;
+        }
+        if (undoStack.depth === 0) {
+          this.send({ type: "info", message: "Nothing to undo." });
+          break;
+        }
+        const count = Math.min(n, undoStack.depth);
+        const undoResults = [];
+        for (let i = 0; i < count; i++) {
+          const top = undoStack.peek();
+          if (!top) break;
+          const undoResult = undoStack.undo();
+          if (undoResult) undoResults.push(undoResult.result);
+        }
+        if (undoResults.length === 0) {
+          this.send({ type: "info", message: "Nothing to undo." });
+        } else {
+          this.send({ type: "info", message: `\u2713 ${undoResults.length} operation(s) undone:
+${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
+        }
+        break;
+      }
+      // ── /diff ───────────────────────────────────────────────────────
+      case "diff": {
+        const history = undoStack.getHistory();
+        if (history.length === 0) {
+          this.send({ type: "info", message: "No file modifications in this session." });
+          break;
+        }
+        const fileMap = /* @__PURE__ */ new Map();
+        for (const entry of history) {
+          if (!fileMap.has(entry.filePath)) {
+            fileMap.set(entry.filePath, { earliest: entry.previousContent });
+          }
+        }
+        const statsOnly = args[0]?.toLowerCase() === "--stats";
+        let newFiles = 0;
+        let modifiedFiles = 0;
+        const diffLines = [];
+        for (const [filePath, { earliest }] of fileMap) {
+          const currentContent = existsSync3(filePath) ? (() => {
+            try {
+              return readFileSync3(filePath, "utf-8");
+            } catch {
+              return null;
+            }
+          })() : null;
+          const isNew = earliest === null;
+          if (isNew) newFiles++;
+          else modifiedFiles++;
+          if (statsOnly) continue;
+          if (isNew) {
+            diffLines.push(`
+\u{1F4C4} [NEW] ${filePath}`);
+            if (currentContent !== null) {
+              diffLines.push(`  ${currentContent.split("\n").length} lines`);
+            } else {
+              diffLines.push("  (file was deleted after creation)");
+            }
+          } else {
+            diffLines.push(`
+\u{1F4DD} [MODIFIED] ${filePath}`);
+            const oldText = earliest ?? "";
+            const newText = currentContent ?? "";
+            if (oldText === newText) {
+              diffLines.push("  (no net change)");
+            } else {
+              diffLines.push(renderDiff(oldText, newText, { filePath, maxLines: 80 }));
+            }
+          }
+        }
+        diffLines.push(`
+**Summary:** ${fileMap.size} file(s) \u2014 ${newFiles} new, ${modifiedFiles} modified`);
+        this.send({ type: "info", message: diffLines.join("\n") });
+        break;
+      }
+      // ── /checkpoint ─────────────────────────────────────────────────
+      case "checkpoint": {
+        const session = this.sessions.current;
+        if (!session) {
+          this.send({ type: "error", message: "No active session." });
+          break;
+        }
+        const sub = args[0]?.toLowerCase();
+        if (!sub || sub === "list") {
+          const cps = session.checkpoints;
+          if (cps.length === 0) {
+            this.send({ type: "info", message: "No checkpoints. Use /checkpoint save <name> to create one." });
+          } else {
+            const lines = [`\u{1F4CC} Checkpoints (${cps.length}):`, ""];
+            for (const cp of cps) {
+              const ts = cp.timestamp.toLocaleString();
+              lines.push(`  ${cp.name.padEnd(20)} msg #${cp.messageIndex}  ${ts}`);
+            }
+            this.send({ type: "info", message: lines.join("\n") });
+          }
+          break;
+        }
+        const cpName = args.slice(1).join(" ").trim();
+        if (sub === "save") {
+          if (!cpName) {
+            this.send({ type: "error", message: "Usage: /checkpoint save <name>" });
+            break;
+          }
+          session.createCheckpoint(cpName);
+          this.send({ type: "info", message: `\u2713 Checkpoint "${cpName}" saved at message #${session.messages.length}` });
+        } else if (sub === "restore") {
+          if (!cpName) {
+            this.send({ type: "error", message: "Usage: /checkpoint restore <name>" });
+            break;
+          }
+          const ok = session.restoreCheckpoint(cpName);
+          if (ok) {
+            this.send({ type: "info", message: `\u2713 Restored to checkpoint "${cpName}" (${session.messages.length} messages)` });
+            this.sendSessionMessages();
+            this.sendStatus();
+          } else {
+            this.send({ type: "error", message: `Checkpoint "${cpName}" not found.` });
+          }
+        } else if (sub === "delete") {
+          if (!cpName) {
+            this.send({ type: "error", message: "Usage: /checkpoint delete <name>" });
+            break;
+          }
+          const ok = session.deleteCheckpoint(cpName);
+          if (ok) {
+            this.send({ type: "info", message: `\u2713 Deleted checkpoint "${cpName}"` });
+          } else {
+            this.send({ type: "error", message: `Checkpoint "${cpName}" not found.` });
+          }
+        } else {
+          this.send({ type: "error", message: `Unknown subcommand: ${sub}. Use save/restore/list/delete.` });
+        }
+        break;
+      }
+      // ── /fork ───────────────────────────────────────────────────────
+      case "fork": {
+        const session = this.sessions.current;
+        if (!session) {
+          this.send({ type: "info", message: "No active session to fork." });
+          break;
+        }
+        const sub = args.join(" ").trim();
+        let messageCount = session.messages.length;
+        let fromLabel = "current position";
+        if (sub) {
+          const cp = session.checkpoints.find((c) => c.name === sub);
+          if (!cp) {
+            const available = session.checkpoints.map((c) => c.name);
+            this.send({ type: "error", message: available.length > 0 ? `Checkpoint "${sub}" not found. Available: ${available.join(", ")}` : `Checkpoint "${sub}" not found. No checkpoints saved.` });
+            break;
+          }
+          messageCount = cp.messageIndex;
+          fromLabel = `checkpoint "${cp.name}" (${cp.messageIndex} messages)`;
+        }
+        try {
+          const originalId = session.id.slice(0, 8);
+          const forked = await this.sessions.forkSession(messageCount);
+          this.send({ type: "info", message: `\u{1F500} Session Forked
+  Original: ${originalId}
+  Forked:   ${forked.id.slice(0, 8)} "${forked.title ?? "(untitled)"}"
+  From:     ${fromLabel}
+  Messages: ${forked.messages.length} copied` });
+          this.sendSessionMessages();
+          this.sendStatus();
+          this.sendSessionList();
+        } catch (err) {
+          this.send({ type: "error", message: `Fork failed: ${err.message}` });
+        }
+        break;
+      }
+      // ── /review ─────────────────────────────────────────────────────
+      case "review": {
+        const gitCtx = getGitContext();
+        if (!gitCtx) {
+          this.send({ type: "error", message: "Not a git repository." });
+          break;
+        }
+        const staged = args.includes("--staged");
+        const detailed = args.includes("--detailed");
+        let diff;
+        try {
+          const cmd = staged ? "git diff --staged" : "git diff";
+          diff = execSync(cmd, { encoding: "utf-8", timeout: 1e4 }).trim();
+        } catch {
+          this.send({ type: "error", message: "Failed to run git diff." });
+          break;
+        }
+        if (!diff) {
+          this.send({ type: "info", message: "No changes to review." + (staged ? "" : " Try --staged for staged changes.") });
+          break;
+        }
+        const MAX_DIFF = 8e3;
+        let truncated = false;
+        if (diff.length > MAX_DIFF) {
+          const head = diff.slice(0, Math.floor(MAX_DIFF * 0.7));
+          const tail = diff.slice(diff.length - Math.floor(MAX_DIFF * 0.2));
+          diff = head + "\n\n... [diff truncated, " + diff.length + " chars total] ...\n\n" + tail;
+          truncated = true;
+        }
+        const reviewPrompt = this.buildReviewPrompt(diff, formatGitContextForPrompt(gitCtx), detailed);
+        this.send({ type: "info", message: "\u{1F50D} Analyzing changes..." });
+        try {
+          const review = await this.chatOnce(reviewPrompt, { temperature: 0.3, maxTokens: 8192 });
+          const msg = truncated ? review + "\n\n\u26A0 Diff was truncated. Consider reviewing smaller changesets." : review;
+          this.send({ type: "info", message: msg });
+        } catch (err) {
+          this.send({ type: "error", message: `Review failed: ${err.message}` });
+        }
+        break;
+      }
+      // ── /test ───────────────────────────────────────────────────────
+      case "test": {
+        this.send({ type: "info", message: "\u{1F9EA} Running tests..." });
+        try {
+          const { executeTests } = await import("./run-tests-6XMNZEGY.js");
+          const argStr = args.join(" ").trim();
+          let testArgs = {};
+          if (argStr) {
+            const isCommand = argStr.includes(" ") || /^(mvn|gradle|npm|pytest|cargo|go)\b/.test(argStr);
+            testArgs = isCommand ? { command: argStr } : { filter: argStr };
+          }
+          const report = await executeTests(testArgs);
+          this.send({ type: "info", message: report });
+        } catch (err) {
+          this.send({ type: "error", message: `Test failed: ${err.message}` });
+        }
+        break;
+      }
+      // ── /init ───────────────────────────────────────────────────────
+      case "init": {
+        const cwd = process.cwd();
+        const targetPath = join2(cwd, "AICLI.md");
+        const force = args.includes("--force");
+        if (existsSync3(targetPath) && !force) {
+          this.send({ type: "info", message: `AICLI.md already exists at ${targetPath}
+Use /init --force to overwrite.` });
+          break;
+        }
+        this.send({ type: "info", message: "\u{1F4DD} Scanning project structure..." });
+        try {
+          const projectInfo = this.scanProject(cwd);
+          const prompt = this.buildInitPrompt(projectInfo, cwd);
+          const content = await this.chatOnce(prompt, { temperature: 0.3, maxTokens: 4096 });
+          writeFileSync(targetPath, content, "utf-8");
+          this.send({ type: "info", message: `\u2713 Generated: ${targetPath} (${content.length} chars)
+Use /context reload to load it.` });
+        } catch (err) {
+          this.send({ type: "error", message: `Failed to generate AICLI.md: ${err.message}` });
+        }
+        break;
+      }
+      // ── /doctor ─────────────────────────────────────────────────────
+      case "doctor": {
+        const lines = ["\u{1FA7A} **AI-CLI Health Check**", ""];
+        lines.push("**API Keys:**");
+        const providersList = this.providers.listAll();
+        for (const p of providersList) {
+          const icon = p.configured ? "\u2713" : "\u25CB";
+          const status = p.configured ? "configured" : "not configured";
+          lines.push(`  ${icon}  ${p.id.padEnd(14)} ${status}`);
+        }
+        lines.push("");
+        const configDir = this.config.getConfigDir();
+        lines.push("**Config Files:**");
+        lines.push(`  Dir: ${configDir}`);
+        const checkFile = (label, filePath) => {
+          const exists = existsSync3(filePath);
+          let extra = "";
+          if (exists) {
+            try {
+              extra = ` (${statSync(filePath).size} bytes)`;
+            } catch {
+            }
+          }
+          lines.push(`  ${exists ? "\u2713" : "\u2013"}  ${label.padEnd(14)} ${exists ? filePath + extra : "(not found)"}`);
+        };
+        checkFile("config.json", join2(configDir, "config.json"));
+        checkFile("memory.md", join2(configDir, MEMORY_FILE_NAME));
+        checkFile("dev-state.md", join2(configDir, "dev-state.md"));
+        lines.push("");
+        if (this.mcpManager) {
+          lines.push("**MCP Servers:**");
+          const statuses = this.mcpManager.getStatus();
+          if (statuses.length === 0) {
+            lines.push("  (no servers configured)");
+          } else {
+            for (const s of statuses) {
+              const state = s.connected ? `connected \xB7 ${s.serverName} \xB7 ${s.toolCount} tools` : `disconnected${s.error ? ` \xB7 ${s.error}` : ""}`;
+              lines.push(`  ${s.connected ? "\u2713" : "\u2717"}  ${s.serverId.padEnd(16)} ${state}`);
+            }
+          }
+          lines.push("");
+        }
+        lines.push("**Current Session:**");
+        lines.push(`  Provider: ${this.currentProvider}`);
+        lines.push(`  Model:    ${this.currentModel}`);
+        lines.push(`  Version:  ${VERSION}`);
+        lines.push("");
+        lines.push("\u2713 Health check complete");
+        this.send({ type: "info", message: lines.join("\n") });
+        break;
+      }
       default:
         this.send({ type: "error", message: `Unknown command: /${name}. Type /help for available commands.` });
     }
@@ -1313,6 +1707,21 @@ ${activated.meta.description || ""}` });
     });
   }
   // ── Helpers ──────────────────────────────────────────────────────
+  /**
+   * One-shot AI call (for /init, /review). Returns plain text content.
+   */
+  async chatOnce(prompt, opts) {
+    const provider = this.providers.get(this.currentProvider);
+    if (!provider) throw new Error("No provider available");
+    const response = await provider.chat({
+      messages: [{ role: "user", content: prompt, timestamp: /* @__PURE__ */ new Date() }],
+      model: this.currentModel,
+      stream: false,
+      temperature: opts?.temperature ?? 0.3,
+      maxTokens: opts?.maxTokens ?? 4096
+    });
+    return response.content;
+  }
   buildSystemPrompt() {
     const skillContent = this.skillManager?.getActivePromptContent();
     const activeSkill = skillContent && this.skillManager?.getActive() ? { name: this.skillManager.getActive().meta.name, content: skillContent } : void 0;
@@ -1367,6 +1776,197 @@ ${activated.meta.description || ""}` });
    *   2. Project: <git-root>/AICLI.md or CLAUDE.md
    *   3. Subdir:  <cwd>/AICLI.md or CLAUDE.md (only if cwd ≠ project root)
    */
+  // ── /init helpers ─────────────────────────────────────────────────
+  static SCAN_SKIP_DIRS = /* @__PURE__ */ new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "out",
+    "target",
+    ".next",
+    ".nuxt",
+    "__pycache__",
+    ".venv",
+    "venv",
+    ".tox",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".gradle",
+    ".idea",
+    ".vscode",
+    ".vs",
+    "coverage",
+    ".cache",
+    ".parcel-cache",
+    "dist-cjs",
+    "release",
+    ".output",
+    ".turbo",
+    "vendor"
+  ]);
+  scanDirTree(dir, maxDepth = 2, maxEntries = 80) {
+    const lines = [];
+    let count = 0;
+    const walk = (d, prefix, depth) => {
+      if (depth > maxDepth || count >= maxEntries) return;
+      let entries;
+      try {
+        entries = readdirSync(d);
+      } catch {
+        return;
+      }
+      const filtered = entries.filter((e) => !e.startsWith(".") && !_SessionHandler.SCAN_SKIP_DIRS.has(e));
+      const sorted = filtered.sort((a, b) => {
+        let aIsDir = false, bIsDir = false;
+        try {
+          aIsDir = statSync(join2(d, a)).isDirectory();
+        } catch {
+        }
+        try {
+          bIsDir = statSync(join2(d, b)).isDirectory();
+        } catch {
+        }
+        if (aIsDir !== bIsDir) return aIsDir ? -1 : 1;
+        return a.localeCompare(b);
+      });
+      for (let i = 0; i < sorted.length && count < maxEntries; i++) {
+        const name = sorted[i];
+        const fullPath = join2(d, name);
+        const isLast = i === sorted.length - 1;
+        let isDir;
+        try {
+          isDir = statSync(fullPath).isDirectory();
+        } catch {
+          continue;
+        }
+        lines.push(prefix + (isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ") + name + (isDir ? "/" : ""));
+        count++;
+        if (isDir) walk(fullPath, prefix + (isLast ? "    " : "\u2502   "), depth + 1);
+      }
+    };
+    walk(dir, "", 0);
+    if (count >= maxEntries) lines.push("... (truncated)");
+    return lines.join("\n");
+  }
+  scanProject(cwd) {
+    const info = { type: "unknown", language: "unknown", configFiles: [], directoryStructure: "" };
+    const check = (file) => existsSync3(join2(cwd, file));
+    const configCandidates = [
+      "package.json",
+      "tsconfig.json",
+      "Cargo.toml",
+      "pyproject.toml",
+      "setup.py",
+      "requirements.txt",
+      "go.mod",
+      "pom.xml",
+      "build.gradle",
+      "build.gradle.kts",
+      "CMakeLists.txt",
+      "Makefile",
+      ".csproj",
+      ".sln",
+      "composer.json",
+      "Gemfile",
+      "mix.exs",
+      "deno.json",
+      "bun.lockb"
+    ];
+    info.configFiles = configCandidates.filter(check);
+    if (check("package.json")) {
+      info.type = "node";
+      info.language = check("tsconfig.json") ? "TypeScript" : "JavaScript";
+      try {
+        const pkg = JSON.parse(readFileSync3(join2(cwd, "package.json"), "utf-8"));
+        const scripts = pkg.scripts ?? {};
+        info.buildCommand = scripts.build ? "npm run build" : void 0;
+        info.testCommand = scripts.test ? "npm test" : void 0;
+        info.devCommand = scripts.dev ? "npm run dev" : void 0;
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (allDeps["react"]) info.framework = "React";
+        else if (allDeps["vue"]) info.framework = "Vue";
+        else if (allDeps["@angular/core"]) info.framework = "Angular";
+        else if (allDeps["next"]) info.framework = "Next.js";
+        else if (allDeps["express"]) info.framework = "Express";
+      } catch {
+      }
+    } else if (check("Cargo.toml")) {
+      info.type = "rust";
+      info.language = "Rust";
+      info.buildCommand = "cargo build";
+      info.testCommand = "cargo test";
+    } else if (check("pyproject.toml") || check("setup.py") || check("requirements.txt")) {
+      info.type = "python";
+      info.language = "Python";
+      info.testCommand = "pytest";
+    } else if (check("go.mod")) {
+      info.type = "go";
+      info.language = "Go";
+      info.buildCommand = "go build ./...";
+      info.testCommand = "go test ./...";
+    } else if (check("pom.xml")) {
+      info.type = "java";
+      info.language = "Java";
+      info.buildCommand = "mvn package";
+      info.testCommand = "mvn test";
+    } else if (check("build.gradle") || check("build.gradle.kts")) {
+      info.type = "java";
+      info.language = "Java/Kotlin";
+      info.buildCommand = "./gradlew build";
+      info.testCommand = "./gradlew test";
+    }
+    info.directoryStructure = this.scanDirTree(cwd);
+    return info;
+  }
+  buildInitPrompt(info, cwd) {
+    const parts = [
+      "Please generate an AICLI.md context file (Markdown format) for the following project.",
+      "\n## Project Info\n",
+      `- Working directory: ${cwd}`,
+      `- Type: ${info.type}`,
+      `- Language: ${info.language}`
+    ];
+    if (info.framework) parts.push(`- Framework: ${info.framework}`);
+    if (info.buildCommand) parts.push(`- Build command: ${info.buildCommand}`);
+    if (info.testCommand) parts.push(`- Test command: ${info.testCommand}`);
+    if (info.devCommand) parts.push(`- Dev command: ${info.devCommand}`);
+    parts.push(`
+## Detected Config Files
+${info.configFiles.map((f) => `- ${f}`).join("\n")}`);
+    parts.push(`
+## Directory Structure
+\`\`\`
+${info.directoryStructure}
+\`\`\``);
+    parts.push(`
+## Requirements
+Generate a structured Markdown file with: project overview, tech stack, project structure, common commands, code style. Keep it concise, within 200 lines.`);
+    return parts.join("\n");
+  }
+  // ── /review helper ──────────────────────────────────────────────────
+  buildReviewPrompt(diff, gitContextStr, detailed) {
+    const level = detailed ? "Please perform a detailed in-depth review covering: security, performance, maintainability, error handling, naming conventions, and code duplication." : "Please perform a concise code review focusing on bugs, security issues, and key improvement suggestions.";
+    return `# Code Review Request
+
+${level}
+
+## Git Status
+${gitContextStr}
+
+## Code Changes (diff)
+\`\`\`diff
+${diff}
+\`\`\`
+
+## Output Format
+1. **Overall Assessment**: One-sentence summary
+2. **Issues** (if any): [Severity] file:line \u2014 description + fix
+3. **Improvement Suggestions** (if any)
+4. **Highlights** (if any)
+
+Severity: \u{1F534} Critical / \u{1F7E1} Warning / \u{1F535} Info`;
+  }
   loadContextFiles() {
     const parts = [];
     const cwd = process.cwd();
@@ -1515,7 +2115,7 @@ async function startWebServer(options = {}) {
     }
     try {
       const SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "dist-cjs", "release", "__pycache__", ".next", ".nuxt", "coverage", ".cache"]);
-      const entries = readdirSync(targetDir, { withFileTypes: true });
+      const entries = readdirSync2(targetDir, { withFileTypes: true });
       const files = entries.filter((e) => !SKIP.has(e.name) && !e.name.startsWith(".")).slice(0, 50).map((e) => ({
         name: e.name,
         path: relative(cwd, join3(targetDir, e.name)).replace(/\\/g, "/"),
@@ -1556,7 +2156,7 @@ async function startWebServer(options = {}) {
       return;
     }
     try {
-      const stat = statSync(fullPath);
+      const stat = statSync2(fullPath);
       if (stat.size > 512 * 1024) {
         res.json({ error: `File too large (${(stat.size / 1024).toFixed(0)} KB, max 512 KB)` });
         return;