agdi 2.2.3 → 2.4.1

package/dist/index.js

@@ -1,9 +1,15 @@
 #!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/index.ts
 import { Command } from "commander";
-import chalk12 from "chalk";
-import ora4 from "ora";
+import chalk13 from "chalk";
+import ora5 from "ora";
 
 // src/core/llm/index.ts
 var PuterProvider = class {
@@ -46,6 +52,38 @@ var PuterProvider = class {
       usage: typeof data !== "string" ? data.usage : void 0
     };
   }
+  async chat(messages) {
+    const response = await fetch("https://api.puter.com/ai/chat", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.model,
+        messages: messages.map((m) => ({ role: m.role, content: m.content }))
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Puter API error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    let text = "";
+    if (typeof data === "string") {
+      text = data;
+    } else if (data.message?.content) {
+      if (Array.isArray(data.message.content)) {
+        text = data.message.content.map((c) => c.text || "").join("");
+      } else {
+        text = data.message.content;
+      }
+    } else if (data.choices?.[0]?.message?.content) {
+      text = data.choices[0].message.content;
+    }
+    return {
+      text,
+      usage: typeof data !== "string" ? data.usage : void 0
+    };
+  }
 };
 var GeminiProvider = class {
   config;
@@ -71,6 +109,28 @@ var GeminiProvider = class {
       usage: void 0
     };
   }
+  async chat(messages) {
+    const { GoogleGenAI } = await import("@google/genai");
+    const ai = new GoogleGenAI({ apiKey: this.config.apiKey });
+    const contents = messages.map((m) => {
+      if (m.role === "system") {
+        return { role: "user", parts: [{ text: m.content }] };
+      }
+      return {
+        role: m.role === "assistant" ? "model" : "user",
+        parts: [{ text: m.content }]
+      };
+    });
+    const response = await ai.models.generateContent({
+      model: this.config.model || "gemini-2.5-flash",
+      contents
+    });
+    const text = response.candidates?.[0]?.content?.parts?.[0]?.text || "";
+    return {
+      text,
+      usage: void 0
+    };
+  }
 };
 var OpenRouterProvider = class {
   config;
@@ -107,6 +167,33 @@ var OpenRouterProvider = class {
       } : void 0
     };
   }
