@virsanghavi/axis-server 1.3.0 → 1.4.0

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
@@ -1310,11 +1625,11 @@ force_unlock is a LAST RESORT \u2014 only for locks >25 min old from a crashed a
         ["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}`);
         }
       }
@@ -1415,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: {
@@ -1625,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;
+      }
+    } catch {
+    }
+    if (!ragResults && ragEngine) {
+      try {
+        const localRag = await ragEngine.search(query);
+        if (localRag.length > 0) {
+          ragResults = localRag.join("\n---\n");
+        }
+      } catch {
       }
-      return { content: [{ type: "text", text: `Search failed: ${e}` }], isError: true };
     }
+    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.3.0",
+    "version": "1.4.0",
     "description": "Axis MCP Server CLI",
     "main": "dist/index.js",
     "bin": {