@residue/cli 0.0.2 → 0.0.4

package/dist/index.js

@@ -3622,10 +3622,40 @@ function capture() {
   });
 }
 
+// src/commands/clear.ts
+var log2 = createLogger("clear");
+function clear(opts) {
+  return safeTry(async function* () {
+    const projectRoot = yield* getProjectRoot();
+    const pendingPath = yield* getPendingPath(projectRoot);
+    const sessions = yield* readPending(pendingPath);
+    if (sessions.length === 0) {
+      log2.info("No pending sessions to clear.");
+      return ok(undefined);
+    }
+    if (opts?.id) {
+      const targetId = opts.id;
+      const isFound = sessions.some((s) => s.id === targetId);
+      if (!isFound) {
+        log2.info(`Session ${targetId} not found in pending queue.`);
+        return ok(undefined);
+      }
+      const remaining = sessions.filter((s) => s.id !== targetId);
+      yield* writePending({ path: pendingPath, sessions: remaining });
+      log2.info(`Cleared session ${targetId}.`);
+      return ok(undefined);
+    }
+    const count = sessions.length;
+    yield* writePending({ path: pendingPath, sessions: [] });
+    log2.info(`Cleared ${count} pending session(s).`);
+    return ok(undefined);
+  });
+}
+
 // src/commands/hook.ts
 import { mkdir as mkdir2, readFile, rm, stat, writeFile } from "fs/promises";
 import { join as join2 } from "path";
-var log2 = createLogger("hook");
+var log3 = createLogger("hook");
 function readStdin() {
   return ResultAsync.fromPromise((async () => {
     const chunks = [];
@@ -3722,7 +3752,7 @@ function handleSessionStart(opts) {
       message: "Failed to write hook state file",
       code: "IO_ERROR"
     }));
-    log2.debug("session started for claude-code");
+    log3.debug("session started for claude-code");
     return ok(undefined);
   });
 }
@@ -3754,7 +3784,7 @@ function handleSessionEnd(opts) {
       message: "Failed to remove hook state file",
       code: "IO_ERROR"
     }));
-    log2.debug("session %s ended", trimmedId);
+    log3.debug("session %s ended", trimmedId);
     return ok(undefined);
   });
 }
@@ -3785,7 +3815,7 @@ import {
   writeFile as writeFile2
 } from "fs/promises";
 import { join as join3 } from "path";
-var log3 = createLogger("init");
+var log4 = createLogger("init");
 var POST_COMMIT_LINE = "residue capture >/dev/null 2>&1 &";
 var PRE_PUSH_LINE = 'residue sync --remote-url "$2"';
 function installHook(opts) {
@@ -3876,9 +3906,9 @@ function init() {
       }),
       ensureGitignore(projectRoot)
     ]);
-    log3.info("Initialized residue in this repository.");
-    log3.info(`  ${postCommit}`);
-    log3.info(`  ${prePush}`);
+    log4.info("Initialized residue in this repository.");
+    log4.info(`  ${postCommit}`);
+    log4.info(`  ${prePush}`);
     return ok(undefined);
   });
 }
@@ -3937,7 +3967,7 @@ function resolveConfig() {
 }
 
 // src/commands/login.ts
