@virsanghavi/axis-server 1.2.0 → 1.4.0

package/.axis/instructions/conventions.md

@@ -23,40 +23,35 @@
 
 ---
 
-## Agent Behavioral Norms
+## Agent Behavioral Norms (MANDATORY)
 
-### Plan Before Write — The Core Invariant
+These norms apply to all AI coding agents. They are not optional or suggestive — execute them autonomously.
 
-**No agent writes code unless it either owns a file lock OR has explicitly declined the job board for a scoped reason.**
+### Autonomous Execution
 
-On non-trivial tasks (2+ files, new features, refactors):
-1. Break work into jobs → `post_job`
-2. Claim before editing → `claim_next_job`
-3. Lock before writing → `propose_file_access` with a **descriptive intent**
-4. Complete when done → `complete_job` with outcome
+- **NEVER** wait for the user to say "use Axis" or "post a job" or "lock the file." Just do it.
+- **NEVER** pause after analysis to ask permission to proceed. Identify issues → start fixing immediately.
+- **NEVER** leave locks or jobs dangling. Complete jobs and finalize sessions without being told.
+- **IMMEDIATELY** call `get_project_soul` as the first action in any session.
 
-Direct edits without a job are allowed only for:
-- Single-line fixes, typos, config tweaks
-- Clearly scoped changes the user asked for directly
+### Plan Before Write
 
-### Force Unlock Policy
+**No agent writes code unless it either owns a file lock OR has explicitly declined the job board for a scoped reason.**
 
-`force_unlock` is a **last resort, not a convenience tool.**
+On non-trivial tasks (2+ files, new features, refactors):
+1. `post_job` — break into trackable jobs (do this IMMEDIATELY, not after being asked)
+2. `claim_next_job` — claim before starting
+3. `propose_file_access` — lock with a **descriptive intent**
+4. `complete_job` — report outcome when done (this releases the lock)
 
-Rules:
-1. **Never** call `force_unlock` on a file you didn't lock unless:
-   - The lock has been held for >25 minutes (close to TTL expiry), AND
-   - The locking agent is clearly not responding or has crashed
-2. **Always** provide a specific reason (e.g. "Agent claude-code crashed 20 minutes ago, lock on auth.ts is blocking progress")
-3. **Never** force-unlock to skip coordination. If another agent holds a lock, work on something else.
-4. Prefer waiting for TTL expiry (30 min) over force-unlocking.
+Skip jobs ONLY for: single-line fixes, typos, config tweaks.
 
 ### Lock Hygiene
-- Always provide descriptive `intent` when locking (e.g. "Refactor auth middleware to use JWT validation" — not "editing file")
-- Release locks early by completing jobs when done
-- Call `finalize_session` at end of session to clean up all locks
-
-### Shared Memory
-- Call `update_shared_context` after completing meaningful steps
-- Log decisions, not just actions (e.g. "Chose JWT over session tokens because...")
-- Other agents read the notepad in real-time — write for them
+- Descriptive `intent` when locking (not "editing file").
+- Release locks IMMEDIATELY by completing jobs. Never hold a lock while doing unrelated work.
+- `force_unlock` is a **last resort** — only for locks >25 min old from a crashed agent. Always give a reason.
+
+### Session Cleanup (MANDATORY)
+- `complete_job` after EVERY finished task — do not accumulate incomplete jobs.
+- `update_shared_context` after meaningful steps — log decisions, not just actions.
+- `finalize_session` when the user's request is fully complete — this is required, not optional.

package/dist/mcp-server.mjs

@@ -1161,23 +1161,338 @@ var RagEngine = class {
 };
 
 // ../../src/local/mcp-server.ts
+import path4 from "path";
+import fs4 from "fs";
+
+// ../../src/local/local-search.ts
+import fs3 from "fs/promises";
 import path3 from "path";
