agdi 2.5.0 → 2.6.0

package/README.md

@@ -19,7 +19,7 @@
 [![Node.js](https://img.shields.io/badge/Node.js-18+-339933?style=for-the-badge&logo=node.js&logoColor=white)](https://nodejs.org/)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.4-3178C6?style=for-the-badge&logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
 
-**Build full-stack apps from natural language • AI-powered Git workflow • Enterprise-grade security**
+**Build full-stack apps from natural language • Multi-Agent AI • Codebase RAG • Enterprise Security**
 
 [Website](https://agdi-dev.vercel.app) · [npm](https://www.npmjs.com/package/agdi) · [GitHub](https://github.com/anassagd432/Agdi-dev)
 
@@ -27,6 +27,71 @@
 
 ---
 
+## 🚀 What's New in v2.6
+
+<table>
+<tr>
+<td width="50%">
+
+### 🤖 Multi-Agent System
+Planner → Coder → Reviewer pipeline. Your code is reviewed by AI before delivery.
+
+```bash
+→ /agent
+🤖 Multi-agent mode: ON
+  Planner → Coder → Reviewer pipeline enabled
+```
+
+</td>
+<td width="50%">
+
+### 🔍 Codebase RAG
+Index and search your entire project semantically. The AI understands your code.
+
+```bash
+→ /index
+✓ Indexed 47 files, 312 chunks
+
+→ /search authentication
+🔍 src/auth/login.ts:15 (0.87)
+```
+
+</td>
+</tr>
+<tr>
+<td width="50%">
+
+### 🔧 MCP Tool Integration
+Model Context Protocol for standardized AI tool calls.
+
+```bash
+→ /tools
+🔧 Available Tools
+  read_file [filesystem]
+  list_dir [filesystem]
+  search_code [code]
+```
+
+</td>
+<td width="50%">
+
+### 🧠 Persistent Memory
+AI remembers your preferences and project context across sessions.
+
+```bash
+→ /memory
+🧠 Memory Stats
+  Total entries: 12
+  Projects: 3
+  Preferences: 5
+```
+
+</td>
+</tr>
+</table>
+
+---
+
 ## ⚡ Quick Start
 
 ```bash
@@ -50,13 +115,25 @@ $ agdi
 
 Model: gemini-2.5-flash
 Workspace: ~/projects/my-app
-Commands: /status, /diff, /commit, /build, /clear, /history, /model, /help, /exit
+Commands: /status, /diff, /commit, /build, /index, /search, /agent, /help, /exit
 
 ──────────────────────────────────────────────────
 
+→ /agent
+🤖 Multi-agent mode: ON
+
 → create a todo app with dark mode and local storage
 
-Generating action plan...
+📋 Phase 1: Planning...
+  ✓ Plan created
+
+💻 Phase 2: Coding...
+  ✓ Code generated
+
+🔍 Phase 3: Review (iteration 1)...
+  ✓ Code approved!
+
+✅ Multi-Agent Pipeline Complete
 
 📋 Action Plan - todo-app
    ─────────────────────────
@@ -80,7 +157,8 @@ Generating action plan...
 ### 🤖 AI-Powered Development
 - **Natural language to code** — Describe what you want, get production-ready apps
 - **Conversation memory** — AI remembers context across messages
-- **Multi-turn chat** — Iterative development with full context
+- **Multi-agent mode** — Planner, Coder, Reviewer pipeline
+- **Codebase RAG** — AI understands your entire project
 
 </td>
 <td width="50%">
@@ -107,9 +185,10 @@ Generating action plan...
 ### 🌐 Multi-Provider AI
 - **Gemini** — Free tier, fast responses
 - **OpenRouter** — 400+ models, one API
-- **OpenAI** — GPT-4o, o1 reasoning
-- **Anthropic** — Claude 3.5 Sonnet
+- **OpenAI** — GPT-4o, o3 reasoning
+- **Anthropic** — Claude 4.5 Sonnet
 - **DeepSeek** — R1, V3 models
+- **Puter** — 100% free, no key needed
 
 </td>
 </tr>
@@ -131,6 +210,11 @@ Inside the session:
 |---------|-------------|
 | `/build <prompt>` | Generate & execute an app from description |
 | `/edit <file>` | AI-powered surgical file editing |
+| `/index` | 🆕 Index current project for RAG search |
+| `/search <query>` | 🆕 Semantic code search |
+| `/tools` | 🆕 List available MCP tools |
+| `/agent` | 🆕 Toggle multi-agent mode |
+| `/memory` | 🆕 View persistent memory stats |
 | `/status` | AI analysis of git status |
 | `/diff` | AI explanation of current changes |
 | `/commit` | Auto-generate & run git commit |
@@ -153,6 +237,70 @@ agdi run [dir]            # Run a generated project
 
 ---
 
+## 🤖 Multi-Agent Architecture (v2.6)
+
+Enable with `/agent` for higher quality code:
+
+```
+┌──────────────────────────────────────────────────────────┐
+│  User Request                                            │
+└─────────────────────────┬────────────────────────────────┘
+                          ▼
+┌──────────────────────────────────────────────────────────┐
+│  📋 PLANNER AGENT                                        │
+│  Analyzes request, creates step-by-step implementation   │
+│  plan, identifies files to create/modify                 │
+└─────────────────────────┬────────────────────────────────┘
+                          ▼
+┌──────────────────────────────────────────────────────────┐
+│  💻 CODER AGENT                                          │
+│  Writes production-ready TypeScript/React code           │
+│  following the plan                                      │
+└─────────────────────────┬────────────────────────────────┘
+                          ▼
+┌──────────────────────────────────────────────────────────┐
+│  🔍 REVIEWER AGENT                                       │
+│  Reviews for:                                            │
+│  • Correctness • Security • Performance • Completeness  │
+│                                                          │
+│  → APPROVED: Code delivered to user                      │
+│  → NEEDS_CHANGES: Sent back to CODER (max 3 loops)       │
+└─────────────────────────┬────────────────────────────────┘
+                          ▼
+┌──────────────────────────────────────────────────────────┐
+│  ✅ High-Quality, Reviewed Code                          │
+└──────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🔍 Codebase RAG (v2.6)
+
+Index your project so AI can understand all your code:
+
+```bash
+# Index your project (creates searchable chunks)
+→ /index
+✓ Indexed 47 files, 312 chunks
+
+# Semantic search
+→ /search user authentication
+🔍 Search Results
+  src/auth/login.ts:15 (0.87)
+    export async function authenticateUser...
+  src/middleware/auth.ts:1 (0.65)
+    import { verifyToken } from...
+  src/hooks/useAuth.ts:5 (0.52)
+    const AuthContext = createContext...
+```
+
+**How it works:**
+1. **Indexer** walks your project, chunks code by functions/classes
+2. **Retriever** uses TF-IDF semantic search (no external vector DB)
+3. **Context** is automatically injected into AI prompts
+
+---
+
 ## 🛡️ Security Architecture
 
 Agdi includes **zero-trust security** designed for safe AI-assisted development:
@@ -195,7 +343,7 @@ Real-time scanning detects:
 - **22+ secret patterns** — AWS, GitHub, OpenAI, Anthropic, Stripe, etc.
 - **Shell injection** — Dangerous command patterns
 - **Prompt injection** — LLM manipulation attempts
-- **Supply chain risks** — Suspicious package references
+- **Network exfiltration** — Suspicious external requests
 
 ### 📊 Audit Logging
 
@@ -220,7 +368,6 @@ All decisions logged to `~/.agdi/audit.jsonl`:
 | Kimi K2 | `moonshotai/kimi-k2:free` | General purpose |
 | Gemma 3N E2B | `google/gemma-3n-e2b-it:free` | Lightweight |
 | LFM Thinking | `liquid/lfm-2.5-1.2b-thinking:free` | Agentic tasks |
-| Devstral ⚠️ | `mistralai/devstral-2512:free` | Ends Jan 27 |
 
 ### Image Generation
 
@@ -243,9 +390,9 @@ All decisions logged to `~/.agdi/audit.jsonl`:
 <td>
 
 **OpenRouter** 🌐
-- Claude 3.5 Sonnet
-- GPT-4o / 4o Mini
-- Llama 3.3 70B
+- Claude 4.5 Sonnet
+- GPT-5 / GPT-4o
+- Llama 4 Maverick
 - DeepSeek R1
 - 400+ more
 
@@ -253,10 +400,10 @@ All decisions logged to `~/.agdi/audit.jsonl`:
 <td>
 
 **OpenAI** 🧠
+- GPT-5
 - GPT-4o
-- GPT-4o Mini
+- o3
 - o1
-- o1-mini
 
 </td>
 </tr>
@@ -264,15 +411,15 @@ All decisions logged to `~/.agdi/audit.jsonl`:
 <td>
 
 **Anthropic** 💜
+- Claude 4.5 Sonnet
+- Claude 4.5 Opus
 - Claude 3.5 Sonnet
-- Claude 3.5 Haiku
-- Claude 3 Opus
 
 </td>
 <td>
 
 **DeepSeek** 🌊
-- DeepSeek V3
+- DeepSeek V3.2
 - DeepSeek R1 (Reasoning)
 
 </td>
@@ -300,6 +447,9 @@ Config stored in `~/.agdi/`:
 ├── config.json              # API keys & settings
 ├── rules.json               # Permission rules
 ├── trusted-workspaces.json  # Trusted directories
+├── memory/                  # 🆕 Persistent memory
+│   └── store.json
+├── indexes/                 # 🆕 RAG indexes
 └── audit.jsonl              # Audit log
 ```
 
@@ -325,10 +475,14 @@ agdi auth --status
 <p>TypeScript Errors</p>
 </td>
 <td align="center">
-<h3>100</h3>
+<h3>60</h3>
 <p>Tests Passing</p>
 </td>
 <td align="center">
+<h3>148 KB</h3>
+<p>Build Size</p>
+</td>
+<td align="center">
 <h3>22+</h3>
 <p>Security Patterns</p>
 </td>
@@ -344,14 +498,20 @@ agdi auth --status
 ## 🚀 Examples
 
 ```bash
-# Create a full-stack app
-agdi build "Create a blog with authentication and markdown support"
+# Create a full-stack app (multi-agent recommended)
+agdi
+→ /agent
+→ Create a blog with authentication and markdown support
 
-# Create a dashboard
-agdi build "Build an analytics dashboard with charts using Recharts"
+# Semantic search your codebase
+agdi
+→ /index
+→ /search payment processing
 
-# Create an API
-agdi build "Create a REST API with Express, Prisma, and PostgreSQL"
+# AI-powered file editing
+agdi
+→ /edit src/components/Header.tsx
+"Add a dark mode toggle button"
 
 # Interactive development
 agdi
@@ -371,6 +531,7 @@ agdi
 - **Styling**: Chalk, Ora
 - **Build**: tsup
 - **Testing**: Vitest
+- **AI**: Multi-agent, RAG, Token Optimization
 
 ---
 

package/dist/chunk-NVMD3WL3.js

@@ -0,0 +1,349 @@
+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/core/rag/indexer.ts
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, mkdirSync } from "fs";
+import { join, extname, relative } from "path";
+import { homedir } from "os";
+import { createHash } from "crypto";
+var INDEX_DIR = join(homedir(), ".agdi", "indexes");
+var CHUNK_SIZE = 50;
+var OVERLAP = 10;
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".rb",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".cs",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".md",
+  ".txt",
+  ".css",
+  ".scss",
+  ".html"
+]);
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "target",
+  ".idea",
+  ".vscode",
+  "coverage",
+  ".nyc_output"
+]);
+var IGNORE_FILES = /* @__PURE__ */ new Set([
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  ".DS_Store",
+  "Thumbs.db"
+]);
+function getLanguage(ext) {
+  const langMap = {
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".mjs": "javascript",
+    ".py": "python",
+    ".rb": "ruby",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".c": "c",
+    ".cpp": "cpp",
+    ".cs": "csharp",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".md": "markdown",
+    ".css": "css",
+    ".html": "html"
+  };
+  return langMap[ext] || "text";
+}
+function generateId(filePath, startLine) {
+  const hash = createHash("md5").update(`${filePath}:${startLine}`).digest("hex").slice(0, 8);
+  return `chunk_${hash}`;
+}
+function hashContent(content) {
+  return createHash("md5").update(content).digest("hex").slice(0, 12);
+}
+function detectChunkType(content, language) {
+  const firstLine = content.split("\n")[0].trim();
+  if (language === "typescript" || language === "javascript") {
+    if (/^(export\s+)?(async\s+)?function\s/.test(firstLine)) return "function";
+    if (/^(export\s+)?(abstract\s+)?class\s/.test(firstLine)) return "class";
+    if (/^(import|from)\s/.test(firstLine)) return "import";
+    if (/^export\s/.test(firstLine)) return "export";
+  }
+  if (language === "python") {
+    if (/^(async\s+)?def\s/.test(firstLine)) return "function";
+    if (/^class\s/.test(firstLine)) return "class";
+    if (/^(from|import)\s/.test(firstLine)) return "import";
+  }
+  if (/^(\/\/|\/\*|#|""")/.test(firstLine)) return "comment";
+  return "other";
+}
+function* walkDirectory(dir, basePath) {
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (!IGNORE_DIRS.has(entry.name)) {
+        yield* walkDirectory(fullPath, basePath);
+      }
+    } else if (entry.isFile()) {
+      if (!IGNORE_FILES.has(entry.name)) {
+        const ext = extname(entry.name).toLowerCase();
+        if (SUPPORTED_EXTENSIONS.has(ext)) {
+          yield fullPath;
+        }
+      }
+    }
+  }
+}
+function chunkFile(filePath, basePath) {
+  const content = readFileSync(filePath, "utf-8");
+  const lines = content.split("\n");
+  const ext = extname(filePath).toLowerCase();
+  const language = getLanguage(ext);
+  const relativePath = relative(basePath, filePath);
+  const chunks = [];
+  for (let i = 0; i < lines.length; i += CHUNK_SIZE - OVERLAP) {
+    const chunkLines = lines.slice(i, i + CHUNK_SIZE);
+    const chunkContent = chunkLines.join("\n");
+    if (chunkContent.trim().length === 0) continue;
+    chunks.push({
+      id: generateId(filePath, i),
+      filePath,
+      relativePath,
+      content: chunkContent,
+      startLine: i + 1,
+      endLine: Math.min(i + CHUNK_SIZE, lines.length),
+      type: detectChunkType(chunkContent, language),
+      language,
+      hash: hashContent(chunkContent)
+    });
+  }
+  return chunks;
+}
+function indexProject(projectPath) {
+  const startTime = Date.now();
+  const allChunks = [];
+  let fileCount = 0;
+  for (const filePath of walkDirectory(projectPath, projectPath)) {
+    try {
+      const stat = statSync(filePath);
+      if (stat.size > 1024 * 1024) continue;
+      const chunks = chunkFile(filePath, projectPath);
+      allChunks.push(...chunks);
+      fileCount++;
+    } catch {
+    }
+  }
+  const index = {
+    version: 1,
+    projectPath,
+    indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    fileCount,
+    chunkCount: allChunks.length,
+    chunks: allChunks
+  };
+  saveIndex(projectPath, index);
+  console.log(`Indexed ${fileCount} files, ${allChunks.length} chunks in ${Date.now() - startTime}ms`);
+  return index;
+}
+function getIndexPath(projectPath) {
+  const hash = createHash("md5").update(projectPath).digest("hex").slice(0, 12);
+  return join(INDEX_DIR, `${hash}.json`);
+}
+function saveIndex(projectPath, index) {
+  if (!existsSync(INDEX_DIR)) {
+    mkdirSync(INDEX_DIR, { recursive: true });
+  }
+  writeFileSync(getIndexPath(projectPath), JSON.stringify(index));
+}
+function loadIndex(projectPath) {
+  const indexPath = getIndexPath(projectPath);
+  if (!existsSync(indexPath)) return null;
+  try {
+    const data = readFileSync(indexPath, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function isIndexStale(index) {
+  const indexedAt = new Date(index.indexedAt).getTime();
+  const hourAgo = Date.now() - 60 * 60 * 1e3;
+  return indexedAt < hourAgo;
+}
+
+// src/core/rag/retriever.ts
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9_]/g, " ").split(/\s+/).filter((t) => t.length > 2);
+}
+function calculateTF(tokens) {
+  const tf = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    tf.set(token, (tf.get(token) || 0) + 1);
+  }
+  const max = Math.max(...tf.values());
+  for (const [token, count] of tf) {
+    tf.set(token, count / max);
+  }
+  return tf;
+}
+function scoreChunk(chunk, queryTokens, queryTF) {
+  const chunkTokens = tokenize(chunk.content);
+  const chunkTF = calculateTF(chunkTokens);
+  let score = 0;
+  const matchedTokens = /* @__PURE__ */ new Set();
+  for (const queryToken of queryTokens) {
+    if (chunkTF.has(queryToken)) {
+      score += chunkTF.get(queryToken) * (queryTF.get(queryToken) || 1);
+      matchedTokens.add(queryToken);
+    }
+    for (const chunkToken of chunkTokens) {
+      if (chunkToken.startsWith(queryToken) || queryToken.startsWith(chunkToken)) {
+        if (!matchedTokens.has(queryToken)) {
+          score += 0.5 * (queryTF.get(queryToken) || 1);
+          matchedTokens.add(queryToken);
+        }
+      }
+    }
+  }
+  const pathTokens = tokenize(chunk.relativePath);
+  for (const queryToken of queryTokens) {
+    if (pathTokens.includes(queryToken)) {
+      score += 0.5;
+    }
+  }
+  if (chunk.type === "function" || chunk.type === "class") {
+    score *= 1.2;
+  }
+  score = score / Math.sqrt(queryTokens.length);
+  return score;
+}
+function extractHighlights(chunk, queryTokens) {
+  const lines = chunk.content.split("\n");
+  const highlights = [];
+  for (const line of lines) {
+    const lineLower = line.toLowerCase();
+    for (const token of queryTokens) {
+      if (lineLower.includes(token)) {
+        const trimmed = line.trim();
+        if (trimmed.length > 0 && !highlights.includes(trimmed)) {
+          highlights.push(trimmed.slice(0, 100));
+          break;
+        }
+      }
+    }
+    if (highlights.length >= 3) break;
+  }
+  return highlights;
+}
+function searchCodebase(projectPath, query, options = {}) {
+  const limit = options.limit ?? 10;
+  const minScore = options.minScore ?? 0.1;
+  const index = loadIndex(projectPath);
+  if (!index) {
+    console.warn("No index found. Run /index first.");
+    return [];
+  }
+  const queryTokens = tokenize(query);
+  if (queryTokens.length === 0) {
+    return [];
+  }
+  const queryTF = calculateTF(queryTokens);
+  const results = [];
+  for (const chunk of index.chunks) {
+    if (options.fileTypes && !options.fileTypes.includes(chunk.language)) {
+      continue;
+    }
+    if (options.chunkTypes && !options.chunkTypes.includes(chunk.type)) {
+      continue;
+    }
+    const score = scoreChunk(chunk, queryTokens, queryTF);
+    if (score >= minScore) {
+      results.push({
+        chunk,
+        score,
+        highlights: extractHighlights(chunk, queryTokens)
+      });
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, limit);
+}
+function getRelevantContext(projectPath, prompt, maxChunks = 5) {
+  const results = searchCodebase(projectPath, prompt, { limit: maxChunks });
+  if (results.length === 0) {
+    return "";
+  }
+  const parts = ["[Relevant Code Context]"];
+  for (const result of results) {
+    parts.push(`
+// ${result.chunk.relativePath}:${result.chunk.startLine}-${result.chunk.endLine}`);
+    parts.push("```" + result.chunk.language);
+    parts.push(result.chunk.content.slice(0, 500));
+    if (result.chunk.content.length > 500) {
+      parts.push("// ... (truncated)");
+    }
+    parts.push("```");
+  }
+  parts.push("[/Relevant Code Context]\n");
+  return parts.join("\n");
+}
+function findFiles(projectPath, pattern) {
+  const index = loadIndex(projectPath);
+  if (!index) return [];
+  const patternLower = pattern.toLowerCase();
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const chunk of index.chunks) {
+    if (seen.has(chunk.filePath)) continue;
+    if (chunk.relativePath.toLowerCase().includes(patternLower)) {
+      seen.add(chunk.filePath);
+      results.push(chunk);
+    }
+  }
+  return results;
+}
+
+export {
+  __require,
+  indexProject,
+  loadIndex,
+  isIndexStale,
+  searchCodebase,
+  getRelevantContext,
+  findFiles
+};