-var log4 = createLogger("login");
+var log5 = createLogger("login");
 function login(opts) {
   if (!opts.url.startsWith("http://") && !opts.url.startsWith("https://")) {
     return errAsync(new CliError({
@@ -3949,17 +3979,164 @@ function login(opts) {
   const config = { worker_url: cleanUrl, token: opts.token };
   if (opts.isLocal) {
     return getProjectRoot().andThen((projectRoot) => writeLocalConfig({ projectRoot, config }).map(() => {
-      log4.info(`Logged in to ${cleanUrl} (project-local config)`);
+      log5.info(`Logged in to ${cleanUrl} (project-local config)`);
     }));
   }
   return writeConfig(config).map(() => {
-    log4.info(`Logged in to ${cleanUrl}`);
+    log5.info(`Logged in to ${cleanUrl}`);
   });
 }
 
+// src/lib/search-text.ts
+function buildSearchText(opts) {
+  const header = [
+    `Session: ${opts.metadata.sessionId}`,
+    `Agent: ${opts.metadata.agent}`,
+    opts.metadata.commits.length > 0 ? `Commits: ${opts.metadata.commits.join(", ")}` : null,
+    opts.metadata.branch ? `Branch: ${opts.metadata.branch}` : null,
+    opts.metadata.repo ? `Repo: ${opts.metadata.repo}` : null
+  ].filter(Boolean).join(`
+`);
+  const body = opts.lines.map((line) => `[${line.role}] ${line.text}`).join(`
+`);
+  return `${header}
+
+${body}
+`;
+}
+function extractClaudeCode(raw) {
+  const lines = [];
+  if (!raw.trim())
+    return lines;
+  const entries = [];
+  for (const line of raw.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {}
+  }
+  for (const entry of entries) {
+    if (entry.isMeta || entry.isSidechain)
+      continue;
+    if (entry.type === "user") {
+      const content = entry.message?.content;
+      if (!content)
+        continue;
+      if (typeof content === "string") {
+        const trimmed = content.trim();
+        if (trimmed)
+          lines.push({ role: "human", text: trimmed });
+      } else if (Array.isArray(content)) {
+        const hasToolResult = content.some((b) => b.type === "tool_result");
+        if (hasToolResult)
+          continue;
+        const text = content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join(`
+`).trim();
+        if (text)
+          lines.push({ role: "human", text });
+      }
+    } else if (entry.type === "assistant") {
+      const content = entry.message?.content;
+      if (!Array.isArray(content))
+        continue;
+      for (const block of content) {
+        if (block.type === "text" && block.text) {
+          const trimmed = block.text.trim();
+          if (trimmed)
+            lines.push({ role: "assistant", text: trimmed });
+        } else if (block.type === "tool_use" && block.name) {
+          const desc = summarizeToolInput(block.name, block.input);
+          lines.push({ role: "tool", text: desc });
+        }
+      }
+    }
+  }
+  return lines;
+}
+function extractPi(raw) {
+  const lines = [];
+  if (!raw.trim())
+    return lines;
+  const entries = [];
+  for (const line of raw.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {}
+  }
+  for (const entry of entries) {
+    if (entry.type !== "message")
+      continue;
+    const msg = entry.message;
+    if (!msg)
+      continue;
+    if (msg.role === "user") {
+      const content = msg.content;
+      if (!content)
+        continue;
+      if (typeof content === "string") {
+        const trimmed = content.trim();
+        if (trimmed)
+          lines.push({ role: "human", text: trimmed });
+      } else if (Array.isArray(content)) {
+        const text = content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join(`
+`).trim();
+        if (text)
+          lines.push({ role: "human", text });
+      }
+    } else if (msg.role === "assistant") {
+      const content = msg.content;
+      if (!Array.isArray(content)) {
+        if (typeof content === "string" && content.trim()) {
+          lines.push({ role: "assistant", text: content.trim() });
+        }
+        continue;
+      }
+      for (const block of content) {
+        if (block.type === "text" && block.text) {
+          const trimmed = block.text.trim();
+          if (trimmed)
+            lines.push({ role: "assistant", text: trimmed });
+        } else if (block.type === "toolCall" && block.name) {
+          const desc = summarizeToolInput(block.name, block.arguments);
+          lines.push({ role: "tool", text: desc });
+        }
+      }
+    }
+  }
+  return lines;
+}
+function summarizeToolInput(name, input) {
+  if (!input)
+    return name;
+  const path = input.path ?? input.file_path ?? input.filePath ?? input.filename;
+  if (typeof path === "string")
+    return `${name} ${path}`;
+  const command = input.command ?? input.cmd;
+  if (typeof command === "string") {
+    const short = command.length > 120 ? command.slice(0, 120) + "..." : command;
+    return `${name} ${short}`;
+  }
+  const query = input.query ?? input.search ?? input.pattern;
+  if (typeof query === "string")
+    return `${name} ${query}`;
+  return name;
+}
+var extractors = {
+  "claude-code": extractClaudeCode,
+  pi: extractPi
+};
+function getExtractor(agent) {
+  return extractors[agent] ?? null;
+}
+
 // src/commands/sync.ts
 import { stat as stat3 } from "fs/promises";
-var log5 = createLogger("sync");
+var log6 = createLogger("sync");
 var STALE_THRESHOLD_MS = 30 * 60 * 1000;
 function requestUploadUrl(opts) {
   return ResultAsync.fromPromise(fetch(`${opts.workerUrl}/api/sessions/upload-url`, {
@@ -4022,7 +4199,7 @@ function buildCommitMeta(opts) {
     for (const ref of opts.commitRefs) {
       const metaResult = await getCommitMeta(ref.sha);
       if (metaResult.isErr()) {
-        log5.warn(metaResult.error);
+        log6.warn(metaResult.error);
         continue;
       }
       commits.push({
@@ -4050,17 +4227,54 @@ function closeStaleOpenSessions(opts) {
   const checks = openSessions.map((session) => getFileMtimeMs(session.data_path).map((mtimeMs) => {
     if (mtimeMs === null) {
       session.status = "ended";
-      log5.debug("auto-closed session %s (data file not accessible)", session.id);
+      log6.debug("auto-closed session %s (data file not accessible)", session.id);
     } else {
       const msSinceModified = now - mtimeMs;
       if (msSinceModified > STALE_THRESHOLD_MS) {
         session.status = "ended";
-        log5.debug("auto-closed stale session %s (data file unchanged for %dm)", session.id, Math.round(msSinceModified / 60000));
+        log6.debug("auto-closed stale session %s (data file unchanged for %dm)", session.id, Math.round(msSinceModified / 60000));
       }
     }
   }));
   return ResultAsync.combine(checks).map(() => opts.sessions);
 }
+function generateSearchText(opts) {
+  const extractor = getExtractor(opts.session.agent);
+  if (!extractor) {
+    log6.debug("no search text extractor for agent %s, skipping", opts.session.agent);
+    return null;
+  }
+  const searchLines = extractor(opts.rawData);
+  if (searchLines.length === 0)
+    return null;
+  const branches = [
+    ...new Set(opts.session.commits.map((c) => c.branch).filter(Boolean))
+  ];
+  return buildSearchText({
+    metadata: {
+      sessionId: opts.session.id,
+      agent: opts.session.agent,
+      commits: opts.commits.map((c) => c.sha.slice(0, 7)),
+      branch: branches[0] ?? "",
+      repo: `${opts.org}/${opts.repo}`
+    },
+    lines: searchLines
+  });
+}
+function uploadSearchText(opts) {
+  return ResultAsync.fromPromise(fetch(opts.url, {
+    method: "PUT",
+    headers: { "Content-Type": "text/plain" },
+    body: opts.data
+  }).then((response) => {
+    if (!response.ok) {
+      throw new Error(`R2 search upload failed: HTTP ${response.status}`);
+    }
+  }), toCliError({
+    message: "Search text R2 upload failed",
+    code: "NETWORK_ERROR"
+  }));
+}
 function syncSessions(opts) {
   return ResultAsync.fromSafePromise((async () => {
     const remaining = [];
@@ -4071,13 +4285,13 @@ function syncSessions(opts) {
       }
       const dataResult = await readSessionData(session.data_path);
       if (dataResult.isErr()) {
-        log5.warn(dataResult.error);
+        log6.warn(dataResult.error);
         remaining.push(session);
         continue;
       }
       const data = dataResult.value;
       if (data === null) {
-        log5.warn(`dropping session ${session.id}: data file missing at ${session.data_path}`);
+        log6.warn(`dropping session ${session.id}: data file missing at ${session.data_path}`);
         continue;
       }
       const commitsResult = await buildCommitMeta({
@@ -4086,7 +4300,7 @@ function syncSessions(opts) {
         repo: opts.repo
       });
       if (commitsResult.isErr()) {
-        log5.warn(commitsResult.error);
+        log6.warn(commitsResult.error);
         remaining.push(session);
         continue;
       }
@@ -4096,7 +4310,7 @@ function syncSessions(opts) {
         sessionId: session.id
       });
       if (uploadUrlResult.isErr()) {
-        log5.warn(`failed to get upload URL for session ${session.id}: ${uploadUrlResult.error.message}`);
+        log6.warn(`failed to get upload URL for session ${session.id}: ${uploadUrlResult.error.message}`);
         remaining.push(session);
         continue;
       }
@@ -4105,11 +4319,29 @@ function syncSessions(opts) {
         data
       });
       if (directUploadResult.isErr()) {
-        log5.warn(`R2 upload failed for session ${session.id}: ${directUploadResult.error.message}`);
+        log6.warn(`R2 upload failed for session ${session.id}: ${directUploadResult.error.message}`);
         remaining.push(session);
         continue;
       }
-      log5.debug("uploaded session %s data directly to R2", session.id);
+      log6.debug("uploaded session %s data directly to R2", session.id);
+      const searchText = generateSearchText({
+        session,
+        rawData: data,
+        commits: commitsResult.value,
+        org: opts.org,
+        repo: opts.repo
+      });
+      if (searchText && uploadUrlResult.value.search_url) {
+        const searchUploadResult = await uploadSearchText({
+          url: uploadUrlResult.value.search_url,
+          data: searchText
+        });
+        if (searchUploadResult.isErr()) {
+          log6.warn(`search text upload failed for session ${session.id}: ${searchUploadResult.error.message}`);
+        } else {
+          log6.debug("uploaded search text for session %s", session.id);
+        }
+      }
       const metadataResult = await postSessionMetadata({
         workerUrl: opts.workerUrl,
         token: opts.token,
@@ -4122,14 +4354,14 @@ function syncSessions(opts) {
         commits: commitsResult.value
       });
       if (metadataResult.isErr()) {
-        log5.warn(`metadata upload failed for session ${session.id}: ${metadataResult.error.message}`);
+        log6.warn(`metadata upload failed for session ${session.id}: ${metadataResult.error.message}`);
         remaining.push(session);
         continue;
       }
       if (session.status === "open") {
         remaining.push(session);
       }
-      log5.debug("synced session %s", session.id);
+      log6.debug("synced session %s", session.id);
     }
     return remaining;
   })());
@@ -4175,8 +4407,157 @@ function sync(opts) {
 // src/commands/push.ts
 var push = sync;
 
+// src/commands/search.ts
+var log7 = createLogger("search");
+function fetchSearch(opts) {
+  const path = opts.isAi ? "/api/search/ai" : "/api/search";
+  const url = `${opts.workerUrl}${path}?q=${encodeURIComponent(opts.query)}`;
+  return ResultAsync.fromPromise(fetch(url, {
+    headers: { Authorization: `Bearer ${opts.token}` }
+  }).then(async (response) => {
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(`HTTP ${response.status}: ${body}`);
+    }
+    return response.json();
+  }), toCliError({ message: "Search request failed", code: "NETWORK_ERROR" }));
+}
+function fetchSessionCommits(opts) {
+  const url = `${opts.workerUrl}/api/sessions/${opts.sessionId}/commits`;
+  return ResultAsync.fromPromise(fetch(url, {
+    headers: { Authorization: `Bearer ${opts.token}` }
+  }).then(async (response) => {
+    if (!response.ok)
+      return [];
+    const data = await response.json();
+    return data.commits;
+  }), toCliError({
+    message: "Failed to fetch session commits",
+    code: "NETWORK_ERROR"
+  })).orElse(() => ok([]));
+}
+function extractSessionId(filename) {
+  const match = filename.match(/(?:sessions|search)\/(.+?)\.(?:json|txt)$/);
+  return match ? match[1] : filename;
+}
+function truncate(opts) {
+  if (opts.text.length <= opts.maxLength)
+    return opts.text;
+  return opts.text.slice(0, opts.maxLength) + "...";
+}
+function formatSnippet(text) {
+  const cleaned = text.replace(/\\n/g, " ").replace(/\\"/g, '"').replace(/\s+/g, " ").trim();
+  return truncate({ text: cleaned, maxLength: 200 });
+}
+function buildCommitUrl(opts) {
+  return `${opts.workerUrl}/app/${opts.org}/${opts.repo}/${opts.sha}`;
+}
+function renderSearchResults(opts) {
+  if (opts.results.data.length === 0) {
+    log7.info("No results found.");
+    return;
+  }
+  log7.info(`${opts.results.data.length} result(s) for "${opts.results.search_query}"
+`);
+  for (const item of opts.results.data) {
+    const sessionId = extractSessionId(item.filename);
+    const scorePercent = (item.score * 100).toFixed(1);
+    log7.info(`  ${sessionId}  [${scorePercent}%]`);
+    const snippet = item.content[0]?.text;
+    if (snippet) {
+      log7.info(`    ${formatSnippet(snippet)}`);
+    }
+    const commits = opts.commitMap.get(sessionId) ?? [];
+    if (commits.length > 0) {
+      for (const commit of commits) {
+        const url = buildCommitUrl({
+          workerUrl: opts.workerUrl,
+          org: commit.org,
+          repo: commit.repo,
+          sha: commit.commit_sha
+        });
+        log7.info(`    -> ${url}`);
+      }
+    }
+    log7.info("");
+  }
+}
+function renderAiSearchResults(opts) {
+  if (opts.results.response) {
+    log7.info(opts.results.response);
+    log7.info("");
+  }
+  if (opts.results.data.length > 0) {
+    log7.info(`--- Sources (${opts.results.data.length}) ---
+`);
+    for (const item of opts.results.data) {
+      const sessionId = extractSessionId(item.filename);
+      const scorePercent = (item.score * 100).toFixed(1);
+      log7.info(`  ${sessionId}  [${scorePercent}%]`);
+      const commits = opts.commitMap.get(sessionId) ?? [];
+      if (commits.length > 0) {
+        for (const commit of commits) {
+          const url = buildCommitUrl({
+            workerUrl: opts.workerUrl,
+            org: commit.org,
+            repo: commit.repo,
+            sha: commit.commit_sha
+          });
+          log7.info(`    -> ${url}`);
+        }
+      }
+    }
+    log7.info("");
+  }
+}
+function isAiSearchResponse(response) {
+  return "response" in response;
+}
+function search(opts) {
+  return safeTry(async function* () {
+    const config = yield* resolveConfig();
+    if (!config) {
+      return err(new CliError({
+        message: "Not configured. Run 'residue login' first.",
+        code: "CONFIG_MISSING"
+      }));
+    }
+    const results = yield* fetchSearch({
+      workerUrl: config.worker_url,
+      token: config.token,
+      query: opts.query,
+      isAi: opts.isAi ?? false
+    });
+    const sessionIds = results.data.map((item) => extractSessionId(item.filename));
+    const uniqueSessionIds = [...new Set(sessionIds)];
+    const commitResults = yield* ResultAsync.combine(uniqueSessionIds.map((sessionId) => fetchSessionCommits({
+      workerUrl: config.worker_url,
+      token: config.token,
+      sessionId
+    }).map((commits) => ({ sessionId, commits }))));
+    const commitMap = new Map;
+    for (const entry of commitResults) {
+      commitMap.set(entry.sessionId, entry.commits);
+    }
+    if (opts.isAi && isAiSearchResponse(results)) {
+      renderAiSearchResults({
+        results,
+        commitMap,
+        workerUrl: config.worker_url
+      });
+    } else {
+      renderSearchResults({
+        results,
+        commitMap,
+        workerUrl: config.worker_url
+      });
+    }
+    return ok(undefined);
+  });
+}
+
 // src/commands/session-end.ts
-var log6 = createLogger("session");
+var log8 = createLogger("session");
 function sessionEnd(opts) {
   return safeTry(async function* () {
     const projectRoot = yield* getProjectRoot();
@@ -4193,13 +4574,13 @@ function sessionEnd(opts) {
       id: opts.id,
       updates: { status: "ended" }
     });
-    log6.debug("session %s ended", opts.id);
+    log8.debug("session %s ended", opts.id);
     return ok(undefined);
   });
 }
 
 // src/commands/session-start.ts
-var log7 = createLogger("session");
+var log9 = createLogger("session");
 function sessionStart(opts) {
   const id = crypto.randomUUID();
   return getProjectRoot().andThen(getPendingPath).andThen((pendingPath) => addSession({
@@ -4214,7 +4595,7 @@ function sessionStart(opts) {
     }
   })).map(() => {
     process.stdout.write(id);
-    log7.debug("session started for %s", opts.agent);
+    log9.debug("session started for %s", opts.agent);
   });
 }
 
@@ -4363,7 +4744,7 @@ export default function (pi: ExtensionAPI) {
 `;
 
 // src/commands/setup.ts
-var log8 = createLogger("setup");
+var log10 = createLogger("setup");
 var CLAUDE_HOOK_COMMAND = "residue hook claude-code";
 function hasResidueHook(entries) {
   return entries.some((entry) => entry.hooks.some((h) => h.command === CLAUDE_HOOK_COMMAND));
@@ -4408,12 +4789,12 @@ function setupClaudeCode(projectRoot) {
       isChanged = true;
     }
     if (!isChanged) {
-      log8.info("residue hooks already configured in .claude/settings.json");
+      log10.info("residue hooks already configured in .claude/settings.json");
       return;
     }
     await writeFile3(settingsPath, JSON.stringify(settings, null, 2) + `
 `);
-    log8.info("Configured Claude Code hooks in .claude/settings.json");
+    log10.info("Configured Claude Code hooks in .claude/settings.json");
   })(), toCliError({ message: "Failed to setup Claude Code", code: "IO_ERROR" }));
 }
 function setupPi(projectRoot) {
@@ -4427,11 +4808,11 @@ function setupPi(projectRoot) {
       isExisting = true;
     } catch {}
     if (isExisting) {
-      log8.info("residue extension already exists at .pi/extensions/residue.ts");
+      log10.info("residue extension already exists at .pi/extensions/residue.ts");
       return;
     }
     await writeFile3(targetPath, extension_ts_default);
-    log8.info("Installed pi extension at .pi/extensions/residue.ts");
+    log10.info("Installed pi extension at .pi/extensions/residue.ts");
   })(), toCliError({ message: "Failed to setup pi", code: "IO_ERROR" }));
 }
 function setup(opts) {
@@ -4450,9 +4831,144 @@ function setup(opts) {
   });
 }
 
+// src/commands/status.ts
+import { readFile as readFile4, stat as stat5 } from "fs/promises";
+import { join as join6 } from "path";
+var log11 = createLogger("status");
+function checkFileExists(path) {
+  return ResultAsync.fromPromise(stat5(path).then(() => true), toCliError({ message: "Failed to check file", code: "IO_ERROR" })).orElse(() => okAsync(false));
+}
+function checkHookInstalled(opts) {
+  const hookPath = join6(opts.gitDir, "hooks", opts.hookName);
+  return ResultAsync.fromPromise(readFile4(hookPath, "utf-8").then((content) => content.includes(opts.needle)), toCliError({ message: "Failed to read hook", code: "IO_ERROR" })).orElse(() => okAsync(false));
+}
+function getGitDir() {
+  return ResultAsync.fromPromise((async () => {
+    const proc = Bun.spawn(["git", "rev-parse", "--git-dir"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    await proc.exited;
+    return (await new Response(proc.stdout).text()).trim();
+  })(), toCliError({ message: "Failed to get git directory", code: "GIT_ERROR" }));
+}
+function status() {
+  return safeTry(async function* () {
+    const isRepo = yield* isGitRepo();
+    if (!isRepo) {
+      log11.info("Not a git repository.");
+      return ok(undefined);
+    }
+    const projectRoot = yield* getProjectRoot();
+    log11.info("Login");
+    const globalConfig = yield* readConfig();
+    if (globalConfig) {
+      log11.info(`  global: ${globalConfig.worker_url}`);
+    } else {
+      log11.info("  global: not configured");
+    }
+    const localConfig = yield* readLocalConfig(projectRoot);
+    if (localConfig) {
+      log11.info(`  local:  ${localConfig.worker_url}`);
+    } else {
+      log11.info("  local:  not configured");
+    }
+    const isActiveConfig = localConfig ?? globalConfig;
+    if (isActiveConfig) {
+      log11.info(`  active: ${isActiveConfig.worker_url}`);
+    } else {
+      log11.info('  active: none (run "residue login" to configure)');
+    }
+    log11.info("");
+    log11.info("Hooks");
+    const gitDir = yield* getGitDir();
+    const isPostCommitInstalled = yield* checkHookInstalled({
+      gitDir,
+      hookName: "post-commit",
+      needle: "residue capture"
+    });
+    log11.info(`  post-commit: ${isPostCommitInstalled ? "installed" : "not installed"}`);
+    const isPrePushInstalled = yield* checkHookInstalled({
+      gitDir,
+      hookName: "pre-push",
+      needle: "residue sync"
+    });
+    log11.info(`  pre-push:    ${isPrePushInstalled ? "installed" : "not installed"}`);
+    if (!isPostCommitInstalled || !isPrePushInstalled) {
+      log11.info('  run "residue init" to install missing hooks');
+    }
+    log11.info("");
+    log11.info("Adapters");
+    const isClaudeSetup = yield* checkFileExists(join6(projectRoot, ".claude", "settings.json"));
+    let isClaudeHookConfigured = false;
+    if (isClaudeSetup) {
+      isClaudeHookConfigured = yield* ResultAsync.fromPromise(readFile4(join6(projectRoot, ".claude", "settings.json"), "utf-8").then((content) => content.includes("residue hook claude-code")), toCliError({
+        message: "Failed to read claude settings",
+        code: "IO_ERROR"
+      })).orElse(() => okAsync(false));
+    }
+    log11.info(`  claude-code: ${isClaudeHookConfigured ? "configured" : "not configured"}`);
+    const isPiSetup = yield* checkFileExists(join6(projectRoot, ".pi", "extensions", "residue.ts"));
+    log11.info(`  pi:          ${isPiSetup ? "configured" : "not configured"}`);
+    log11.info("");
+    log11.info("Sessions");
+    const pendingPath = yield* getPendingPath(projectRoot);
+    const sessions = yield* readPending(pendingPath);
+    if (sessions.length === 0) {
+      log11.info("  no pending sessions");
+    } else {
+      const openSessions = sessions.filter((s) => s.status === "open");
+      const endedSessions = sessions.filter((s) => s.status === "ended");
+      const totalCommits = sessions.reduce((sum, s) => sum + s.commits.length, 0);
+      const sessionsWithCommits = sessions.filter((s) => s.commits.length > 0);
+      log11.info(`  total:   ${sessions.length}`);
+      log11.info(`  open:    ${openSessions.length}`);
+      log11.info(`  ended:   ${endedSessions.length}`);
+      log11.info(`  commits: ${totalCommits} across ${sessionsWithCommits.length} session(s)`);
+      const isReadyToSync = sessionsWithCommits.length > 0;
+      if (isReadyToSync) {
+        log11.info(`  ${sessionsWithCommits.length} session(s) ready to sync on next push`);
+      } else {
+        log11.info("  no sessions ready to sync (no commits captured yet)");
+      }
+    }
+    return ok(undefined);
+  });
+}
+// package.json
+var package_default = {
+  name: "@residue/cli",
+  version: "0.0.4",
+  repository: {
+    type: "git",
+    url: "https://github.com/butttons/residue",
+    directory: "packages/cli"
+  },
+  type: "module",
+  bin: {
+    residue: "./dist/index.js"
+  },
+  scripts: {
+    dev: "bun run src/index.ts",
+    build: "bun build src/index.ts --outfile dist/index.js --target bun",
+    test: "bun test",
+    typecheck: "tsc --noEmit"
+  },
+  devDependencies: {
+    "@types/bun": "latest",
+    "@types/debug": "^4.1.12",
+    typescript: "^5.7.0"
+  },
+  dependencies: {
+    commander: "^14.0.3",
+    debug: "^4.4.3",
+    neverthrow: "^8.2.0"
+  }
+};
+
 // src/index.ts
 var program2 = new Command;
-program2.name("residue").description("Capture AI agent conversations linked to git commits").version("0.0.1");
+program2.name("residue").description("Capture AI agent conversations linked to git commits").version(package_default.version);
 program2.command("login").description("Save worker URL and auth token").requiredOption("--url <worker_url>", "Worker URL").requiredOption("--token <auth_token>", "Auth token").option("--local", "Save config to this project instead of globally").action(wrapCommand((opts) => login({ url: opts.url, token: opts.token, isLocal: opts.local })));
 program2.command("init").description("Install git hooks in current repo").action(wrapCommand(() => init()));
 program2.command("setup").description("Configure an agent adapter for this project").argument("<agent>", "Agent to set up (claude-code, pi)").action(wrapCommand((agent) => setup({ agent })));
@@ -4468,4 +4984,7 @@ session.command("end").description("Mark an agent session as ended").requiredOpt
 program2.command("capture").description("Tag pending sessions with current commit SHA (called by post-commit hook)").action(wrapHookCommand(() => capture()));
 program2.command("sync").description("Upload pending sessions to worker (called by pre-push hook)").option("--remote-url <url>", "Remote URL (passed by pre-push hook)").action(wrapHookCommand((opts) => sync({ remoteUrl: opts.remoteUrl })));
 program2.command("push").description("Upload pending sessions to worker (manual trigger)").action(wrapCommand(() => push()));
+program2.command("clear").description("Remove pending sessions from the local queue").option("--id <session-id>", "Clear a specific session by ID").action(wrapCommand((opts) => clear({ id: opts.id })));
+program2.command("status").description("Show current residue state for this project").action(wrapCommand(() => status()));
+program2.command("search").description("Search session history").argument("<query>", "Search query").option("--ai", "Use AI-powered search (generates an answer with citations)").action(wrapCommand((query, opts) => search({ query, isAi: opts.ai })));
 program2.parse();