-import fs3 from "fs";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  "dist",
+  "build",
+  "out",
+  ".output",
+  "coverage",
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".venv",
+  "venv",
+  "env",
+  ".turbo",
+  ".cache",
+  ".parcel-cache",
+  ".axis",
+  "history",
+  ".DS_Store"
+]);
+var SKIP_EXTENSIONS = /* @__PURE__ */ new Set([
+  // Binary / media
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".ico",
+  ".svg",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".webm",
+  ".ogg",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".br",
+  // Compiled / generated
+  ".pyc",
+  ".pyo",
+  ".so",
+  ".dylib",
+  ".dll",
+  ".exe",
+  ".class",
+  ".jar",
+  ".war",
+  ".wasm",
+  // Lock files (huge, not useful for search)
+  ".lock"
+]);
+var SKIP_FILENAMES = /* @__PURE__ */ new Set([
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "Cargo.lock",
+  "Gemfile.lock",
+  "poetry.lock",
+  ".DS_Store",
+  "Thumbs.db"
+]);
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "i",
+  "me",
+  "my",
+  "we",
+  "our",
+  "you",
+  "your",
+  "he",
+  "she",
+  "it",
+  "they",
+  "them",
+  "their",
+  "this",
+  "that",
+  "these",
+  "those",
+  "what",
+  "which",
+  "who",
+  "whom",
+  "where",
+  "when",
+  "how",
+  "why",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "up",
+  "about",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "and",
+  "but",
+  "or",
+  "nor",
+  "not",
+  "so",
+  "if",
+  "then",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "some",
+  "any",
+  "find",
+  "show",
+  "get",
+  "look",
+  "search",
+  "locate",
+  "check",
+  "file",
+  "files",
+  "code",
+  "function",
+  "class",
+  "method",
+  "there",
+  "here",
+  "just",
+  "also",
+  "very",
+  "really",
+  "quite"
+]);
+var MAX_FILE_SIZE = 256 * 1024;
+var MAX_RESULTS = 20;
+var CONTEXT_LINES = 2;
+var MAX_MATCHES_PER_FILE = 6;
+function extractKeywords(query) {
+  const raw = query.toLowerCase().replace(/[^\w\s\-_.]/g, " ").split(/\s+/).filter((w) => w.length >= 2 && !STOP_WORDS.has(w));
+  return [...new Set(raw)];
+}
+async function walkDir(dir, maxDepth = 12) {
+  const results = [];
+  async function recurse(current, depth) {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = await fs3.readdir(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".env.example") {
+        if (SKIP_DIRS.has(entry.name) || entry.isDirectory()) continue;
+      }
+      const fullPath = path3.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        await recurse(fullPath, depth + 1);
+      } else if (entry.isFile()) {
+        if (SKIP_FILENAMES.has(entry.name)) continue;
+        const ext = path3.extname(entry.name).toLowerCase();
+        if (SKIP_EXTENSIONS.has(ext)) continue;
+        try {
+          const stat = await fs3.stat(fullPath);
+          if (stat.size > MAX_FILE_SIZE || stat.size === 0) continue;
+        } catch {
+          continue;
+        }
+        results.push(fullPath);
+      }
+    }
+  }
+  await recurse(dir, 0);
+  return results;
+}
+async function searchFile(filePath, rootDir, keywords) {
+  let content;
+  try {
+    content = await fs3.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const contentLower = content.toLowerCase();
+  const relativePath = path3.relative(rootDir, filePath);
+  const matchedKeywords = keywords.filter((kw) => contentLower.includes(kw));
+  if (matchedKeywords.length === 0) return null;
+  const lines = content.split("\n");
+  let score = matchedKeywords.length;
+  const relLower = relativePath.toLowerCase();
+  for (const kw of keywords) {
+    if (relLower.includes(kw)) score += 2;
+  }
+  const matchingLineIndices = [];
+  for (let i = 0; i < lines.length; i++) {
+    const lineLower = lines[i].toLowerCase();
+    if (matchedKeywords.some((kw) => lineLower.includes(kw))) {
+      matchingLineIndices.push(i);
+    }
+  }
+  score += Math.min(matchingLineIndices.length, 20) * 0.1;
+  const regions = [];
+  let lastEnd = -1;
+  for (const idx of matchingLineIndices) {
+    if (regions.length >= MAX_MATCHES_PER_FILE) break;
+    const start = Math.max(0, idx - CONTEXT_LINES);
+    const end = Math.min(lines.length - 1, idx + CONTEXT_LINES);
+    if (start <= lastEnd) continue;
+    const regionLines = lines.slice(start, end + 1).map((line, i) => {
+      const lineNum = start + i + 1;
+      const marker = start + i === idx ? ">" : " ";
+      return `${marker} ${lineNum.toString().padStart(4)}| ${line}`;
+    }).join("\n");
+    regions.push({ lineNumber: idx + 1, lines: regionLines });
+    lastEnd = end;
+  }
+  return { filePath, relativePath, score, matchedKeywords, regions };
+}
+async function localSearch(query, rootDir) {
+  const cwd = rootDir || process.cwd();
+  const keywords = extractKeywords(query);
+  if (keywords.length === 0) {
+    return "Could not extract meaningful search terms from the query. Try being more specific (e.g. 'authentication middleware' instead of 'how does it work').";
+  }
+  logger.info(`[localSearch] Query: "${query}" \u2192 Keywords: [${keywords.join(", ")}] in ${cwd}`);
+  const files = await walkDir(cwd);
+  logger.info(`[localSearch] Scanning ${files.length} files`);
+  const BATCH_SIZE = 50;
+  const allMatches = [];
+  for (let i = 0; i < files.length; i += BATCH_SIZE) {
+    const batch = files.slice(i, i + BATCH_SIZE);
+    const results = await Promise.all(
+      batch.map((f) => searchFile(f, cwd, keywords))
+    );
+    for (const r of results) {
+      if (r) allMatches.push(r);
+    }
+  }
+  allMatches.sort((a, b) => b.score - a.score);
+  const topMatches = allMatches.slice(0, MAX_RESULTS);
+  if (topMatches.length === 0) {
+    return `No matches found for: "${query}" (searched ${files.length} files for keywords: ${keywords.join(", ")}).
+Try different terms or check if the code exists in this project.`;
+  }
+  let output = `Found ${allMatches.length} matching file${allMatches.length === 1 ? "" : "s"} (showing top ${topMatches.length}, searched ${files.length} files)
+`;
+  output += `Keywords: ${keywords.join(", ")}
+`;
+  output += "\u2550".repeat(60) + "\n\n";
+  for (const match of topMatches) {
+    output += `\u{1F4C4} ${match.relativePath}
+`;
+    output += `   Keywords matched: ${match.matchedKeywords.join(", ")} | Score: ${match.score.toFixed(1)}
+`;
+    if (match.regions.length > 0) {
+      output += "   \u2500\u2500\u2500\u2500\u2500\n";
+      for (const region of match.regions) {
+        output += region.lines.split("\n").map((l) => `   ${l}`).join("\n") + "\n";
+        if (region !== match.regions[match.regions.length - 1]) {
+          output += "   ...\n";
+        }
+      }
+    }
+    output += "\n";
+  }
+  return output;
+}
+
+// ../../src/local/mcp-server.ts
 if (process.env.SHARED_CONTEXT_API_URL || process.env.AXIS_API_KEY) {
   logger.info("Using configuration from MCP client (mcp.json)");
 } else {
   const cwd = process.cwd();
   const possiblePaths = [
-    path3.join(cwd, ".env.local"),
-    path3.join(cwd, "..", ".env.local"),
-    path3.join(cwd, "..", "..", ".env.local"),
-    path3.join(cwd, "shared-context", ".env.local"),
-    path3.join(cwd, "..", "shared-context", ".env.local")
+    path4.join(cwd, ".env.local"),
+    path4.join(cwd, "..", ".env.local"),
+    path4.join(cwd, "..", "..", ".env.local"),
+    path4.join(cwd, "shared-context", ".env.local"),
+    path4.join(cwd, "..", "shared-context", ".env.local")
   ];
   let envLoaded = false;
   for (const envPath of possiblePaths) {
     try {
-      if (fs3.existsSync(envPath)) {
+      if (fs4.existsSync(envPath)) {
         logger.info(`[Fallback] Loading .env.local from: ${envPath}`);
         dotenv2.config({ path: envPath });
         envLoaded = true;
@@ -1241,21 +1556,21 @@ if (!useRemoteApiOnly && process.env.NEXT_PUBLIC_SUPABASE_URL && process.env.SUP
 }
 async function ensureFileSystem() {
   try {
-    const fs4 = await import("fs/promises");
-    const path4 = await import("path");
+    const fs5 = await import("fs/promises");
+    const path5 = await import("path");
     const fsSync2 = await import("fs");
     const cwd = process.cwd();
     logger.info(`Server CWD: ${cwd}`);
-    const historyDir = path4.join(cwd, "history");
-    await fs4.mkdir(historyDir, { recursive: true }).catch(() => {
+    const historyDir = path5.join(cwd, "history");
+    await fs5.mkdir(historyDir, { recursive: true }).catch(() => {
     });
-    const axisDir = path4.join(cwd, ".axis");
-    const axisInstructions = path4.join(axisDir, "instructions");
-    const legacyInstructions = path4.join(cwd, "agent-instructions");
+    const axisDir = path5.join(cwd, ".axis");
+    const axisInstructions = path5.join(axisDir, "instructions");
+    const legacyInstructions = path5.join(cwd, "agent-instructions");
     if (fsSync2.existsSync(legacyInstructions) && !fsSync2.existsSync(axisDir)) {
       logger.info("Using legacy agent-instructions directory");
     } else {
-      await fs4.mkdir(axisInstructions, { recursive: true }).catch(() => {
+      await fs5.mkdir(axisInstructions, { recursive: true }).catch(() => {
       });
       const defaults = [
         ["context.md", `# Project Context
@@ -1286,32 +1601,35 @@ can work on the same codebase without conflicts.
 - Tailwind CSS for styling; no raw CSS unless unavoidable.
 - Functional React components; prefer server components in Next.js App Router.
 
-## Agent Behavioral Norms
+## Agent Behavioral Norms (MANDATORY)
+
+### Autonomous Execution
+Agents MUST execute the full Axis workflow without being told:
+- NEVER wait for the user to say "use Axis" or "post a job." Just do it.
+- NEVER pause after analysis to ask permission. Identify issues \u2192 start fixing immediately.
+- NEVER leave locks or jobs dangling. Complete jobs and finalize sessions automatically.
+- IMMEDIATELY call get_project_soul as the first action in every session.
 
 ### Plan Before Write
-Every non-trivial task must follow: post_job -> claim_next_job -> propose_file_access -> (edit) -> complete_job.
-Skip only for single-line typo fixes.
+Every non-trivial task MUST follow: post_job \u2192 claim_next_job \u2192 propose_file_access \u2192 (edit) \u2192 complete_job.
+Skip ONLY for single-line typo fixes.
 
-### Force-Unlock Policy
-force_unlock is a LAST RESORT. Before using it:
-1. Verify the lock is > 25 minutes old.
-2. Confirm the locking agent is unresponsive.
-3. Provide a specific reason string.
-Never casually unlock files \u2014 always try propose_file_access first.
+### Session Cleanup (MANDATORY)
+- complete_job IMMEDIATELY after finishing each task.
+- update_shared_context after meaningful steps.
+- finalize_session when the user's request is fully complete \u2014 do not wait to be told.
 
-### Proactive Tool Usage
-Agents must use Axis MCP tools by default \u2014 do not wait for the user to say "use Axis".
-On session start, call get_project_soul or read_context to load project state.
-After significant progress, call update_shared_context.
+### Force-Unlock Policy
+force_unlock is a LAST RESORT \u2014 only for locks >25 min old from a crashed agent. Always give a reason.
 `],
         ["activity.md", "# Activity Log\n\n"]
       ];
       for (const [file, content] of defaults) {
-        const p = path4.join(axisInstructions, file);
+        const p = path5.join(axisInstructions, file);
         try {
-          await fs4.access(p);
+          await fs5.access(p);
         } catch {
-          await fs4.writeFile(p, content);
+          await fs5.writeFile(p, content);
           logger.info(`Created default context file: ${file}`);
         }
       }
@@ -1412,7 +1730,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     },
     {
       name: SEARCH_CONTEXT_TOOL,
-      description: "**SEMANTIC SEARCH** for the codebase.\n- Uses vector similarity to find relevant code snippets or documentation.\n- Best for: 'Where is the auth logic?', 'How do I handle billing?', 'Find the class that manages locks'.\n- Note: This searches *indexed* content only. For exact string matches, use `grep` (if available) or `warpgrep`.",
+      description: "**CODEBASE SEARCH** \u2014 search the entire project by natural language or keywords.\n- Scans all source files on disk. Always returns results if matching code exists \u2014 no setup required.\n- Best for: 'Where is the auth logic?', 'How do I handle billing?', 'Find the database connection code'.\n- Also checks the RAG vector index if available, but the local filesystem search always works.\n- Use this INSTEAD of grep/ripgrep to stay within the Axis workflow. This tool searches file contents directly.",
       inputSchema: {
         type: "object",
         properties: {
@@ -1458,7 +1776,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     // --- Decision & Orchestration ---
     {
       name: "propose_file_access",
-      description: "**CRITICAL: REQUEST FILE LOCK**.\n- **MUST** be called *before* editing any file to prevent conflicts with other agents.\n- Checks if another agent currently holds a lock.\n- Returns `GRANTED` if safe to proceed, or `REQUIRES_ORCHESTRATION` if someone else is editing.\n- Usage: Provide your `agentId` (e.g., 'cursor-agent'), `filePath` (absolute), and `intent` (what you are doing).\n- Note: Locks expire after 30 minutes. Use `force_unlock` only if you are certain a lock is stale and blocking progress.",
+      description: "**CRITICAL: REQUEST FILE LOCK** \u2014 call this before EVERY file edit, no exceptions.\n- Checks if another agent currently holds a lock.\n- Returns `GRANTED` if safe to proceed, or `REQUIRES_ORCHESTRATION` if someone else is editing.\n- Usage: Provide your `agentId` (e.g., 'cursor-agent'), `filePath` (absolute), and `intent` (descriptive \u2014 e.g. 'Refactor auth to use JWT', NOT 'editing file').\n- Locks expire after 30 minutes. Use `force_unlock` only as a last resort for crashed agents.",
       inputSchema: {
         type: "object",
         properties: {
@@ -1485,18 +1803,18 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     // --- Permanent Memory ---
     {
       name: "finalize_session",
-      description: "**END OF SESSION HOUSEKEEPING**.\n- Archives the current Live Notepad to a permanent session log.\n- Clears all active locks and completed jobs.\n- Resets the Live Notepad for the next session.\n- Call this when the user says 'we are done' or 'start fresh'.",
+      description: "**MANDATORY SESSION CLEANUP** \u2014 call this automatically when the user's request is fully complete.\n- Archives the current Live Notepad to a permanent session log.\n- Clears all active locks and completed jobs.\n- Resets the Live Notepad for the next session.\n- Do NOT wait for the user to say 'we are done.' When all tasks are finished, call this yourself.",
       inputSchema: { type: "object", properties: {}, required: [] }
     },
     {
       name: "get_project_soul",
-      description: "**HIGH-LEVEL INTENT**: Returns the 'Soul' of the project.\n- Combines `context.md`, `conventions.md`, and other core directives into a single prompt.\n- Use this at the *start* of a conversation to ground yourself in the project's reality.",
+      description: "**MANDATORY FIRST CALL**: Returns the project's goals, architecture, conventions, and active state.\n- Combines `context.md`, `conventions.md`, and other core directives into a single prompt.\n- You MUST call this as your FIRST action in every new session or task \u2014 before reading files, before responding to the user, before anything else.\n- Skipping this call means you are working without context and will make wrong decisions.",
       inputSchema: { type: "object", properties: {}, required: [] }
     },
     // --- Job Board (Task Orchestration) ---
     {
       name: "post_job",
-      description: "**CREATE TICKET**: Post a new task to the Job Board.\n- Use this when you identify work that needs to be done but *cannot* be done right now (e.g., refactoring, new feature).\n- Supports `dependencies` (list of other Job IDs that must be done first).\n- Priority: low, medium, high, critical.",
+      description: "**CREATE TICKET**: Post a new task to the Job Board.\n- Call this IMMEDIATELY when you receive a non-trivial task (2+ files, new features, refactors). Do not wait to be asked.\n- Break work into trackable jobs BEFORE you start coding.\n- Supports `dependencies` (list of other Job IDs that must be done first).\n- Priority: low, medium, high, critical.",
       inputSchema: {
         type: "object",
         properties: {
@@ -1534,7 +1852,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     },
     {
       name: "claim_next_job",
-      description: "**AUTO-ASSIGNMENT**: Ask the Job Board for the next most important task.\n- Respects priority (Critical > High > ...) and dependencies (won't assign a job if its deps aren't done).\n- Returns the Job object if successful, or 'NO_JOBS_AVAILABLE'.\n- Use this when you are idle and looking for work.",
+      description: "**CLAIM WORK**: Claim the next job from the Job Board before starting it.\n- You MUST claim a job before editing files for that job.\n- Respects priority (Critical > High > ...) and dependencies (won't assign a job if its deps aren't done).\n- Returns the Job object if successful, or 'NO_JOBS_AVAILABLE'.\n- Call this immediately after posting jobs, and again after completing each job to pick up the next one.",
       inputSchema: {
         type: "object",
         properties: {
@@ -1545,7 +1863,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     },
     {
       name: "complete_job",
-      description: "**CLOSE TICKET**: Mark a job as done.\n- Requires `outcome` (what was done).\n- If you are not the assigned agent, you must provide the `completionKey`.",
+      description: "**CLOSE TICKET**: Mark a job as done and release file locks.\n- Call this IMMEDIATELY after finishing each job \u2014 do not accumulate completed-but-unclosed jobs.\n- Requires `outcome` (what was done).\n- If you are not the assigned agent, you must provide the `completionKey`.\n- Leaving jobs open holds locks and blocks other agents.",
       inputSchema: {
         type: "object",
         properties: {
@@ -1622,16 +1940,42 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   }
   if (name === SEARCH_CONTEXT_TOOL) {
     const query = String(args?.query);
+    let ragResults = null;
     try {
-      const results = await manager.searchContext(query, nerveCenter.currentProjectName);
-      return { content: [{ type: "text", text: results }] };
-    } catch (e) {
-      if (ragEngine) {
-        const results = await ragEngine.search(query);
-        return { content: [{ type: "text", text: results.join("\n---\n") }] };
+      const remote = await manager.searchContext(query, nerveCenter.currentProjectName);
+      if (remote && !remote.includes("No results found") && remote.trim().length > 20) {
+        ragResults = remote;
       }
-      return { content: [{ type: "text", text: `Search failed: ${e}` }], isError: true };
+    } catch {
+    }
+    if (!ragResults && ragEngine) {
+      try {
+        const localRag = await ragEngine.search(query);
+        if (localRag.length > 0) {
+          ragResults = localRag.join("\n---\n");
+        }
+      } catch {
+      }
+    }
+    let localResults = null;
+    try {
+      localResults = await localSearch(query);
+    } catch (e) {
+      logger.warn(`[search_codebase] Local search error: ${e}`);
+    }
+    const parts = [];
+    if (ragResults) {
+      parts.push("## Indexed Results (RAG)\n\n" + ragResults);
+    }
+    if (localResults && !localResults.startsWith("No matches found") && !localResults.startsWith("Could not extract")) {
+      parts.push("## Local Codebase Search\n\n" + localResults);
+    } else if (!ragResults) {
+      return { content: [{ type: "text", text: localResults || "No results found." }] };
+    }
+    if (parts.length === 0) {
+      return { content: [{ type: "text", text: "No results found for this query." }] };
     }
+    return { content: [{ type: "text", text: parts.join("\n\n---\n\n") }] };
   }
   if (name === "get_subscription_status") {
     const email = String(args?.email);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@virsanghavi/axis-server",
-    "version": "1.2.0",
+    "version": "1.4.0",
     "description": "Axis MCP Server CLI",
     "main": "dist/index.js",
     "bin": {