@teddysc/claude-run 0.5.0 → 0.6.0

package/README.md

@@ -25,6 +25,12 @@ The browser will open automatically at http://localhost:12001.
 
 ## Changelog
 
+### 0.6.0
+- Add full-text search using ripgrep
+- Search across all conversation content including tool calls
+- Include debug command in search response for troubleshooting
+- Always search ignored files for comprehensive results
+
 ### 0.5.0
 - Add conversation export to Markdown
 - Export modes: Full conversation or tools only
@@ -36,12 +42,12 @@ The browser will open automatically at http://localhost:12001.
 
 ## Features
 
+- **Full-text search** - Search across all conversation content including tool calls using ripgrep
 - **Export conversations** - Download conversations as Markdown with customizable options
 - **Export modes** - Choose between full conversation or tools-only export
 - **Truncation options** - Limit long tool outputs by line count or character count
 - **Batch export** - Export multiple conversations at once
 - **Real-time streaming** - Watch conversations update live as Claude responds
-- **Search** - Find sessions by prompt text or project name
 - **Filter by project** - Focus on specific projects
 - **Resume sessions** - Copy the resume command to continue any conversation in your terminal
 - **Copy messages** - Click the copy button on any message to copy its text content

package/dist/index.js

@@ -269,9 +269,130 @@ async function getConversationStream(sessionId, fromOffset = 0) {
   }
 }
 
