agdi 2.2.3 → 2.4.0

package/dist/index.js

@@ -1,4 +1,10 @@
 #!/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";
@@ -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,
@@ -1270,8 +1369,8 @@ async function selectModel() {
 `));
 }
 
-// src/commands/codex.ts
-import { input as input4 } from "@inquirer/prompts";
+// src/commands/agdi-dev.ts
+import { input as input4, confirm as confirm2 } from "@inquirer/prompts";
 import chalk11 from "chalk";
 import ora3 from "ora";
 
@@ -2455,6 +2554,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 +2572,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 +2894,577 @@ 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/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 +3477,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
@@ -2796,13 +3531,20 @@ async function startCodingMode() {
   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(`Workspace: ${chalk11.cyan(env.workspaceRoot)}`));
+  console.log(chalk11.gray("Commands: /status, /diff, /commit, /build, /clear, /history, /model, /help, /exit\n"));
   console.log(chalk11.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({
@@ -2836,6 +3578,41 @@ async function startCodingMode() {
         await chatMode(llm);
         continue;
       }
+      if (trimmed === "/clear") {
+        clearConversation();
+        conversation.setSystemPrompt(buildContextAwarePrompt());
+        console.log(chalk11.green("\n\u2713 Conversation cleared.\n"));
+        continue;
+      }
+      if (trimmed === "/history") {
+        const messages = conversation.getMessages();
+        if (messages.length === 0) {
+          console.log(chalk11.gray("\n(no conversation history)\n"));
+        } else {
+          console.log(chalk11.cyan.bold("\n\u{1F4DC} Conversation History\n"));
+          console.log(chalk11.gray(conversation.getSummary()));
+          console.log("");
+          for (const msg of messages.slice(-6)) {
+            const role = msg.role === "user" ? chalk11.green("You") : chalk11.cyan("AI");
+            const preview = msg.content.slice(0, 80) + (msg.content.length > 80 ? "..." : "");
+            console.log(`  ${role}: ${chalk11.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("/build ") || trimmed.startsWith("build ")) {
         const prompt = userInput.replace(/^\/?build\s+/i, "").trim();
         if (prompt) {
@@ -2855,7 +3632,15 @@ async function startCodingMode() {
       }
       const spinner = ora3("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) {
@@ -2910,6 +3695,114 @@ async function chatMode(llm) {
     }
   }
 }
+async function handleGitStatus(llm) {
+  if (!isGitRepo()) {
+    console.log(chalk11.yellow("\n\u26A0\uFE0F  Not a git repository\n"));
+    return;
+  }
+  const spinner = ora3("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(chalk11.cyan.bold("\n\u{1F4CA} Git Status Analysis\n"));
+    console.log(chalk11.gray(statusText));
+    console.log(chalk11.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(chalk11.yellow("\n\u26A0\uFE0F  Not a git repository\n"));
+    return;
+  }
+  const spinner = ora3("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(chalk11.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(chalk11.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(chalk11.yellow("\n\u26A0\uFE0F  Not a git repository\n"));
+    return;
+  }
+  const status = getStatus();
+  if (status.staged.length === 0) {
+    console.log(chalk11.yellow("\n\u26A0\uFE0F  No staged changes. Stage some changes first with `git add`.\n"));
+    return;
+  }
+  const spinner = ora3("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(chalk11.cyan.bold("\n\u{1F4AC} Generated Commit Message\n"));
+    console.log(chalk11.white(`  ${commitMessage}
+`));
+    const shouldCommit = await confirm2({
+      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(chalk11.green("\n\u2713 Committed successfully!\n"));
+      } catch (gitError) {
+        console.log(chalk11.red("\n\u2717 Commit failed. Check git output above.\n"));
+      }
+    } else {
+      console.log(chalk11.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");
@@ -2922,7 +3815,19 @@ ${chalk11.gray("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}
 }
 function showHelp() {
   console.log(chalk11.cyan.bold("\n\u{1F4D6} Commands\n"));
+  console.log(chalk11.cyan("  Git Commands:"));
+  console.log(chalk11.gray("  /status    ") + "AI analysis of git status");
+  console.log(chalk11.gray("  /diff      ") + "AI explanation of current changes");
+  console.log(chalk11.gray("  /commit    ") + "Generate and run git commit");
+  console.log("");
+  console.log(chalk11.cyan("  Build Commands:"));
   console.log(chalk11.gray("  /build     ") + "Generate and execute an application");
+  console.log("");
+  console.log(chalk11.cyan("  Conversation:"));
+  console.log(chalk11.gray("  /clear     ") + "Clear conversation history");
+  console.log(chalk11.gray("  /history   ") + "Show recent conversation");
+  console.log("");
+  console.log(chalk11.cyan("  General:"));
   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");

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "agdi",
-    "version": "2.2.3",
+    "version": "2.4.0",
     "description": "AI-powered app generator - build full-stack apps from natural language in your terminal",
     "type": "module",
     "bin": {
@@ -62,4 +62,4 @@
         "jszip": "^3.10.0",
         "ora": "^8.0.0"
     }
-}
+}