+  async chat(messages) {
+    const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.config.apiKey}`,
+        "HTTP-Referer": "https://agdi.dev",
+        "X-Title": "Agdi CLI"
+      },
+      body: JSON.stringify({
+        model: this.config.model || "anthropic/claude-3.5-sonnet",
+        messages: messages.map((m) => ({ role: m.role, content: m.content }))
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenRouter API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    return {
+      text: data.choices?.[0]?.message?.content || "",
+      usage: data.usage ? {
+        inputTokens: data.usage.prompt_tokens,
+        outputTokens: data.usage.completion_tokens
+      } : void 0
+    };
+  }
 };
 function createLLMProvider(provider, config) {
   switch (provider) {
@@ -364,6 +451,18 @@ var MALICIOUS_PATTERNS = [
     description: "Private key detected",
     severity: "critical"
   },
+  {
+    pattern: /sk-ant-[A-Za-z0-9-_]{95,}/g,
+    category: "secret",
+    description: "Anthropic API key detected",
+    severity: "critical"
+  },
+  {
+    pattern: /sk-ant-api[A-Za-z0-9-_]{90,}/g,
+    category: "secret",
+    description: "Anthropic API key (alt format) detected",
+    severity: "critical"
+  },
   // ==================== DANGEROUS CODE PATTERNS ====================
   {
     pattern: /\beval\s*\(/g,
@@ -475,6 +574,50 @@ var MALICIOUS_PATTERNS = [
     category: "dangerous",
     description: "Template literal with shell commands",
     severity: "medium"
+  },
+  // ==================== PROMPT INJECTION DEFENSE ====================
+  {
+    pattern: /ignore\s+(all\s+)?(previous|above|prior)\s+(instructions?|prompts?|rules?)/gi,
+    category: "suspicious",
+    description: "Prompt injection: instruction override attempt",
+    severity: "critical"
+  },
+  {
+    pattern: /\[SYSTEM\]|\[INST\]|<\|im_start\|>|<\|endoftext\|>/gi,
+    category: "suspicious",
+    description: "Prompt injection: model control tokens",
+    severity: "critical"
+  },
+  {
+    pattern: /you\s+are\s+(now\s+)?(a|an|the)\s+\w+\s+(that|who|which)/gi,
+    category: "suspicious",
+    description: "Prompt injection: role override attempt",
+    severity: "high"
+  },
+  {
+    pattern: /disregard\s+(all\s+)?safety|bypass\s+(all\s+)?security|disable\s+(all\s+)?restrictions/gi,
+    category: "suspicious",
+    description: "Prompt injection: safety bypass attempt",
+    severity: "critical"
+  },
+  {
+    pattern: /\bexec\s*\(\s*[`'"].*?\$\(.*?\)/g,
+    category: "dangerous",
+    description: "Command injection via exec with substitution",
+    severity: "critical"
+  },
+  // ==================== NETWORK EXFILTRATION ====================
+  {
+    pattern: /\bfetch\s*\(\s*['"`]https?:\/\/[^'"`]*\.(ru|cn|tk|ml|ga)\//gi,
+    category: "suspicious",
+    description: "Request to suspicious TLD",
+    severity: "high"
+  },
+  {
+    pattern: /\bnew\s+WebSocket\s*\(\s*['"`]wss?:\/\/(?!localhost|127\.0\.0\.1)/g,
+    category: "suspicious",
+    description: "WebSocket to external server",
+    severity: "medium"
   }
 ];
 function scanCode(code, filename) {
@@ -1270,10 +1413,10 @@ async function selectModel() {
 `));
 }
 
-// src/commands/codex.ts
-import { input as input4 } from "@inquirer/prompts";
-import chalk11 from "chalk";
-import ora3 from "ora";
+// src/commands/agdi-dev.ts
+import { input as input5, confirm as confirm3 } from "@inquirer/prompts";
+import chalk12 from "chalk";
+import ora4 from "ora";
 
 // src/actions/plan-executor.ts
 import { select as select4, confirm } from "@inquirer/prompts";
@@ -1331,6 +1474,40 @@ function summarizePlan(plan) {
     riskTier: maxRiskTier
   };
 }
+function validateAction(action) {
+  if (!action || typeof action !== "object") return null;
+  const obj = action;
+  const type = obj.type;
+  if (type === "mkdir") {
+    if (typeof obj.path !== "string" || !obj.path) return null;
+    if (obj.path.includes("..") || obj.path.startsWith("/") || /^[A-Z]:/i.test(obj.path)) return null;
+    return { type: "mkdir", path: obj.path };
+  }
+  if (type === "writeFile") {
+    if (typeof obj.path !== "string" || !obj.path) return null;
+    if (typeof obj.content !== "string") return null;
+    if (obj.path.includes("..") || obj.path.startsWith("/") || /^[A-Z]:/i.test(obj.path)) return null;
+    return { type: "writeFile", path: obj.path, content: obj.content };
+  }
+  if (type === "deleteFile") {
+    if (typeof obj.path !== "string" || !obj.path) return null;
+    if (obj.path.includes("..") || obj.path.startsWith("/") || /^[A-Z]:/i.test(obj.path)) return null;
+    return { type: "deleteFile", path: obj.path };
+  }
+  if (type === "exec") {
+    if (!Array.isArray(obj.argv) || obj.argv.length === 0) return null;
+    if (!obj.argv.every((a) => typeof a === "string")) return null;
+    const dangerous = ["sudo", "su", "rm -rf /", "format", "mkfs", "dd", ":(){"];
+    const cmdStr = obj.argv.join(" ").toLowerCase();
+    if (dangerous.some((d) => cmdStr.includes(d))) return null;
+    return {
+      type: "exec",
+      argv: obj.argv,
+      cwd: typeof obj.cwd === "string" ? obj.cwd : void 0
+    };
+  }
+  return null;
+}
 function parseActionPlan(response) {
   try {
     const jsonMatch = response.match(/\{[\s\S]*"actions"[\s\S]*\}/);
@@ -1341,10 +1518,23 @@ function parseActionPlan(response) {
     if (!parsed.actions || !Array.isArray(parsed.actions)) {
       return null;
     }
+    const validatedActions = [];
+    for (const action of parsed.actions) {
+      const validated = validateAction(action);
+      if (!validated) {
+        console.warn(`Invalid action rejected: ${JSON.stringify(action).slice(0, 100)}`);
+        continue;
+      }
+      validatedActions.push(validated);
+    }
+    if (validatedActions.length === 0) {
+      return null;
+    }
+    const projectName = typeof parsed.projectName === "string" ? parsed.projectName.replace(/[^a-zA-Z0-9-_]/g, "-").slice(0, 50) : "generated-app";
     return {
-      projectName: parsed.projectName || "generated-app",
-      actions: parsed.actions,
-      nextSteps: parsed.nextSteps
+      projectName,
+      actions: validatedActions,
+      nextSteps: typeof parsed.nextSteps === "string" ? parsed.nextSteps : void 0
     };
   } catch {
     return null;
@@ -1661,6 +1851,68 @@ async function deleteFileTool(path4) {
     return { success: false, error: msg };
   }
 }
+async function applyPatchTool(path4, unifiedDiff) {
+  const validation = validatePath(path4);
+  if (!validation.valid) {
+    return { success: false, error: validation.error };
+  }
+  try {
+    const current = existsSync3(validation.resolved) ? await readFile(validation.resolved, "utf-8") : "";
+    const patched = applySimplePatch(current, unifiedDiff);
+    if (patched === null) {
+      return { success: false, error: "Failed to apply patch" };
+    }
+    await writeFile(validation.resolved, patched, "utf-8");
+    logEvent({
+      eventType: "command_result",
+      command: `applyPatch ${path4}`,
+      result: { exitCode: 0 },
+      metadata: {
+        tool: "applyPatchTool",
+        path: validation.resolved,
+        patchLength: unifiedDiff.length
+      }
+    });
+    return { success: true };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return { success: false, error: msg };
+  }
+}
+function applySimplePatch(content, diff) {
+  const lines = content.split("\n");
+  const diffLines = diff.split("\n");
+  let lineIndex = 0;
+  const result = [];
+  for (const diffLine of diffLines) {
+    if (diffLine.startsWith("---") || diffLine.startsWith("+++") || diffLine.startsWith("@@")) {
+      continue;
+    }
+    if (diffLine.startsWith("-")) {
+      lineIndex++;
+    } else if (diffLine.startsWith("+")) {
+      result.push(diffLine.slice(1));
+    } else if (diffLine.startsWith(" ") || diffLine === "") {
+      if (lineIndex < lines.length) {
+        result.push(lines[lineIndex]);
+        lineIndex++;
+      }
+    }
+  }
+  while (lineIndex < lines.length) {
+    result.push(lines[lineIndex]);
+    lineIndex++;
+  }
+  return result.join("\n");
+}
+function resolvePath(path4) {
+  const env = getEnvironment();
+  return resolve(env.workspaceRoot, path4);
+}
+function fileExists(path4) {
+  const resolved = resolvePath(path4);
+  return existsSync3(resolved);
+}
 
 // src/security/permission-gate.ts
 import { resolve as resolve2, relative as relative2, isAbsolute as isAbsolute2 } from "path";
@@ -2455,6 +2707,11 @@ function saveTrustConfig(config) {
 function normalizePath(path4) {
   return resolve3(path4).toLowerCase().replace(/\\/g, "/");
 }
+function isWorkspaceTrusted(workspacePath) {
+  const config = loadTrustConfig();
+  const normalized = normalizePath(workspacePath);
+  return config.trustedWorkspaces.some((w) => w.normalizedPath === normalized);
+}
 function trustWorkspace(workspacePath) {
   const config = loadTrustConfig();
   const normalized = normalizePath(workspacePath);
@@ -2468,6 +2725,63 @@ function trustWorkspace(workspacePath) {
   });
   saveTrustConfig(config);
 }
+async function promptWorkspaceTrust(workspacePath) {
+  if (isWorkspaceTrusted(workspacePath)) {
+    console.log(chalk9.green("\u2713 Workspace is trusted\n"));
+    return "persistent";
+  }
+  console.log(chalk9.yellow("\n\u26A0\uFE0F  Untrusted Workspace"));
+  console.log(chalk9.gray(`   ${workspacePath}
+`));
+  console.log(chalk9.gray("Agdi can run commands in this workspace."));
+  console.log(chalk9.gray("Do you trust the contents of this folder?\n"));
+  const choice = await select3({
+    message: "Trust this workspace?",
+    choices: [
+      {
+        name: "Trust for this session only",
+        value: "session",
+        description: "Allow commands for this session, ask again next time"
+      },
+      {
+        name: "Trust and remember",
+        value: "persistent",
+        description: "Always trust this workspace"
+      },
+      {
+        name: "Exit (don't trust)",
+        value: "exit",
+        description: "Exit without granting trust"
+      }
+    ]
+  });
+  return choice;
+}
+async function handleTrustFlow(workspacePath) {
+  const choice = await promptWorkspaceTrust(workspacePath);
+  switch (choice) {
+    case "session":
+      updateEnvironment({ trustLevel: "session" });
+      console.log(chalk9.green("\u2713 Trusted for this session\n"));
+      return "session";
+    case "persistent":
+      trustWorkspace(workspacePath);
+      updateEnvironment({ trustLevel: "persistent" });
+      console.log(chalk9.green("\u2713 Workspace trusted and remembered\n"));
+      return "persistent";
+    case "exit":
+      console.log(chalk9.yellow("\n\u{1F44B} Exiting. Workspace not trusted.\n"));
+      return null;
+  }
+}
+async function ensureTrusted(workspacePath) {
+  if (isWorkspaceTrusted(workspacePath)) {
+    updateEnvironment({ trustLevel: "persistent" });
+    return true;
+  }
+  const result = await handleTrustFlow(workspacePath);
+  return result !== null;
+}
 
 // src/actions/plan-executor.ts
 function displayPlanSummary(plan) {
@@ -2733,14 +3047,775 @@ async function parseAndExecutePlan(response) {
   return executePlan(plan);
 }
 
-// src/commands/codex.ts
-var CHAT_SYSTEM_PROMPT = `You are Agdi dev, an elite AI coding assistant. You help developers write code, debug issues, and build applications.
+// src/core/context-manager.ts
+import { readdirSync, readFileSync as readFileSync5, statSync, existsSync as existsSync6 } from "fs";
+import { join as join4, basename } from "path";
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  ".cache",
+  "coverage",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".idea",
+  ".vscode",
+  ".turbo"
+]);
+var IGNORED_FILES = /* @__PURE__ */ new Set([
+  ".DS_Store",
+  "Thumbs.db",
+  ".env",
+  ".env.local",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml"
+]);
+var MAX_TREE_DEPTH = 4;
+var MAX_FILES_PER_DIR = 20;
+function getWorkspaceTree(rootDir, maxDepth = MAX_TREE_DEPTH) {
+  const env = getEnvironment();
+  const root = rootDir || env.workspaceRoot;
+  if (!existsSync6(root)) {
+    return "(workspace not found)";
+  }
+  const lines = [];
+  lines.push(basename(root) + "/");
+  buildTree(root, "", lines, 0, maxDepth);
+  return lines.join("\n");
+}
+function buildTree(dir, prefix, lines, depth, maxDepth) {
+  if (depth >= maxDepth) {
+    lines.push(prefix + "\u2514\u2500\u2500 ...");
+    return;
+  }
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return;
+  }
+  const filtered = entries.filter((e) => {
+    if (IGNORED_DIRS.has(e) || IGNORED_FILES.has(e)) return false;
+    if (e.startsWith(".") && e !== ".github") return false;
+    return true;
+  });
+  const dirs = [];
+  const files = [];
+  for (const entry of filtered) {
+    const fullPath = join4(dir, entry);
+    try {
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        dirs.push(entry);
+      } else {
+        files.push(entry);
+      }
+    } catch {
+    }
+  }
+  dirs.sort();
+  files.sort();
+  const allEntries = [...dirs.map((d) => ({ name: d, isDir: true })), ...files.map((f) => ({ name: f, isDir: false }))];
+  const truncated = allEntries.length > MAX_FILES_PER_DIR;
+  const toShow = truncated ? allEntries.slice(0, MAX_FILES_PER_DIR) : allEntries;
+  toShow.forEach((entry, index) => {
+    const isLast = index === toShow.length - 1 && !truncated;
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const childPrefix = isLast ? "    " : "\u2502   ";
+    if (entry.isDir) {
+      lines.push(prefix + connector + entry.name + "/");
+      buildTree(join4(dir, entry.name), prefix + childPrefix, lines, depth + 1, maxDepth);
+    } else {
+      lines.push(prefix + connector + entry.name);
+    }
+  });
+  if (truncated) {
+    lines.push(prefix + "\u2514\u2500\u2500 ... (" + (allEntries.length - MAX_FILES_PER_DIR) + " more)");
+  }
+}
+function getProjectConfig(rootDir) {
+  const env = getEnvironment();
+  const root = rootDir || env.workspaceRoot;
+  const packageJsonPath = join4(root, "package.json");
+  if (existsSync6(packageJsonPath)) {
+    try {
+      const content = readFileSync5(packageJsonPath, "utf-8");
+      const pkg = JSON.parse(content);
+      return {
+        name: pkg.name || basename(root),
+        version: pkg.version,
+        description: pkg.description,
+        dependencies: pkg.dependencies,
+        devDependencies: pkg.devDependencies,
+        scripts: pkg.scripts
+      };
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function buildWorkspaceContext(rootDir) {
+  const env = getEnvironment();
+  const root = rootDir || env.workspaceRoot;
+  return {
+    workspaceRoot: root,
+    fileTree: getWorkspaceTree(root),
+    projectConfig: getProjectConfig(root),
+    gitStatus: null
+    // Filled by GitManager
+  };
+}
+function formatContextForPrompt(context) {
+  const sections = [];
+  sections.push("## Current Workspace");
+  sections.push(`Path: ${context.workspaceRoot}`);
+  if (context.projectConfig) {
+    const cfg = context.projectConfig;
+    sections.push(`
+Project: ${cfg.name}${cfg.version ? " v" + cfg.version : ""}`);
+    if (cfg.description) {
+      sections.push(`Description: ${cfg.description}`);
+    }
+    if (cfg.scripts) {
+      const scriptList = Object.keys(cfg.scripts).slice(0, 5).join(", ");
+      sections.push(`Scripts: ${scriptList}`);
+    }
+  }
+  sections.push("\n## File Structure");
+  sections.push("```");
+  sections.push(context.fileTree);
+  sections.push("```");
+  if (context.gitStatus) {
+    sections.push("\n## Git Status");
+    sections.push(context.gitStatus);
+  }
+  return sections.join("\n");
+}
+
+// src/core/git-manager.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync7 } from "fs";
+import { join as join5 } from "path";
+function execGit(args, cwd) {
+  const env = getEnvironment();
+  const workDir = cwd || env.workspaceRoot;
+  try {
+    const result = spawnSync("git", args, {
+      cwd: workDir,
+      encoding: "utf-8",
+      timeout: 1e4
+    });
+    if (result.error) {
+      throw result.error;
+    }
+    return result.stdout?.trim() || "";
+  } catch (error) {
+    return "";
+  }
+}
+function isGitRepo(dir) {
+  const env = getEnvironment();
+  const checkDir = dir || env.workspaceRoot;
+  return existsSync7(join5(checkDir, ".git"));
+}
+function getStatus(cwd) {
+  if (!isGitRepo(cwd)) {
+    return {
+      isGitRepo: false,
+      branch: "",
+      ahead: 0,
+      behind: 0,
+      staged: [],
+      unstaged: [],
+      untracked: [],
+      hasConflicts: false
+    };
+  }
+  const branch = execGit(["rev-parse", "--abbrev-ref", "HEAD"], cwd) || "main";
+  let ahead = 0;
+  let behind = 0;
+  const trackingInfo = execGit(["rev-list", "--left-right", "--count", `origin/${branch}...HEAD`], cwd);
+  if (trackingInfo) {
+    const [behindStr, aheadStr] = trackingInfo.split(/\s+/);
+    behind = parseInt(behindStr, 10) || 0;
+    ahead = parseInt(aheadStr, 10) || 0;
+  }
+  const statusOutput = execGit(["status", "--porcelain=v1"], cwd);
+  const staged = [];
+  const unstaged = [];
+  const untracked = [];
+  let hasConflicts = false;
+  for (const line of statusOutput.split("\n")) {
+    if (!line) continue;
+    const indexStatus = line[0];
+    const workTreeStatus = line[1];
+    const filePath = line.slice(3).trim();
+    if (indexStatus === "U" || workTreeStatus === "U" || indexStatus === "A" && workTreeStatus === "A" || indexStatus === "D" && workTreeStatus === "D") {
+      hasConflicts = true;
+    }
+    if (indexStatus === "?" && workTreeStatus === "?") {
+      untracked.push(filePath);
+      continue;
+    }
+    if (indexStatus !== " " && indexStatus !== "?") {
+      staged.push({
+        path: filePath,
+        status: parseStatus(indexStatus)
+      });
+    }
+    if (workTreeStatus !== " " && workTreeStatus !== "?") {
+      unstaged.push({
+        path: filePath,
+        status: parseStatus(workTreeStatus)
+      });
+    }
+  }
+  return {
+    isGitRepo: true,
+    branch,
+    ahead,
+    behind,
+    staged,
+    unstaged,
+    untracked,
+    hasConflicts
+  };
+}
+function parseStatus(code) {
+  switch (code) {
+    case "A":
+      return "added";
+    case "M":
+      return "modified";
+    case "D":
+      return "deleted";
+    case "R":
+      return "renamed";
+    case "C":
+      return "copied";
+    default:
+      return "modified";
+  }
+}
+function getDiff(staged = false, cwd) {
+  if (!isGitRepo(cwd)) {
+    return { files: [], summary: "(not a git repository)" };
+  }
+  const args = staged ? ["diff", "--cached", "--stat"] : ["diff", "--stat"];
+  const statOutput = execGit(args, cwd);
+  const patchArgs = staged ? ["diff", "--cached"] : ["diff"];
+  const patchOutput = execGit(patchArgs, cwd);
+  const files = [];
+  const statLines = statOutput.split("\n");
+  for (const line of statLines) {
+    const match = line.match(/^\s*(.+?)\s+\|\s+(\d+)\s*([+-]*)/);
+    if (match) {
+      const [, path4, changes, plusMinus] = match;
+      const additions = (plusMinus.match(/\+/g) || []).length;
+      const deletions = (plusMinus.match(/-/g) || []).length;
+      const filePatches = patchOutput.split(/^diff --git/m);
+      const filePatch = filePatches.find((p) => p.includes(path4.trim())) || "";
+      files.push({
+        path: path4.trim(),
+        additions,
+        deletions,
+        patch: filePatch.slice(0, 2e3)
+        // Limit patch size
+      });
+    }
+  }
+  const totalAdditions = files.reduce((sum, f) => sum + f.additions, 0);
+  const totalDeletions = files.reduce((sum, f) => sum + f.deletions, 0);
+  const summary = `${files.length} file(s) changed, ${totalAdditions} insertion(s), ${totalDeletions} deletion(s)`;
+  return { files, summary };
+}
+function formatStatusForPrompt(status) {
+  if (!status.isGitRepo) {
+    return "(not a git repository)";
+  }
+  const lines = [];
+  lines.push(`Branch: ${status.branch}`);
+  if (status.ahead > 0 || status.behind > 0) {
+    lines.push(`Tracking: ${status.ahead} ahead, ${status.behind} behind origin`);
+  }
+  if (status.hasConflicts) {
+    lines.push("\u26A0\uFE0F  MERGE CONFLICTS DETECTED");
+  }
+  if (status.staged.length > 0) {
+    lines.push(`
+Staged (${status.staged.length}):`);
+    for (const f of status.staged.slice(0, 10)) {
+      lines.push(`  ${f.status[0].toUpperCase()} ${f.path}`);
+    }
+    if (status.staged.length > 10) {
+      lines.push(`  ... and ${status.staged.length - 10} more`);
+    }
+  }
+  if (status.unstaged.length > 0) {
+    lines.push(`
+Unstaged (${status.unstaged.length}):`);
+    for (const f of status.unstaged.slice(0, 10)) {
+      lines.push(`  ${f.status[0].toUpperCase()} ${f.path}`);
+    }
+    if (status.unstaged.length > 10) {
+      lines.push(`  ... and ${status.unstaged.length - 10} more`);
+    }
+  }
+  if (status.untracked.length > 0) {
+    lines.push(`
+Untracked (${status.untracked.length}):`);
+    for (const f of status.untracked.slice(0, 5)) {
+      lines.push(`  ? ${f}`);
+    }
+    if (status.untracked.length > 5) {
+      lines.push(`  ... and ${status.untracked.length - 5} more`);
+    }
+  }
+  if (status.staged.length === 0 && status.unstaged.length === 0 && status.untracked.length === 0) {
+    lines.push("\n\u2713 Working tree clean");
+  }
+  return lines.join("\n");
+}
+function formatDiffForPrompt(diff) {
+  if (diff.files.length === 0) {
+    return "(no changes)";
+  }
+  const lines = [];
+  lines.push(diff.summary);
+  lines.push("");
+  for (const file of diff.files.slice(0, 5)) {
+    lines.push(`### ${file.path}`);
+    lines.push(`+${file.additions} -${file.deletions}`);
+    if (file.patch) {
+      lines.push("```diff");
+      lines.push(file.patch.slice(0, 1e3));
+      if (file.patch.length > 1e3) lines.push("... (truncated)");
+      lines.push("```");
+    }
+    lines.push("");
+  }
+  if (diff.files.length > 5) {
+    lines.push(`... and ${diff.files.length - 5} more files`);
+  }
+  return lines.join("\n");
+}
+
+// src/core/conversation-manager.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
+var AGDI_DIR = join6(homedir5(), ".agdi");
+var SESSIONS_DIR = join6(AGDI_DIR, "sessions");
+var MAX_CONTEXT_TOKENS = 32e3;
+var CHARS_PER_TOKEN = 4;
+var ConversationManager = class _ConversationManager {
+  messages = [];
+  sessionId;
+  systemPrompt = "";
+  constructor(sessionId) {
+    this.sessionId = sessionId || this.generateSessionId();
+  }
+  /**
+   * Set the system prompt (persists across conversation)
+   */
+  setSystemPrompt(prompt) {
+    this.systemPrompt = prompt;
+  }
+  /**
+   * Get the system prompt
+   */
+  getSystemPrompt() {
+    return this.systemPrompt;
+  }
+  /**
+   * Add a user message
+   */
+  addUserMessage(content) {
+    this.messages.push({
+      role: "user",
+      content,
+      timestamp: Date.now()
+    });
+    this.trimToContextLimit();
+  }
+  /**
+   * Add an assistant response
+   */
+  addAssistantMessage(content) {
+    this.messages.push({
+      role: "assistant",
+      content,
+      timestamp: Date.now()
+    });
+    this.trimToContextLimit();
+  }
+  /**
+   * Get all messages for LLM context
+   */
+  getMessages() {
+    return [...this.messages];
+  }
+  /**
+   * Get messages formatted for API calls
+   */
+  getMessagesForAPI() {
+    const result = [];
+    if (this.systemPrompt) {
+      result.push({ role: "system", content: this.systemPrompt });
+    }
+    for (const msg of this.messages) {
+      result.push({ role: msg.role, content: msg.content });
+    }
+    return result;
+  }
+  /**
+   * Get message count
+   */
+  getMessageCount() {
+    return this.messages.length;
+  }
+  /**
+   * Get turn count (user messages)
+   */
+  getTurnCount() {
+    return this.messages.filter((m) => m.role === "user").length;
+  }
+  /**
+   * Clear conversation history
+   */
+  clear() {
+    this.messages = [];
+  }
+  /**
+   * Get session ID
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Get last N messages
+   */
+  getLastMessages(n) {
+    return this.messages.slice(-n);
+  }
+  /**
+   * Get conversation summary for display
+   */
+  getSummary() {
+    const turns = this.getTurnCount();
+    const tokens = this.estimateTokens();
+    return `Session: ${this.sessionId} | ${turns} turns | ~${tokens} tokens`;
+  }
+  /**
+   * Estimate token count
+   */
+  estimateTokens() {
+    let chars = this.systemPrompt.length;
+    for (const msg of this.messages) {
+      chars += msg.content.length;
+    }
+    return Math.ceil(chars / CHARS_PER_TOKEN);
+  }
+  /**
+   * Trim messages to stay within context limit
+   */
+  trimToContextLimit() {
+    while (this.estimateTokens() > MAX_CONTEXT_TOKENS && this.messages.length > 2) {
+      this.messages.shift();
+    }
+  }
+  /**
+   * Generate a unique session ID
+   */
+  generateSessionId() {
+    const now = /* @__PURE__ */ new Date();
+    const date = now.toISOString().split("T")[0];
+    const random = Math.random().toString(36).substring(2, 8);
+    return `${date}-${random}`;
+  }
+  // ==================== PERSISTENCE ====================
+  /**
+   * Save session to disk
+   */
+  save() {
+    this.ensureDirectories();
+    const session = {
+      id: this.sessionId,
+      messages: this.messages,
+      createdAt: this.messages[0]?.timestamp || Date.now(),
+      updatedAt: Date.now()
+    };
+    const filePath = join6(SESSIONS_DIR, `${this.sessionId}.json`);
+    writeFileSync4(filePath, JSON.stringify(session, null, 2));
+  }
+  /**
+   * Load session from disk
+   */
+  static load(sessionId) {
+    const filePath = join6(SESSIONS_DIR, `${sessionId}.json`);
+    if (!existsSync8(filePath)) {
+      return null;
+    }
+    try {
+      const content = readFileSync6(filePath, "utf-8");
+      const session = JSON.parse(content);
+      const manager = new _ConversationManager(session.id);
+      manager.messages = session.messages;
+      return manager;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * List available sessions
+   */
+  static listSessions() {
+    if (!existsSync8(SESSIONS_DIR)) {
+      return [];
+    }
+    const { readdirSync: readdirSync2 } = __require("fs");
+    const files = readdirSync2(SESSIONS_DIR);
+    return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", "")).sort().reverse();
+  }
+  /**
+   * Ensure directories exist
+   */
+  ensureDirectories() {
+    if (!existsSync8(AGDI_DIR)) {
+      mkdirSync4(AGDI_DIR, { recursive: true });
+    }
+    if (!existsSync8(SESSIONS_DIR)) {
+      mkdirSync4(SESSIONS_DIR, { recursive: true });
+    }
+  }
+};
+var currentConversation = null;
+function getConversation() {
+  if (!currentConversation) {
+    currentConversation = new ConversationManager();
+  }
+  return currentConversation;
+}
+function clearConversation() {
+  if (currentConversation) {
+    currentConversation.clear();
+  }
+}
+
+// src/core/file-editor.ts
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync9 } from "fs";
+import chalk11 from "chalk";
+import ora3 from "ora";
+import { input as input4, confirm as confirm2 } from "@inquirer/prompts";
+var EDIT_SYSTEM_PROMPT = `You are a surgical code editor. Given a file's content and an edit instruction, output ONLY a unified diff patch.
+
+## Output Format (STRICT)
+\`\`\`diff
+--- a/filename
++++ b/filename
+@@ -start,count +start,count @@
+ context line (unchanged)
+-removed line
++added line
+ context line (unchanged)
+\`\`\`
+
+## Rules
+1. Output ONLY the diff block, no explanation before or after
+2. Include 3 context lines around each change
+3. Use proper unified diff format with @@ hunk headers
+4. Preserve exact indentation (spaces/tabs)
+5. Multiple changes = multiple @@ hunks
+6. Line numbers in @@ must be accurate
+
+## Example
+Input: "Add a console.log at line 5"
+Output:
+\`\`\`diff
+--- a/index.ts
++++ b/index.ts
+@@ -3,6 +3,7 @@
+ import { foo } from './foo';
+ 
+ function main() {
++    console.log('Debug point');
+     const result = foo();
+     return result;
+ }
+\`\`\``;
+async function readFileForEdit(filePath) {
+  const resolved = resolvePath(filePath);
+  if (!existsSync9(resolved)) {
+    return null;
+  }
+  try {
+    const content = await readFile2(resolved, "utf-8");
+    const lines = content.split("\n");
+    const numbered = lines.map((line, i) => `${String(i + 1).padStart(4, " ")} \u2502 ${line}`).join("\n");
+    return { content, numbered };
+  } catch {
+    return null;
+  }
+}
+function extractDiff(response) {
+  const diffMatch = response.match(/```diff\n([\s\S]*?)```/);
+  if (diffMatch) {
+    return diffMatch[1].trim();
+  }
+  const codeMatch = response.match(/```\n([\s\S]*?)```/);
+  if (codeMatch && codeMatch[1].includes("@@")) {
+    return codeMatch[1].trim();
+  }
+  if (response.includes("@@") && (response.includes("---") || response.includes("+++"))) {
+    return response.trim();
+  }
+  return null;
+}
+function previewDiff(diff) {
+  console.log(chalk11.cyan.bold("\n\u{1F4DD} Proposed Changes:\n"));
+  const lines = diff.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("+++") || line.startsWith("---")) {
+      console.log(chalk11.gray(line));
+    } else if (line.startsWith("@@")) {
+      console.log(chalk11.cyan(line));
+    } else if (line.startsWith("+")) {
+      console.log(chalk11.green(line));
+    } else if (line.startsWith("-")) {
+      console.log(chalk11.red(line));
+    } else {
+      console.log(chalk11.gray(line));
+    }
+  }
+  console.log("");
+}
+function countChanges(diff) {
+  const lines = diff.split("\n");
+  let added = 0;
+  let removed = 0;
+  for (const line of lines) {
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      added++;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      removed++;
+    }
+  }
+  return { added, removed };
+}
+async function handleFileEdit(filePath, llm) {
+  const env = getEnvironment();
+  if (!fileExists(filePath)) {
+    console.log(chalk11.red(`
+\u2717 File not found: ${filePath}
+`));
+    return { success: false, error: "File not found" };
+  }
+  const fileData = await readFileForEdit(filePath);
+  if (!fileData) {
+    console.log(chalk11.red(`
+\u2717 Could not read file: ${filePath}
+`));
+    return { success: false, error: "Could not read file" };
+  }
+  const previewLines = fileData.numbered.split("\n").slice(0, 20);
+  console.log(chalk11.cyan.bold(`
+\u{1F4C4} ${filePath}
+`));
+  console.log(chalk11.gray(previewLines.join("\n")));
+  if (fileData.content.split("\n").length > 20) {
+    console.log(chalk11.gray(`    ... (${fileData.content.split("\n").length - 20} more lines)`));
+  }
+  console.log("");
+  const instruction = await input4({
+    message: chalk11.yellow("Describe the edit:")
+  });
+  if (!instruction.trim()) {
+    console.log(chalk11.gray("\n(no instruction provided)\n"));
+    return { success: false, error: "No instruction" };
+  }
+  const spinner = ora3("Generating edit...").start();
+  try {
+    const prompt = `File: ${filePath}
+
+Content:
+\`\`\`
+${fileData.content}
+\`\`\`
+
+Edit instruction: ${instruction}
+
+Generate the unified diff to make this change.`;
+    const response = await llm.generate(prompt, EDIT_SYSTEM_PROMPT);
+    spinner.stop();
+    const diff = extractDiff(response.text);
+    if (!diff) {
+      console.log(chalk11.yellow("\n\u26A0\uFE0F  Could not generate a valid diff.\n"));
+      console.log(chalk11.gray("AI response:\n" + response.text.slice(0, 500)));
+      return { success: false, error: "Invalid diff generated" };
+    }
+    previewDiff(diff);
+    const changes = countChanges(diff);
+    console.log(chalk11.gray(`  ${chalk11.green(`+${changes.added}`)} additions, ${chalk11.red(`-${changes.removed}`)} deletions
+`));
+    const shouldApply = await confirm2({
+      message: "Apply these changes?",
+      default: true
+    });
+    if (!shouldApply) {
+      console.log(chalk11.gray("\n\u{1F44B} Edit cancelled.\n"));
+      return { success: false, error: "Cancelled by user" };
+    }
+    const applySpinner = ora3("Applying changes...").start();
+    const result = await applyPatchTool(filePath, diff);
+    applySpinner.stop();
+    if (result.success) {
+      console.log(chalk11.green(`
+\u2713 Successfully edited ${filePath}
+`));
+      logEvent({
+        eventType: "command_result",
+        command: `/edit ${filePath}`,
+        result: { exitCode: 0 },
+        metadata: {
+          instruction,
+          added: changes.added,
+          removed: changes.removed
+        }
+      });
+      return { success: true, linesChanged: changes.added + changes.removed };
+    } else {
+      console.log(chalk11.red(`
+\u2717 Failed to apply changes: ${result.error}
+`));
+      return { success: false, error: result.error };
+    }
+  } catch (error) {
+    spinner.stop();
+    const msg = error instanceof Error ? error.message : String(error);
+    console.log(chalk11.red(`
+\u2717 Error: ${msg}
+`));
+    return { success: false, error: msg };
+  }
+}
+
+// src/commands/agdi-dev.ts
+var BASE_CHAT_PROMPT = `You are Agdi dev, an elite AI coding assistant. You help developers write code, debug issues, and build applications.
 
 ## Your Capabilities
 - Write complete, production-ready code
 - Debug and fix code issues  
 - Explain code and architecture
 - Answer coding questions
+- Analyze git status and diffs
+- Generate meaningful commit messages
 
 ## Response Style
 - Be concise and direct
@@ -2753,6 +3828,17 @@ var CHAT_SYSTEM_PROMPT = `You are Agdi dev, an elite AI coding assistant. You he
 - Follow modern best practices
 - Include proper error handling
 - Write self-documenting code`;
+function buildContextAwarePrompt() {
+  const context = buildWorkspaceContext();
+  const gitStatus = getStatus();
+  context.gitStatus = formatStatusForPrompt(gitStatus);
+  const contextSection = formatContextForPrompt(context);
+  return `${BASE_CHAT_PROMPT}
+
+---
+
+${contextSection}`;
+}
 var BUILD_SYSTEM_PROMPT = `You are Agdi dev, an AI coding assistant that generates applications.
 
 ## CRITICAL: Output Format
@@ -2789,29 +3875,36 @@ Instead, output a single JSON object with this exact structure:
 async function startCodingMode() {
   const activeConfig = getActiveProvider();
   if (!activeConfig) {
-    console.log(chalk11.red("\u274C No API key configured. Run: agdi"));
+    console.log(chalk12.red("\u274C No API key configured. Run: agdi"));
     return;
   }
   const { provider, apiKey, model } = activeConfig;
   const config = loadConfig();
   const env = initSession();
   displaySessionHeader(env);
+  const isTrusted = await ensureTrusted(env.workspaceRoot);
+  if (!isTrusted) {
+    process.exit(0);
+  }
   logSessionStart(env.workspaceRoot, env.trustLevel);
-  console.log(chalk11.cyan.bold("\u26A1 Agdi dev\n"));
-  console.log(chalk11.gray(`Model: ${chalk11.cyan(model)}`));
-  console.log(chalk11.gray("Commands: /model, /chat, /build, /help, /exit\n"));
-  console.log(chalk11.gray("\u2500".repeat(50) + "\n"));
+  console.log(chalk12.cyan.bold("\u26A1 Agdi dev\n"));
+  console.log(chalk12.gray(`Model: ${chalk12.cyan(model)}`));
+  console.log(chalk12.gray(`Workspace: ${chalk12.cyan(env.workspaceRoot)}`));
+  console.log(chalk12.gray("Commands: /status, /diff, /commit, /build, /clear, /history, /model, /help, /exit\n"));
+  console.log(chalk12.gray("\u2500".repeat(50) + "\n"));
   const pm = new ProjectManager();
   let llm = createLLMProvider(provider, { apiKey, model });
+  const conversation = getConversation();
+  conversation.setSystemPrompt(buildContextAwarePrompt());
   while (true) {
     try {
-      const userInput = await input4({
-        message: chalk11.green("\u2192")
+      const userInput = await input5({
+        message: chalk12.green("\u2192")
       });
       const trimmed = userInput.trim().toLowerCase();
       if (trimmed === "/exit" || trimmed === "exit" || trimmed === "quit") {
         logSessionEnd();
-        console.log(chalk11.gray("\n\u{1F44B} Goodbye!\n"));
+        console.log(chalk12.gray("\n\u{1F44B} Goodbye!\n"));
         break;
       }
       if (trimmed === "/help") {
@@ -2826,22 +3919,66 @@ async function startCodingMode() {
             apiKey: newConfig.apiKey,
             model: newConfig.model
           });
-          console.log(chalk11.gray(`Now using: ${chalk11.cyan(newConfig.model)}
+          console.log(chalk12.gray(`Now using: ${chalk12.cyan(newConfig.model)}
 `));
         }
         continue;
       }
       if (trimmed === "/chat") {
-        console.log(chalk11.gray("\nSwitching to chat mode. Type /code to return.\n"));
+        console.log(chalk12.gray("\nSwitching to chat mode. Type /code to return.\n"));
         await chatMode(llm);
         continue;
       }
+      if (trimmed === "/clear") {
+        clearConversation();
+        conversation.setSystemPrompt(buildContextAwarePrompt());
+        console.log(chalk12.green("\n\u2713 Conversation cleared.\n"));
+        continue;
+      }
+      if (trimmed === "/history") {
+        const messages = conversation.getMessages();
+        if (messages.length === 0) {
+          console.log(chalk12.gray("\n(no conversation history)\n"));
+        } else {
+          console.log(chalk12.cyan.bold("\n\u{1F4DC} Conversation History\n"));
+          console.log(chalk12.gray(conversation.getSummary()));
+          console.log("");
+          for (const msg of messages.slice(-6)) {
+            const role = msg.role === "user" ? chalk12.green("You") : chalk12.cyan("AI");
+            const preview = msg.content.slice(0, 80) + (msg.content.length > 80 ? "..." : "");
+            console.log(`  ${role}: ${chalk12.gray(preview)}`);
+          }
+          console.log("");
+        }
+        continue;
+      }
+      if (trimmed === "/status") {
+        await handleGitStatus(llm);
+        continue;
+      }
+      if (trimmed === "/diff") {
+        await handleGitDiff(llm);
+        continue;
+      }
+      if (trimmed === "/commit") {
+        await handleGitCommit(llm);
+        continue;
+      }
+      if (trimmed.startsWith("/edit ")) {
+        const filePath = userInput.slice(6).trim();
+        if (filePath) {
+          await handleFileEdit(filePath, llm);
+        } else {
+          console.log(chalk12.yellow("\nUsage: /edit <file>\n"));
+        }
+        continue;
+      }
       if (trimmed.startsWith("/build ") || trimmed.startsWith("build ")) {
         const prompt = userInput.replace(/^\/?build\s+/i, "").trim();
         if (prompt) {
           await buildAppWithPlan(prompt, llm);
         } else {
-          console.log(chalk11.yellow("\nUsage: /build <description>\n"));
+          console.log(chalk12.yellow("\nUsage: /build <description>\n"));
         }
         continue;
       }
@@ -2853,9 +3990,17 @@ async function startCodingMode() {
         await buildAppWithPlan(userInput, llm);
         continue;
       }
-      const spinner = ora3("Thinking...").start();
+      const spinner = ora4("Thinking...").start();
       try {
-        const response = await llm.generate(userInput, CHAT_SYSTEM_PROMPT);
+        conversation.addUserMessage(userInput);
+        let response;
+        if (llm.chat) {
+          response = await llm.chat(conversation.getMessagesForAPI());
+        } else {
+          const contextPrompt = buildContextAwarePrompt();
+          response = await llm.generate(userInput, contextPrompt);
+        }
+        conversation.addAssistantMessage(response.text);
         spinner.stop();
         console.log("\n" + formatResponse(response.text) + "\n");
       } catch (error) {
@@ -2865,7 +4010,7 @@ async function startCodingMode() {
     } catch (error) {
       if (error.name === "ExitPromptError") {
         logSessionEnd();
-        console.log(chalk11.gray("\n\n\u{1F44B} Goodbye!\n"));
+        console.log(chalk12.gray("\n\n\u{1F44B} Goodbye!\n"));
         process.exit(0);
       }
       throw error;
@@ -2873,13 +4018,13 @@ async function startCodingMode() {
   }
 }
 async function buildAppWithPlan(prompt, llm) {
-  const spinner = ora3("Generating action plan...").start();
+  const spinner = ora4("Generating action plan...").start();
   try {
     const response = await llm.generate(prompt, BUILD_SYSTEM_PROMPT);
     spinner.stop();
     const result = await parseAndExecutePlan(response.text);
     if (!result) {
-      console.log(chalk11.yellow("\n\u26A0\uFE0F  Model did not return an action plan. Showing response:\n"));
+      console.log(chalk12.yellow("\n\u26A0\uFE0F  Model did not return an action plan. Showing response:\n"));
       console.log(formatResponse(response.text) + "\n");
     }
   } catch (error) {
@@ -2890,15 +4035,15 @@ async function buildAppWithPlan(prompt, llm) {
 async function chatMode(llm) {
   while (true) {
     try {
-      const userInput = await input4({
-        message: chalk11.blue("\u{1F4AC}")
+      const userInput = await input5({
+        message: chalk12.blue("\u{1F4AC}")
       });
       if (userInput.toLowerCase() === "/code" || userInput.toLowerCase() === "/exit") {
-        console.log(chalk11.gray("\nBack to Agdi dev mode.\n"));
+        console.log(chalk12.gray("\nBack to Agdi dev mode.\n"));
         return;
       }
       if (!userInput.trim()) continue;
-      const spinner = ora3("...").start();
+      const spinner = ora4("...").start();
       const response = await llm.generate(userInput, "You are a helpful assistant. Be friendly and concise.");
       spinner.stop();
       console.log("\n" + response.text + "\n");
@@ -2910,51 +4055,172 @@ async function chatMode(llm) {
     }
   }
 }
+async function handleGitStatus(llm) {
+  if (!isGitRepo()) {
+    console.log(chalk12.yellow("\n\u26A0\uFE0F  Not a git repository\n"));
+    return;
+  }
+  const spinner = ora4("Analyzing git status...").start();
+  try {
+    const status = getStatus();
+    const statusText = formatStatusForPrompt(status);
+    const prompt = `Analyze this git status and provide a brief summary of the current state of the repository. What's staged, unstaged, and what should be done next?
+
+${statusText}`;
+    const response = await llm.generate(prompt, BASE_CHAT_PROMPT);
+    spinner.stop();
+    console.log(chalk12.cyan.bold("\n\u{1F4CA} Git Status Analysis\n"));
+    console.log(chalk12.gray(statusText));
+    console.log(chalk12.cyan("\n\u2500\u2500\u2500 AI Analysis \u2500\u2500\u2500\n"));
+    console.log(formatResponse(response.text) + "\n");
+  } catch (error) {
+    spinner.fail("Error analyzing status");
+    handleError(error);
+  }
+}
+async function handleGitDiff(llm) {
+  if (!isGitRepo()) {
+    console.log(chalk12.yellow("\n\u26A0\uFE0F  Not a git repository\n"));
+    return;
+  }
+  const spinner = ora4("Analyzing changes...").start();
+  try {
+    const stagedDiff = getDiff(true);
+    const unstagedDiff = getDiff(false);
+    if (stagedDiff.files.length === 0 && unstagedDiff.files.length === 0) {
+      spinner.stop();
+      console.log(chalk12.gray("\n(no changes to analyze)\n"));
+      return;
+    }
+    let diffContext = "";
+    if (stagedDiff.files.length > 0) {
+      diffContext += "## Staged Changes\n" + formatDiffForPrompt(stagedDiff) + "\n\n";
+    }
+    if (unstagedDiff.files.length > 0) {
+      diffContext += "## Unstaged Changes\n" + formatDiffForPrompt(unstagedDiff);
+    }
+    const prompt = `Explain these code changes. What are the key modifications and their purpose?
+
+${diffContext}`;
+    const response = await llm.generate(prompt, BASE_CHAT_PROMPT);
+    spinner.stop();
+    console.log(chalk12.cyan.bold("\n\u{1F50D} Diff Analysis\n"));
+    console.log(formatResponse(response.text) + "\n");
+  } catch (error) {
+    spinner.fail("Error analyzing diff");
+    handleError(error);
+  }
+}
+async function handleGitCommit(llm) {
+  if (!isGitRepo()) {
+    console.log(chalk12.yellow("\n\u26A0\uFE0F  Not a git repository\n"));
+    return;
+  }
+  const status = getStatus();
+  if (status.staged.length === 0) {
+    console.log(chalk12.yellow("\n\u26A0\uFE0F  No staged changes. Stage some changes first with `git add`.\n"));
+    return;
+  }
+  const spinner = ora4("Generating commit message...").start();
+  try {
+    const stagedDiff = getDiff(true);
+    const diffText = formatDiffForPrompt(stagedDiff);
+    const prompt = `Generate a concise, conventional commit message for these staged changes. Use the format: type(scope): description
+
+Types: feat, fix, docs, style, refactor, test, chore
+Keep the message under 72 characters.
+Return ONLY the commit message, nothing else.
+
+Changes:
+${diffText}`;
+    const response = await llm.generate(prompt, "You are a git commit message generator. Output ONLY the commit message, no explanation.");
+    spinner.stop();
+    const commitMessage = response.text.trim().split("\n")[0];
+    console.log(chalk12.cyan.bold("\n\u{1F4AC} Generated Commit Message\n"));
+    console.log(chalk12.white(`  ${commitMessage}
+`));
+    const shouldCommit = await confirm3({
+      message: "Commit with this message?",
+      default: true
+    });
+    if (shouldCommit) {
+      const { execSync: execSync2 } = await import("child_process");
+      const env = getEnvironment();
+      try {
+        execSync2(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, {
+          cwd: env.workspaceRoot,
+          stdio: "inherit"
+        });
+        console.log(chalk12.green("\n\u2713 Committed successfully!\n"));
+      } catch (gitError) {
+        console.log(chalk12.red("\n\u2717 Commit failed. Check git output above.\n"));
+      }
+    } else {
+      console.log(chalk12.gray("\n\u{1F44B} Commit cancelled.\n"));
+    }
+  } catch (error) {
+    spinner.fail("Error generating commit");
+    handleError(error);
+  }
+}
 function formatResponse(text) {
   return text.replace(/```(\w+)?\n([\s\S]*?)```/g, (_, lang, code) => {
-    const header = lang ? chalk11.gray(`\u2500\u2500 ${lang} \u2500\u2500`) : chalk11.gray("\u2500\u2500 code \u2500\u2500");
+    const header = lang ? chalk12.gray(`\u2500\u2500 ${lang} \u2500\u2500`) : chalk12.gray("\u2500\u2500 code \u2500\u2500");
     return `
 ${header}
-${chalk11.white(code.trim())}
-${chalk11.gray("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}
+${chalk12.white(code.trim())}
+${chalk12.gray("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}
 `;
   });
 }
 function showHelp() {
-  console.log(chalk11.cyan.bold("\n\u{1F4D6} Commands\n"));
-  console.log(chalk11.gray("  /build     ") + "Generate and execute an application");
-  console.log(chalk11.gray("  /model     ") + "Change AI model");
-  console.log(chalk11.gray("  /chat      ") + "Switch to chat mode");
-  console.log(chalk11.gray("  /help      ") + "Show this help");
-  console.log(chalk11.gray("  /exit      ") + "Exit Agdi");
-  console.log(chalk11.gray("\n  Or just type your coding question!\n"));
-  console.log(chalk11.gray('Tip: "Create a todo app" will generate & write files.\n'));
+  console.log(chalk12.cyan.bold("\n\u{1F4D6} Commands\n"));
+  console.log(chalk12.cyan("  Git Commands:"));
+  console.log(chalk12.gray("  /status    ") + "AI analysis of git status");
+  console.log(chalk12.gray("  /diff      ") + "AI explanation of current changes");
+  console.log(chalk12.gray("  /commit    ") + "Generate and run git commit");
+  console.log("");
+  console.log(chalk12.cyan("  Build Commands:"));
+  console.log(chalk12.gray("  /build     ") + "Generate and execute an application");
+  console.log(chalk12.gray("  /edit      ") + "AI-powered surgical file editing");
+  console.log("");
+  console.log(chalk12.cyan("  Conversation:"));
+  console.log(chalk12.gray("  /clear     ") + "Clear conversation history");
+  console.log(chalk12.gray("  /history   ") + "Show recent conversation");
+  console.log("");
+  console.log(chalk12.cyan("  General:"));
+  console.log(chalk12.gray("  /model     ") + "Change AI model");
+  console.log(chalk12.gray("  /chat      ") + "Switch to chat mode");
+  console.log(chalk12.gray("  /help      ") + "Show this help");
+  console.log(chalk12.gray("  /exit      ") + "Exit Agdi");
+  console.log(chalk12.gray("\n  Or just type your coding question!\n"));
+  console.log(chalk12.gray('Tip: "Create a todo app" will generate & write files.\n'));
 }
 function handleError(error) {
   const msg = error instanceof Error ? error.message : String(error);
   if (msg.includes("429") || msg.includes("quota")) {
-    console.log(chalk11.yellow("\n\u26A0\uFE0F  Quota exceeded. Run /model to switch.\n"));
+    console.log(chalk12.yellow("\n\u26A0\uFE0F  Quota exceeded. Run /model to switch.\n"));
   } else if (msg.includes("401") || msg.includes("403")) {
-    console.log(chalk11.red("\n\u{1F511} Invalid API key. Run: agdi auth\n"));
+    console.log(chalk12.red("\n\u{1F511} Invalid API key. Run: agdi auth\n"));
   } else {
-    console.log(chalk11.red("\n" + msg + "\n"));
+    console.log(chalk12.red("\n" + msg + "\n"));
   }
 }
 
 // src/index.ts
 var BANNER = `
-${chalk12.cyan(`    ___              __ _  `)}
-${chalk12.cyan(`   /   |  ____ _____/ /(_) `)}
-${chalk12.cyan(`  / /| | / __ \`/ __  // /  `)}
-${chalk12.cyan(` / ___ |/ /_/ / /_/ // /   `)}
-${chalk12.cyan(`/_/  |_|\\_, /\\__,_//_/    `)}
-${chalk12.cyan(`       /____/              `)}
+${chalk13.cyan(`    ___              __ _  `)}
+${chalk13.cyan(`   /   |  ____ _____/ /(_) `)}
+${chalk13.cyan(`  / /| | / __ \`/ __  // /  `)}
+${chalk13.cyan(` / ___ |/ /_/ / /_/ // /   `)}
+${chalk13.cyan(`/_/  |_|\\_, /\\__,_//_/    `)}
+${chalk13.cyan(`       /____/              `)}
 `;
 var program = new Command();
-program.name("agdi").description(chalk12.cyan("\u{1F680} AI-powered coding assistant")).version("2.2.2").configureHelp({
+program.name("agdi").description(chalk13.cyan("\u{1F680} AI-powered coding assistant")).version("2.2.2").configureHelp({
   // Show banner only when help is requested
   formatHelp: (cmd, helper) => {
-    return BANNER + "\n" + chalk12.gray("  The Open Source AI Architect") + "\n" + chalk12.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n") + "\n" + helper.formatHelp(cmd, helper);
+    return BANNER + "\n" + chalk13.gray("  The Open Source AI Architect") + "\n" + chalk13.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n") + "\n" + helper.formatHelp(cmd, helper);
   }
 });
 program.action(async () => {
@@ -2965,7 +4231,7 @@ program.action(async () => {
     await startCodingMode();
   } catch (error) {
     if (error.name === "ExitPromptError") {
-      console.log(chalk12.gray("\n\n\u{1F44B} Goodbye!\n"));
+      console.log(chalk13.gray("\n\n\u{1F44B} Goodbye!\n"));
       process.exit(0);
     }
     throw error;
@@ -2980,7 +4246,7 @@ program.command("auth").description("Configure API keys").option("--status", "Sh
     }
   } catch (error) {
     if (error.name === "ExitPromptError") {
-      console.log(chalk12.gray("\n\n\u{1F44B} Cancelled.\n"));
+      console.log(chalk13.gray("\n\n\u{1F44B} Cancelled.\n"));
       process.exit(0);
     }
     throw error;
@@ -2991,7 +4257,7 @@ program.command("model").alias("models").description("Change AI model").action(a
     await selectModel();
   } catch (error) {
     if (error.name === "ExitPromptError") {
-      console.log(chalk12.gray("\n\n\u{1F44B} Cancelled.\n"));
+      console.log(chalk13.gray("\n\n\u{1F44B} Cancelled.\n"));
       process.exit(0);
     }
     throw error;
@@ -3005,7 +4271,7 @@ program.command("chat").description("Start a chat session").action(async () => {
     await startChat();
   } catch (error) {
     if (error.name === "ExitPromptError") {
-      console.log(chalk12.gray("\n\n\u{1F44B} Goodbye!\n"));
+      console.log(chalk13.gray("\n\n\u{1F44B} Goodbye!\n"));
       process.exit(0);
     }
     throw error;
@@ -3016,7 +4282,7 @@ program.command("run [directory]").description("Run a generated project").action
     await runProject(directory);
   } catch (error) {
     if (error.name === "ExitPromptError") {
-      console.log(chalk12.gray("\n\n\u{1F44B} Cancelled.\n"));
+      console.log(chalk13.gray("\n\n\u{1F44B} Cancelled.\n"));
       process.exit(0);
     }
     throw error;
@@ -3029,10 +4295,10 @@ program.command("build <prompt>").alias("b").description("Generate an app from a
     }
     const activeConfig = getActiveProvider();
     if (!activeConfig) {
-      console.log(chalk12.red("\u274C No API key configured. Run: agdi auth"));
+      console.log(chalk13.red("\u274C No API key configured. Run: agdi auth"));
       return;
     }
-    const spinner = ora4("Generating application...").start();
+    const spinner = ora5("Generating application...").start();
     try {
       const llm = createLLMProvider(activeConfig.provider, {
         apiKey: activeConfig.apiKey,
@@ -3041,30 +4307,30 @@ program.command("build <prompt>").alias("b").description("Generate an app from a
       const pm = new ProjectManager();
       pm.create(options.output.replace("./", ""), prompt);
       const { plan, files } = await generateApp(prompt, llm, (step, file) => {
-        spinner.text = file ? `${step} ${chalk12.gray(file)}` : step;
+        spinner.text = file ? `${step} ${chalk13.gray(file)}` : step;
       });
       pm.updateFiles(files);
       pm.updateDependencies(plan.dependencies);
       await writeProject(pm.get(), options.output);
-      spinner.succeed(chalk12.green("App generated!"));
-      console.log(chalk12.gray(`
-\u{1F4C1} Created ${files.length} files in ${chalk12.cyan(options.output)}`));
-      console.log(chalk12.gray("\nNext: cd " + options.output + " && npm install && npm run dev\n"));
+      spinner.succeed(chalk13.green("App generated!"));
+      console.log(chalk13.gray(`
+\u{1F4C1} Created ${files.length} files in ${chalk13.cyan(options.output)}`));
+      console.log(chalk13.gray("\nNext: cd " + options.output + " && npm install && npm run dev\n"));
     } catch (error) {
       spinner.fail("Generation failed");
       const msg = error instanceof Error ? error.message : String(error);
       if (msg.includes("429") || msg.includes("quota")) {
-        console.log(chalk12.yellow("\n\u26A0\uFE0F  Quota exceeded. Run: agdi model\n"));
+        console.log(chalk13.yellow("\n\u26A0\uFE0F  Quota exceeded. Run: agdi model\n"));
       } else if (msg.includes("401") || msg.includes("403")) {
-        console.log(chalk12.red("\n\u{1F511} Invalid API key. Run: agdi auth\n"));
+        console.log(chalk13.red("\n\u{1F511} Invalid API key. Run: agdi auth\n"));
       } else {
-        console.error(chalk12.red("\n" + msg + "\n"));
+        console.error(chalk13.red("\n" + msg + "\n"));
       }
       process.exit(1);
     }
   } catch (error) {
     if (error.name === "ExitPromptError") {
-      console.log(chalk12.gray("\n\n\u{1F44B} Cancelled.\n"));
+      console.log(chalk13.gray("\n\n\u{1F44B} Cancelled.\n"));
       process.exit(0);
     }
     throw error;
@@ -3073,11 +4339,11 @@ program.command("build <prompt>").alias("b").description("Generate an app from a
 program.command("config").description("Show configuration").action(async () => {
   const config = loadConfig();
   const active = getActiveProvider();
-  console.log(chalk12.cyan.bold("\n\u2699\uFE0F  Configuration\n"));
-  console.log(chalk12.gray("  Provider: ") + chalk12.cyan(config.defaultProvider || "not set"));
-  console.log(chalk12.gray("  Model:    ") + chalk12.cyan(config.defaultModel || "not set"));
-  console.log(chalk12.gray("  Config:   ") + chalk12.gray("~/.agdi/config.json"));
-  console.log(chalk12.cyan.bold("\n\u{1F510} API Keys\n"));
+  console.log(chalk13.cyan.bold("\n\u2699\uFE0F  Configuration\n"));
+  console.log(chalk13.gray("  Provider: ") + chalk13.cyan(config.defaultProvider || "not set"));
+  console.log(chalk13.gray("  Model:    ") + chalk13.cyan(config.defaultModel || "not set"));
+  console.log(chalk13.gray("  Config:   ") + chalk13.gray("~/.agdi/config.json"));
+  console.log(chalk13.cyan.bold("\n\u{1F510} API Keys\n"));
   const keys = [
     ["Gemini", config.geminiApiKey],
     ["OpenRouter", config.openrouterApiKey],
@@ -3086,7 +4352,7 @@ program.command("config").description("Show configuration").action(async () => {
     ["DeepSeek", config.deepseekApiKey]
   ];
   for (const [name, key] of keys) {
-    const status = key ? chalk12.green("\u2713") : chalk12.gray("\u2717");
+    const status = key ? chalk13.green("\u2713") : chalk13.gray("\u2717");
     console.log(`  ${status} ${name}`);
   }
   console.log("");