package/dist/index.js

@@ -1,10 +1,9 @@
 #!/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');
-});
+import {
+  __require,
+  indexProject,
+  searchCodebase
+} from "./chunk-NVMD3WL3.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -3915,7 +3914,174 @@ Generate the unified diff to make this change.`;
   }
 }
 
+// src/core/mcp/tools.ts
+var tools = /* @__PURE__ */ new Map();
+function registerTool(tool) {
+  tools.set(tool.name, tool);
+}
+function listTools() {
+  return Array.from(tools.values());
+}
+registerTool({
+  name: "read_file",
+  description: "Read the contents of a file",
+  category: "filesystem",
+  parameters: [
+    { name: "path", type: "string", description: "File path to read", required: true }
+  ],
+  execute: async (params) => {
+    const { readFileSync: readFileSync8 } = await import("fs");
+    const { resolve: resolve5 } = await import("path");
+    try {
+      const filePath = resolve5(process.cwd(), params.path);
+      const content = readFileSync8(filePath, "utf-8");
+      return {
+        success: true,
+        data: content,
+        display: `Read ${content.split("\n").length} lines from ${params.path}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to read file: ${error}`
+      };
+    }
+  }
+});
+registerTool({
+  name: "list_dir",
+  description: "List files in a directory",
+  category: "filesystem",
+  parameters: [
+    { name: "path", type: "string", description: "Directory path", required: false, default: "." }
+  ],
+  execute: async (params) => {
+    const { readdirSync: readdirSync2, statSync: statSync2 } = await import("fs");
+    const { resolve: resolve5, join: join8 } = await import("path");
+    try {
+      const dirPath = resolve5(process.cwd(), params.path || ".");
+      const entries = readdirSync2(dirPath);
+      const files = [];
+      const dirs = [];
+      for (const entry of entries) {
+        try {
+          const stat = statSync2(join8(dirPath, entry));
+          if (stat.isDirectory()) {
+            dirs.push(entry + "/");
+          } else {
+            files.push(entry);
+          }
+        } catch {
+          files.push(entry);
+        }
+      }
+      return {
+        success: true,
+        data: { dirs, files },
+        display: `${dirs.length} directories, ${files.length} files`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to list directory: ${error}`
+      };
+    }
+  }
+});
+registerTool({
+  name: "search_code",
+  description: "Search for code in the current project",
+  category: "code",
+  parameters: [
+    { name: "query", type: "string", description: "Search query", required: true },
+    { name: "limit", type: "number", description: "Max results", required: false, default: 5 }
+  ],
+  execute: async (params) => {
+    const { searchCodebase: searchCodebase2 } = await import("./rag-6HO4ZLBN.js");
+    const results = searchCodebase2(
+      process.cwd(),
+      params.query,
+      { limit: params.limit || 5 }
+    );
+    if (results.length === 0) {
+      return {
+        success: true,
+        data: [],
+        display: "No results found"
+      };
+    }
+    const display = results.map(
+      (r) => `${r.chunk.relativePath}:${r.chunk.startLine} (score: ${r.score.toFixed(2)})`
+    ).join("\n");
+    return {
+      success: true,
+      data: results.map((r) => ({
+        file: r.chunk.relativePath,
+        line: r.chunk.startLine,
+        content: r.chunk.content.slice(0, 200)
+      })),
+      display
+    };
+  }
+});
+registerTool({
+  name: "run_command",
+  description: "Run a shell command (requires user approval)",
+  category: "system",
+  parameters: [
+    { name: "command", type: "string", description: "Command to run", required: true }
+  ],
+  execute: async (params) => {
+    return {
+      success: false,
+      error: "Shell commands require explicit user approval. Use /build or /exec instead."
+    };
+  }
+});
+
+// src/core/memory-store.ts
+import { existsSync as existsSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir6 } from "os";
+var MEMORY_DIR = join7(homedir6(), ".agdi", "memory");
+var MEMORY_FILE = join7(MEMORY_DIR, "store.json");
+function ensureMemoryDir() {
+  if (!existsSync10(MEMORY_DIR)) {
+    mkdirSync5(MEMORY_DIR, { recursive: true });
+  }
+}
+function loadMemoryStore() {
+  ensureMemoryDir();
+  if (existsSync10(MEMORY_FILE)) {
+    try {
+      const data = readFileSync7(MEMORY_FILE, "utf-8");
+      return JSON.parse(data);
+    } catch {
+    }
+  }
+  return {
+    version: 1,
+    entries: [],
+    userPreferences: {},
+    projectContexts: {}
+  };
+}
+function getMemoryStats() {
+  const store = loadMemoryStore();
+  const byType = {};
+  for (const entry of store.entries) {
+    byType[entry.type] = (byType[entry.type] || 0) + 1;
+  }
+  return {
+    totalEntries: store.entries.length,
+    byType,
+    projectCount: Object.keys(store.projectContexts).length,
+    preferenceCount: Object.keys(store.userPreferences).length
+  };
+}
+
 // src/commands/agdi-dev.ts
+var multiAgentMode = false;
 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
@@ -4091,6 +4257,69 @@ async function startCodingMode() {
         }
         continue;
       }
+      if (trimmed === "/index") {
+        const spinner2 = ora4("Indexing project...").start();
+        try {
+          const index = indexProject(process.cwd());
+          spinner2.succeed(`Indexed ${index.fileCount} files, ${index.chunkCount} chunks`);
+        } catch (error) {
+          spinner2.fail("Indexing failed: " + (error instanceof Error ? error.message : String(error)));
+        }
+        continue;
+      }
+      if (trimmed.startsWith("/search ")) {
+        const query = userInput.slice(8).trim();
+        if (!query) {
+          console.log(chalk12.yellow("\nUsage: /search <query>\n"));
+          continue;
+        }
+        const results = searchCodebase(process.cwd(), query, { limit: 8 });
+        if (results.length === 0) {
+          console.log(chalk12.gray("\nNo results found. Try /index first.\n"));
+        } else {
+          console.log(chalk12.cyan.bold("\n\u{1F50D} Search Results\n"));
+          for (const r of results) {
+            console.log(chalk12.green(`  ${r.chunk.relativePath}:${r.chunk.startLine}`) + chalk12.gray(` (${r.score.toFixed(2)})`));
+            if (r.highlights.length > 0) {
+              console.log(chalk12.gray(`    ${r.highlights[0].slice(0, 60)}...`));
+            }
+          }
+          console.log("");
+        }
+        continue;
+      }
+      if (trimmed === "/tools") {
+        const tools2 = listTools();
+        console.log(chalk12.cyan.bold("\n\u{1F527} Available Tools\n"));
+        for (const tool of tools2) {
+          console.log(chalk12.green(`  ${tool.name}`) + chalk12.gray(` [${tool.category}]`));
+          console.log(chalk12.gray(`    ${tool.description}`));
+        }
+        console.log("");
+        continue;
+      }
+      if (trimmed === "/agent") {
+        multiAgentMode = !multiAgentMode;
+        console.log(chalk12.cyan(`
+\u{1F916} Multi-agent mode: ${multiAgentMode ? chalk12.green("ON") : chalk12.gray("OFF")}
+`));
+        if (multiAgentMode) {
+          console.log(chalk12.gray("  Planner \u2192 Coder \u2192 Reviewer pipeline enabled\n"));
+        }
+        continue;
+      }
+      if (trimmed === "/memory") {
+        const stats = getMemoryStats();
+        console.log(chalk12.cyan.bold("\n\u{1F9E0} Memory Stats\n"));
+        console.log(chalk12.gray(`  Total entries: ${stats.totalEntries}`));
+        console.log(chalk12.gray(`  Projects: ${stats.projectCount}`));
+        console.log(chalk12.gray(`  Preferences: ${stats.preferenceCount}`));
+        for (const [type, count] of Object.entries(stats.byType)) {
+          console.log(chalk12.gray(`  ${type}: ${count}`));
+        }
+        console.log("");
+        continue;
+      }
       if (trimmed.startsWith("/build ") || trimmed.startsWith("build ")) {
         const prompt = userInput.replace(/^\/?build\s+/i, "").trim();
         if (prompt) {
@@ -4302,6 +4531,15 @@ function showHelp() {
   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("  RAG Commands:"));
+  console.log(chalk12.gray("  /index     ") + "Index current project for search");
+  console.log(chalk12.gray("  /search    ") + "Semantic code search");
+  console.log("");
+  console.log(chalk12.cyan("  Advanced:"));
+  console.log(chalk12.gray("  /tools     ") + "List available MCP tools");
+  console.log(chalk12.gray("  /agent     ") + "Toggle multi-agent mode");
+  console.log(chalk12.gray("  /memory    ") + "Show memory stats");
+  console.log("");
   console.log(chalk12.cyan("  Conversation:"));
   console.log(chalk12.gray("  /clear     ") + "Clear conversation history");
   console.log(chalk12.gray("  /history   ") + "Show recent conversation");
@@ -4312,7 +4550,6 @@ function showHelp() {
   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);

package/dist/rag-6HO4ZLBN.js

@@ -0,0 +1,16 @@
+import {
+  findFiles,
+  getRelevantContext,
+  indexProject,
+  isIndexStale,
+  loadIndex,
+  searchCodebase
+} from "./chunk-NVMD3WL3.js";
+export {
+  findFiles,
+  getRelevantContext,
+  indexProject,
+  isIndexStale,
+  loadIndex,
+  searchCodebase
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "agdi",
-    "version": "2.5.0",
+    "version": "2.6.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"
     }
-}
+}