@staff0rd/assist 0.192.0 → 0.193.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.192.0",
+  version: "0.193.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -925,10 +925,10 @@ function writeSignal(event, data) {
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path50 = getSignalPath();
-  if (!existsSync5(path50)) return void 0;
+  const path52 = getSignalPath();
+  if (!existsSync5(path52)) return void 0;
   try {
-    return JSON.parse(readFileSync5(path50, "utf-8"));
+    return JSON.parse(readFileSync5(path52, "utf-8"));
   } catch {
     return void 0;
   }
@@ -981,10 +981,10 @@ import { stringify as stringifyYaml } from "yaml";
 // src/shared/loadRawYaml.ts
 import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
 import { parse as parseYaml2 } from "yaml";
-function loadRawYaml(path50) {
-  if (!existsSync7(path50)) return {};
+function loadRawYaml(path52) {
+  if (!existsSync7(path52)) return {};
   try {
-    const content = readFileSync6(path50, "utf-8");
+    const content = readFileSync6(path52, "utf-8");
     return parseYaml2(content) || {};
   } catch {
     return {};
@@ -4955,9 +4955,9 @@ var __dirname4 = dirname15(__filename2);
 function packageRoot() {
   return __dirname4;
 }
-function readLines(path50) {
-  if (!existsSync20(path50)) return [];
-  return readFileSync16(path50, "utf-8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path52) {
+  if (!existsSync20(path52)) return [];
+  return readFileSync16(path52, "utf-8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -5390,14 +5390,14 @@ function showProgress(p, label2) {
   const pct = Math.round(p.done / p.total * 100);
   process.stderr.write(`\r\x1B[K[${pct}%] Scanning ${label2}...`);
 }
-async function resolveCommand(cli, path50, description, depth, p) {
-  showProgress(p, path50.join(" "));
-  const subHelp = await runHelp([cli, ...path50]);
+async function resolveCommand(cli, path52, description, depth, p) {
+  showProgress(p, path52.join(" "));
+  const subHelp = await runHelp([cli, ...path52]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path50, description }];
+    return [{ path: path52, description }];
   }
-  const children = await discoverAt(cli, path50, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path50, description }];
+  const children = await discoverAt(cli, path52, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path52, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -5545,9 +5545,9 @@ function logPath(cli) {
   return join19(homedir4(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path50 = logPath(cli);
-  if (!existsSync22(path50)) return void 0;
-  return readFileSync18(path50, "utf-8");
+  const path52 = logPath(cli);
+  if (!existsSync22(path52)) return void 0;
+  return readFileSync18(path52, "utf-8");
 }
 function writeCache(cli, output) {
   const dir = join19(homedir4(), ".assist");
@@ -6189,8 +6189,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path50, value) {
-  const keys = path50.split(".");
+function setNestedValue(obj, path52, value) {
+  const keys = path52.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -6270,9 +6270,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path50) {
+function getNestedValue(obj, path52) {
   let current = obj;
-  for (const key of path50.split(".")) current = stepInto(current, key);
+  for (const key of path52.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -7613,10 +7613,10 @@ function getStorePath(filename) {
   return join26(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path50 = getStorePath(filename);
-  if (existsSync29(path50)) {
+  const path52 = getStorePath(filename);
+  if (existsSync29(path52)) {
     try {
-      return JSON.parse(readFileSync25(path50, "utf-8"));
+      return JSON.parse(readFileSync25(path52, "utf-8"));
     } catch {
       return {};
     }
@@ -8009,7 +8009,7 @@ function validateLine(line) {
     process.exit(1);
   }
 }
-function comment2(path50, line, body) {
+function comment2(path52, line, body) {
   validateBody(body);
   validateLine(line);
   try {
@@ -8029,7 +8029,7 @@ function comment2(path50, line, body) {
           "-f",
           `body=${body}`,
           "-f",
-          `path=${path50}`,
+          `path=${path52}`,
           "-F",
           `line=${line}`
         ],
@@ -8038,7 +8038,7 @@ function comment2(path50, line, body) {
       if (result.status !== 0) {
         throw new Error(result.stderr || result.stdout);
       }
-      console.log(`Added review comment on ${path50}:${line}`);
+      console.log(`Added review comment on ${path52}:${line}`);
     } finally {
       unlinkSync6(queryFile);
     }
@@ -8537,8 +8537,8 @@ function registerPrs(program2) {
   prsCommand.command("wontfix <comment-id> <reason>").description("Reply with reason and resolve thread").action((commentId, reason) => {
     wontfix(Number.parseInt(commentId, 10), reason);
   });
-  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path50, line, body) => {
-    comment2(path50, Number.parseInt(line, 10), body);
+  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path52, line, body) => {
+    comment2(path52, Number.parseInt(line, 10), body);
   });
 }
 
@@ -8790,10 +8790,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path50) {
+async function ravenFetch(connection, path52) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path50}`;
+  const url = `${connection.url}${path52}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -8883,16 +8883,16 @@ import chalk111 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path50;
+  let path52;
   if (opts.collection) {
-    path50 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path52 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path50 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path52 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path50 += `&query=${encodeURIComponent(opts.query)}`;
+    path52 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path50;
+  return path52;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -8901,7 +8901,7 @@ async function fetchAllPages(connection, opts) {
   let start3 = 0;
   while (true) {
     const effectivePageSize = opts.limit !== void 0 ? Math.min(opts.pageSize, opts.limit - allResults.length) : opts.pageSize;
-    const path50 = buildQueryPath({
+    const path52 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -8909,7 +8909,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path50);
+    const data = await ravenFetch(connection, path52);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -10080,8 +10080,8 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename7 = path39.basename(file, path39.extname(file));
-    if (basename7 === "index") continue;
+    const basename8 = path39.basename(file, path39.extname(file));
+    if (basename8 === "index") continue;
     const importers = graph.importedBy.get(file);
     if (!importers || importers.size !== 1) continue;
     const parent = [...importers][0];
@@ -10531,8 +10531,8 @@ import chalk128 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
 import chalk125 from "chalk";
-async function fetchSeq(conn, path50, params) {
-  const url = `${conn.url}${path50}?${params}`;
+async function fetchSeq(conn, path52, params) {
+  const url = `${conn.url}${path52}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -12136,11 +12136,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path50 = process.argv[idx + 1];
+  const path52 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path50, prefix: prefix2 };
+  return { path: path52, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -12468,9 +12468,23 @@ function handleSocket(ws, manager) {
           data.rows
         );
         break;
+      case "resume": {
+        const id = manager.resume(
+          data.sessionId,
+          data.cwd,
+          data.name
+        );
+        ws.send(JSON.stringify({ type: "created", sessionId: id }));
+        break;
+      }
       case "dismiss":
         manager.dismissSession(data.sessionId);
         break;
+      case "history":
+        manager.getHistory().then((history) => {
+          ws.send(JSON.stringify({ type: "history", sessions: history }));
+        });
+        break;
     }
   });
   ws.on("close", () => {
@@ -12480,22 +12494,26 @@ function handleSocket(ws, manager) {
 
 // src/commands/sessions/web/spawnClaude.ts
 import * as pty from "node-pty";
-function spawnClaude2(prompt) {
+function spawnClaude2(opts = {}) {
   const shell = process.platform === "win32" ? "cmd.exe" : process.env.SHELL ?? "bash";
-  const args = buildArgs(prompt);
+  const args = buildArgs(opts);
   return pty.spawn(shell, args, {
     name: "xterm-256color",
     cols: 120,
     rows: 30,
-    cwd: process.cwd(),
+    cwd: opts.cwd ?? process.cwd(),
     env: { ...process.env }
   });
 }
-function buildArgs(prompt) {
+function buildArgs(opts) {
+  const claudeArgs = opts.resumeSessionId ? ["claude", "--resume", opts.resumeSessionId] : opts.prompt ? ["claude", opts.prompt] : ["claude"];
   if (process.platform === "win32") {
-    return prompt ? ["/c", "claude", prompt] : ["/c", "claude"];
+    return ["/c", ...claudeArgs];
   }
-  return prompt ? ["-c", 'exec claude "$0"', prompt] : ["-c", "claude"];
+  return ["-c", `exec ${claudeArgs.map(shellEscape).join(" ")}`];
+}
+function shellEscape(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
 }
 
 // src/commands/sessions/web/createSession.ts
@@ -12505,13 +12523,133 @@ function createSession(id, prompt) {
     name: prompt?.slice(0, 40) || `Session ${id}`,
     status: "running",
     startedAt: Date.now(),
-    pty: spawnClaude2(prompt),
+    pty: spawnClaude2({ prompt }),
+    scrollback: "",
+    idleTimer: null,
+    lastResizeAt: 0
+  };
+}
+function resumeSession(id, sessionId, cwd, name) {
+  return {
+    id,
+    name: name ? `${name.slice(0, 36)} (R)` : `Resume ${sessionId.slice(0, 8)}`,
+    status: "running",
+    startedAt: Date.now(),
+    pty: spawnClaude2({ resumeSessionId: sessionId, cwd }),
     scrollback: "",
     idleTimer: null,
     lastResizeAt: 0
   };
 }
 
+// src/commands/sessions/web/discoverSessions.ts
+import * as fs24 from "fs";
+import * as os from "os";
+import * as path47 from "path";
+
+// src/commands/sessions/web/parseSessionFile.ts
+import * as fs23 from "fs";
+import * as path46 from "path";
+
+// src/commands/sessions/web/extractSessionMeta.ts
+function extractSessionMeta(lines) {
+  let sessionId = "";
+  let cwd = "";
+  let timestamp = "";
+  let name = "";
+  for (const line of lines) {
+    const entry = safeParse(line);
+    if (!entry) continue;
+    sessionId ||= typeof entry.sessionId === "string" ? entry.sessionId : "";
+    timestamp ||= typeof entry.timestamp === "string" ? entry.timestamp : "";
+    cwd ||= typeof entry.cwd === "string" ? entry.cwd : "";
+    if (entry.type === "user" && !entry.isMeta) {
+      name = extractName(entry);
+      break;
+    }
+  }
+  return { sessionId, cwd, timestamp, name };
+}
+function safeParse(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function extractName(entry) {
+  const msg = entry.message;
+  const content = msg?.content;
+  const text = typeof content === "string" ? content : Array.isArray(content) ? content.find((c) => c.type === "text")?.text ?? "" : "";
+  return text.replace(/<command-[^>]*>[^<]*<\/command-[^>]*>/g, "").trim().slice(0, 80);
+}
+
+// src/commands/sessions/web/parseSessionFile.ts
+async function parseSessionFile(filePath) {
+  let handle;
+  try {
+    handle = await fs23.promises.open(filePath, "r");
+    const buf = Buffer.alloc(16384);
+    const { bytesRead } = await handle.read(buf, 0, buf.length, 0);
+    const lines = buf.toString("utf8", 0, bytesRead).split("\n").filter(Boolean);
+    const meta = extractSessionMeta(lines);
+    if (!meta.sessionId) return null;
+    const timestamp = meta.timestamp || (await fs23.promises.stat(filePath)).mtime.toISOString();
+    const project = meta.cwd ? path46.basename(meta.cwd) : dirNameToProject(filePath);
+    return {
+      sessionId: meta.sessionId,
+      name: meta.name || `Session ${meta.sessionId.slice(0, 8)}`,
+      project,
+      cwd: meta.cwd,
+      timestamp
+    };
+  } catch {
+    return null;
+  } finally {
+    await handle?.close();
+  }
+}
+function dirNameToProject(filePath) {
+  const dirName = path46.basename(path46.dirname(filePath));
+  const parts = dirName.split("--");
+  return parts[parts.length - 1].replace(/-/g, "/");
+}
+
+// src/commands/sessions/web/discoverSessions.ts
+async function discoverSessions() {
+  const projectsDir = path47.join(os.homedir(), ".claude", "projects");
+  let projectDirs;
+  try {
+    projectDirs = await fs24.promises.readdir(projectsDir);
+  } catch {
+    return [];
+  }
+  const sessions = [];
+  await Promise.all(
+    projectDirs.map(async (dirName) => {
+      const dirPath = path47.join(projectsDir, dirName);
+      let entries;
+      try {
+        entries = await fs24.promises.readdir(dirPath);
+      } catch {
+        return;
+      }
+      const jsonlFiles = entries.filter((e) => e.endsWith(".jsonl"));
+      await Promise.all(
+        jsonlFiles.map(async (file) => {
+          const filePath = path47.join(dirPath, file);
+          const session = await parseSessionFile(filePath);
+          if (session) sessions.push(session);
+        })
+      );
+    })
+  );
+  sessions.sort(
+    (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+  );
+  return sessions;
+}
+
 // src/commands/sessions/web/scheduleIdle.ts
 var IDLE_MS = 3e3;
 function scheduleIdle(session, onIdle) {
@@ -12580,7 +12718,17 @@ var SessionManager = class {
   spawn(prompt) {
     const id = String(this.nextId++);
     const session = createSession(id, prompt);
-    this.sessions.set(id, session);
+    this.wire(session);
+    return id;
+  }
+  resume(sessionId, cwd, name) {
+    const id = String(this.nextId++);
+    const session = resumeSession(id, sessionId, cwd, name);
+    this.wire(session);
+    return id;
+  }
+  wire(session) {
+    this.sessions.set(session.id, session);
     wirePtyEvents(session, this.clients, (s, status2) => {
       s.status = status2;
       this.notify();
@@ -12590,7 +12738,6 @@ var SessionManager = class {
       this.notify();
     });
     this.notify();
-    return id;
   }
   writeToSession(id, data) {
     const s = this.sessions.get(id);
@@ -12621,6 +12768,9 @@ var SessionManager = class {
       })
     );
   }
+  async getHistory() {
+    return discoverSessions();
+  }
   notify() {
     wsBroadcast(this.clients, {
       type: "sessions",
@@ -12730,21 +12880,21 @@ async function statusLine() {
 }
 
 // src/commands/sync.ts
-import * as fs25 from "fs";
-import * as os from "os";
-import * as path48 from "path";
+import * as fs27 from "fs";
+import * as os2 from "os";
+import * as path50 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
-import * as fs23 from "fs";
-import * as path46 from "path";
+import * as fs25 from "fs";
+import * as path48 from "path";
 import chalk135 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
-  const source = path46.join(claudeDir, "CLAUDE.md");
-  const target = path46.join(targetBase, "CLAUDE.md");
-  const sourceContent = fs23.readFileSync(source, "utf-8");
-  if (fs23.existsSync(target)) {
-    const targetContent = fs23.readFileSync(target, "utf-8");
+  const source = path48.join(claudeDir, "CLAUDE.md");
+  const target = path48.join(targetBase, "CLAUDE.md");
+  const sourceContent = fs25.readFileSync(source, "utf-8");
+  if (fs25.existsSync(target)) {
+    const targetContent = fs25.readFileSync(target, "utf-8");
     if (sourceContent !== targetContent) {
       console.log(
         chalk135.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
@@ -12761,21 +12911,21 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs23.copyFileSync(source, target);
+  fs25.copyFileSync(source, target);
   console.log("Copied CLAUDE.md to ~/.claude/CLAUDE.md");
 }
 
 // src/commands/sync/syncSettings.ts
-import * as fs24 from "fs";
-import * as path47 from "path";
+import * as fs26 from "fs";
+import * as path49 from "path";
 import chalk136 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path47.join(claudeDir, "settings.json");
-  const target = path47.join(targetBase, "settings.json");
-  const sourceContent = fs24.readFileSync(source, "utf-8");
+  const source = path49.join(claudeDir, "settings.json");
+  const target = path49.join(targetBase, "settings.json");
+  const sourceContent = fs26.readFileSync(source, "utf-8");
   const mergedContent = JSON.stringify(JSON.parse(sourceContent), null, "	");
-  if (fs24.existsSync(target)) {
-    const targetContent = fs24.readFileSync(target, "utf-8");
+  if (fs26.existsSync(target)) {
+    const targetContent = fs26.readFileSync(target, "utf-8");
     const normalizedTarget = JSON.stringify(
       JSON.parse(targetContent),
       null,
@@ -12801,29 +12951,29 @@ async function syncSettings(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs24.writeFileSync(target, mergedContent);
+  fs26.writeFileSync(target, mergedContent);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
 // src/commands/sync.ts
 var __filename4 = fileURLToPath7(import.meta.url);
-var __dirname7 = path48.dirname(__filename4);
+var __dirname7 = path50.dirname(__filename4);
 async function sync(options2) {
   const config = loadConfig();
   const yes = options2?.yes ?? config.sync.autoConfirm;
-  const claudeDir = path48.join(__dirname7, "..", "claude");
-  const targetBase = path48.join(os.homedir(), ".claude");
+  const claudeDir = path50.join(__dirname7, "..", "claude");
+  const targetBase = path50.join(os2.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes });
   await syncClaudeMd(claudeDir, targetBase, { yes });
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path48.join(claudeDir, "commands");
-  const targetDir = path48.join(targetBase, "commands");
-  fs25.mkdirSync(targetDir, { recursive: true });
-  const files = fs25.readdirSync(sourceDir);
+  const sourceDir = path50.join(claudeDir, "commands");
+  const targetDir = path50.join(targetBase, "commands");
+  fs27.mkdirSync(targetDir, { recursive: true });
+  const files = fs27.readdirSync(sourceDir);
   for (const file of files) {
-    fs25.copyFileSync(path48.join(sourceDir, file), path48.join(targetDir, file));
+    fs27.copyFileSync(path50.join(sourceDir, file), path50.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -12831,15 +12981,15 @@ function syncCommands(claudeDir, targetBase) {
 
 // src/commands/update.ts
 import { execSync as execSync42 } from "child_process";
-import * as path49 from "path";
+import * as path51 from "path";
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path49.resolve(dir);
-    if (resolved.split(path49.sep).includes("node_modules")) {
+    const resolved = path51.resolve(dir);
+    if (resolved.split(path51.sep).includes("node_modules")) {
       return true;
     }
     const globalPrefix = execSync42("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path49.resolve(globalPrefix).toLowerCase());
+    return resolved.toLowerCase().startsWith(path51.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@staff0rd/assist",
-	"version": "0.192.0",
+	"version": "0.193.0",
 	"type": "module",
 	"main": "dist/index.js",
 	"bin": {