+// api/fulltext-search.ts
+import { existsSync } from "fs";
+import { spawn } from "child_process";
+import { join as join2, basename as basename2 } from "path";
+var DEFAULT_RG_PATH = "/opt/homebrew/bin/rg";
+var DEFAULT_TIMEOUT_MS = 8e3;
+function getRipgrepPath() {
+  return process.env.CLAUDE_RUN_RG_PATH || DEFAULT_RG_PATH;
+}
+function encodeProjectPath2(projectPath) {
+  return projectPath.replace(/[/.]/g, "-");
+}
+function buildArgs(query, options) {
+  const args = [];
+  args.push("--no-ignore");
+  args.push("--glob", "*.jsonl");
+  args.push("--count-matches");
+  const maxCount = Math.max(1, Math.min(options.maxMatchesPerFile ?? 200, 2e3));
+  args.push("--max-count", String(maxCount));
+  if (options.caseSensitive) {
+    args.push("-s");
+  } else {
+    args.push("-i");
+  }
+  if (options.mode === "literal") {
+    args.push("-F");
+  }
+  if (options.wordRegexp) {
+    args.push("-w");
+  }
+  args.push("--", query);
+  return args;
+}
+function formatCommand(rgPath, args) {
+  return [rgPath, ...args].map((a) => JSON.stringify(a)).join(" ");
+}
+function parseCountMatchesOutput(stdout) {
+  const results = [];
+  for (const rawLine of stdout.split("\n")) {
+    const line = rawLine.trim();
+    if (!line) {
+      continue;
+    }
+    const lastColon = line.lastIndexOf(":");
+    if (lastColon <= 0) {
+      continue;
+    }
+    const filePath = line.slice(0, lastColon);
+    const countText = line.slice(lastColon + 1);
+    const count = Number.parseInt(countText, 10);
+    if (!Number.isFinite(count)) {
+      continue;
+    }
+    results.push({ filePath, count });
+  }
+  return results;
+}
+async function searchConversationsWithRipgrep(input) {
+  const { claudeDir: claudeDir3, query, options, project } = input;
+  const trimmedQuery = query.trim();
+  if (!trimmedQuery) {
+    return { matches: [], debugCommand: "" };
+  }
+  if (trimmedQuery.length > 500) {
+    throw new Error("Query too long (max 500 characters). ");
+  }
+  const rgPath = getRipgrepPath();
+  if (!existsSync(rgPath)) {
+    throw new Error(
+      `ripgrep not found at ${rgPath}. Set CLAUDE_RUN_RG_PATH to your rg binary path.`
+    );
+  }
+  const projectsRoot = join2(claudeDir3, "projects");
+  const searchRoot = project ? join2(projectsRoot, encodeProjectPath2(project)) : projectsRoot;
+  if (!existsSync(searchRoot)) {
+    return { matches: [], debugCommand: "" };
+  }
+  const args = [...buildArgs(trimmedQuery, options), searchRoot];
+  const debugCommand = formatCommand(rgPath, args);
+  console.log("[claude-run] rg:", debugCommand);
+  const timeoutMs = Math.max(1e3, Math.min(options.timeoutMs ?? DEFAULT_TIMEOUT_MS, 3e4));
+  const result = await new Promise((resolve, reject) => {
+    const child = spawn(rgPath, args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error(`ripgrep timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    child.stdout.setEncoding("utf-8");
+    child.stderr.setEncoding("utf-8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 2) {
+        reject(new Error(stderr || "ripgrep failed"));
+        return;
+      }
+      const parsed = parseCountMatchesOutput(stdout);
+      const matches = parsed.map(({ filePath, count }) => ({
+        sessionId: basename2(filePath, ".jsonl"),
+        matchCount: count
+      })).sort((a, b) => b.matchCount - a.matchCount);
+      resolve({ matches });
+    });
+  });
+  const maxSessions = Math.max(1, Math.min(options.maxSessions ?? 500, 5e3));
+  return { matches: result.matches.slice(0, maxSessions), debugCommand };
+}
+
 // api/watcher.ts
 import { watch } from "chokidar";
-import { basename as basename2, join as join2 } from "path";
+import { basename as basename3, join as join3 } from "path";
 var watcher = null;
 var claudeDir2 = "";
 var debounceTimers = /* @__PURE__ */ new Map();
@@ -287,7 +408,7 @@ function emitChange(filePath) {
       callback();
     }
   } else if (filePath.endsWith(".jsonl")) {
-    const sessionId = basename2(filePath, ".jsonl");
+    const sessionId = basename3(filePath, ".jsonl");
     for (const callback of sessionChangeListeners) {
       callback(sessionId, filePath);
     }
@@ -308,8 +429,8 @@ function startWatcher() {
   if (watcher) {
     return;
   }
-  const historyPath = join2(claudeDir2, "history.jsonl");
-  const projectsDir2 = join2(claudeDir2, "projects");
+  const historyPath = join3(claudeDir2, "history.jsonl");
+  const projectsDir2 = join3(claudeDir2, "projects");
   const usePolling = process.env.CLAUDE_RUN_USE_POLLING === "1";
   watcher = watch([historyPath, projectsDir2], {
     persistent: true,
@@ -348,18 +469,18 @@ function offSessionChange(callback) {
 }
 
 // api/server.ts
-import { join as join3, dirname } from "path";
+import { join as join4, dirname } from "path";
 import { fileURLToPath } from "url";
-import { readFileSync, existsSync } from "fs";
+import { readFileSync, existsSync as existsSync2 } from "fs";
 import open2 from "open";
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
 function getWebDistPath() {
-  const prodPath = join3(__dirname, "web");
-  if (existsSync(prodPath)) {
+  const prodPath = join4(__dirname, "web");
+  if (existsSync2(prodPath)) {
     return prodPath;
   }
-  return join3(__dirname, "..", "dist", "web");
+  return join4(__dirname, "..", "dist", "web");
 }
 function createServer(options) {
   const {
@@ -390,6 +511,32 @@ function createServer(options) {
     const projects = await getProjects();
     return c.json(projects);
   });
+  app.post("/api/search", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON body" }, 400);
+    }
+    if (!body || typeof body.query !== "string" || !body.options) {
+      return c.json({ error: "Missing query/options" }, 400);
+    }
+    try {
+      const result = await searchConversationsWithRipgrep({
+        claudeDir: getClaudeDir(),
+        query: body.query,
+        options: body.options,
+        project: body.project ?? null
+      });
+      if (result.debugCommand) {
+        c.header("X-Claude-Run-Rg-Command", result.debugCommand);
+      }
+      return c.json({ matches: result.matches });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Search failed";
+      return c.json({ error: message }, 500);
+    }
+  });
   app.get("/api/sessions/stream", async (c) => {
     return streamSSE(c, async (stream) => {
       let isConnected = true;
@@ -505,7 +652,7 @@ function createServer(options) {
   const webDistPath = getWebDistPath();
   app.use("/*", serveStatic({ root: webDistPath }));
   app.get("/*", async (c) => {
-    const indexPath = join3(webDistPath, "index.html");
+    const indexPath = join4(webDistPath, "index.html");
     try {
       const html = readFileSync(indexPath, "utf-8");
       return c.html(html);
@@ -551,7 +698,7 @@ function createServer(options) {
 
 // api/index.ts
 import { homedir as homedir2 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname as dirname2 } from "path";
@@ -559,7 +706,7 @@ var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname2(__filename2);
 function getVersion() {
   try {
-    const pkgPath = join4(__dirname2, "..", "package.json");
+    const pkgPath = join5(__dirname2, "..", "package.json");
     const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
     return pkg.version;
   } catch {
@@ -571,7 +718,7 @@ program.name("claude-run").description(
 ).version(getVersion()).option("-p, --port <number>", "Port to listen on", "12001").option("-H, --host <address>", "Host address to listen on", "127.0.0.1").option(
   "-d, --dir <path>",
   "Claude directory path",
-  join4(homedir2(), ".claude")
+  join5(homedir2(), ".claude")
 ).option("--dev", "Enable CORS for development").option("--no-open", "Do not open browser automatically").parse();
 var opts = program.opts();
 var server = createServer({