agdi 2.5.1 → 2.6.1

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