jinzd-ai-cli 0.4.233 → 0.4.235

package/dist/{chunk-LF3OUJHK.js → chunk-UO3XWZFE.js}

@@ -128,6 +128,293 @@ function scanString(input, options) {
   return hits;
 }
 
+// src/session/session-index.ts
+import { existsSync, readFileSync as readFileSync2, readdirSync, statSync } from "fs";
+import { join } from "path";
+
+// src/session/session-meta.ts
+import { readFileSync, openSync, readSync, closeSync } from "fs";
+function safeDate(value) {
+  const d = new Date(value);
+  return isNaN(d.getTime()) ? /* @__PURE__ */ new Date(0) : d;
+}
+function extractJsonField(header, field) {
+  const re = new RegExp(`"${field}"\\s*:\\s*"([^"]*)"`, "i");
+  const m = header.match(re);
+  return m ? m[1] : void 0;
+}
+function extractJsonNumberField(header, field) {
+  const m = header.match(new RegExp(`"${field}"\\s*:\\s*(\\d+)`));
+  return m ? Number(m[1]) : void 0;
+}
+function readSessionMeta(filePath) {
+  const HEADER_SIZE = 1024;
+  let header;
+  try {
+    const fd = openSync(filePath, "r");
+    const buf = Buffer.alloc(HEADER_SIZE);
+    const bytesRead = readSync(fd, buf, 0, HEADER_SIZE, 0);
+    closeSync(fd);
+    header = buf.toString("utf-8", 0, bytesRead);
+  } catch {
+    return null;
+  }
+  const id = extractJsonField(header, "id");
+  const provider = extractJsonField(header, "provider");
+  const model = extractJsonField(header, "model");
+  const created = extractJsonField(header, "created");
+  const updated = extractJsonField(header, "updated");
+  const title = extractJsonField(header, "title");
+  if (id && provider && model) {
+    let messageCount = extractJsonNumberField(header, "messageCount");
+    if (messageCount === void 0) {
+      messageCount = 0;
+      try {
+        const full = readFileSync(filePath, "utf-8");
+        const matches = full.match(/"role"\s*:/g);
+        messageCount = matches ? matches.length : 0;
+      } catch {
+      }
+    }
+    let branchCount;
+    let activeBranch;
+    try {
+      const brMatch = header.match(/"branches"\s*:\s*\[/);
+      if (brMatch) {
+        const parentMatches = header.match(/"parentBranchId"/g);
+        branchCount = parentMatches ? parentMatches.length + 1 : 1;
+      }
+      activeBranch = extractJsonField(header, "activeBranchId");
+    } catch {
+    }
+    return {
+      id,
+      provider,
+      model,
+      messageCount,
+      created: safeDate(created),
+      updated: safeDate(updated),
+      title: title || void 0,
+      branchCount,
+      activeBranch
+    };
+  }
+  const data = JSON.parse(readFileSync(filePath, "utf-8"));
+  return {
+    id: data.id,
+    provider: data.provider,
+    model: data.model,
+    messageCount: data.messages?.length ?? 0,
+    created: safeDate(data.created),
+    updated: safeDate(data.updated),
+    title: data.title,
+    branchCount: data.branches?.length ?? 1,
+    activeBranch: data.activeBranchId
+  };
+}
+
+// src/session/session-index.ts
+var INDEX_FILE = "sessions.index.json";
+function indexFilePath(historyDir2) {
+  return join(historyDir2, INDEX_FILE);
+}
+function loadIndex(historyDir2) {
+  const fp = indexFilePath(historyDir2);
+  if (!existsSync(fp)) return null;
+  try {
+    const data = JSON.parse(readFileSync2(fp, "utf-8"));
+    if (data?.version === 1 && data.sessions && data.invertedIndex) {
+      return data;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function saveIndex(historyDir2, idx) {
+  idx.built = (/* @__PURE__ */ new Date()).toISOString();
+  const fp = indexFilePath(historyDir2);
+  atomicWriteFileSync(fp, JSON.stringify(idx));
+}
+function rebuildIndex(historyDir2) {
+  if (!existsSync(historyDir2)) {
+    const empty = { version: 1, built: (/* @__PURE__ */ new Date()).toISOString(), sessions: {}, invertedIndex: {} };
+    return empty;
+  }
+  const files = readdirSync(historyDir2).filter((f) => f.endsWith(".json"));
+  const sessions = {};
+  const invertedIndex = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const filePath = join(historyDir2, file);
+    const meta = readSessionMeta(filePath);
+    if (!meta) continue;
+    let fileSize = 0;
+    try {
+      fileSize = statSync(filePath).size;
+    } catch {
+    }
+    let mtimeMs = 0;
+    try {
+      mtimeMs = statSync(filePath).mtimeMs;
+    } catch {
+    }
+    const entry = {
+      id: meta.id,
+      provider: meta.provider,
+      model: meta.model,
+      title: meta.title,
+      messageCount: meta.messageCount,
+      fileSize,
+      created: meta.created.toISOString(),
+      updated: meta.updated.toISOString(),
+      branchCount: meta.branchCount,
+      activeBranch: meta.activeBranch,
+      _mtimeMs: mtimeMs
+    };
+    sessions[meta.id] = entry;
+    addTokensToIndex(invertedIndex, meta.title ?? "", meta.id);
+  }
+  const serializedIndex = {};
+  for (const [token, ids] of invertedIndex) {
+    serializedIndex[token] = [...ids];
+  }
+  const idx = {
+    version: 1,
+    built: (/* @__PURE__ */ new Date()).toISOString(),
+    sessions,
+    invertedIndex: serializedIndex
+  };
+  saveIndex(historyDir2, idx);
+  return idx;
+}
+function updateSessionInIndex(historyDir2, meta, filePath) {
+  let idx = loadIndex(historyDir2);
+  if (!idx) {
+    rebuildIndex(historyDir2);
+    return;
+  }
+  let fileSize = 0;
+  try {
+    fileSize = statSync(filePath).size;
+  } catch {
+  }
+  let mtimeMs = 0;
+  try {
+    mtimeMs = statSync(filePath).mtimeMs;
+  } catch {
+  }
+  const id = meta.id;
+  for (const [token, ids] of Object.entries(idx.invertedIndex)) {
+    const filtered = ids.filter((sid) => sid !== id);
+    if (filtered.length === 0) {
+      delete idx.invertedIndex[token];
+    } else {
+      idx.invertedIndex[token] = filtered;
+    }
+  }
+  idx.sessions[id] = {
+    id,
+    provider: meta.provider,
+    model: meta.model,
+    title: meta.title,
+    messageCount: meta.messageCount,
+    fileSize,
+    created: meta.created.toISOString(),
+    updated: meta.updated.toISOString(),
+    _mtimeMs: mtimeMs
+  };
+  const tokens = tokenize(meta.title ?? "");
+  for (const token of tokens) {
+    const existing = idx.invertedIndex[token] ?? [];
+    if (!existing.includes(id)) {
+      existing.push(id);
+      idx.invertedIndex[token] = existing;
+    }
+  }
+  saveIndex(historyDir2, idx);
+}
+function removeSessionFromIndex(historyDir2, id) {
+  const idx = loadIndex(historyDir2);
+  if (!idx) return;
+  delete idx.sessions[id];
+  for (const [token, ids] of Object.entries(idx.invertedIndex)) {
+    const filtered = ids.filter((sid) => sid !== id);
+    if (filtered.length === 0) {
+      delete idx.invertedIndex[token];
+    } else {
+      idx.invertedIndex[token] = filtered;
+    }
+  }
+  saveIndex(historyDir2, idx);
+}
+function listFromIndex(historyDir2, opts) {
+  let idx = loadIndex(historyDir2);
+  if (!idx) {
+    idx = rebuildIndex(historyDir2);
+  }
+  return Object.values(idx.sessions).map((entry) => ({
+    id: entry.id,
+    provider: entry.provider,
+    model: entry.model,
+    title: entry.title,
+    messageCount: entry.messageCount,
+    created: new Date(entry.created),
+    updated: new Date(entry.updated),
+    fileSize: opts?.includeFileSize ? entry.fileSize : void 0,
+    branchCount: entry.branchCount,
+    activeBranch: entry.activeBranch
+  })).sort((a, b) => b.updated.getTime() - a.updated.getTime());
+}
+function searchCandidates(historyDir2, query) {
+  const idx = loadIndex(historyDir2);
+  if (!idx) return null;
+  const queryTokens = tokenize(query.toLowerCase());
+  if (queryTokens.length === 0) return null;
+  const scoreMap = /* @__PURE__ */ new Map();
+  for (const token of queryTokens) {
+    const matchingIds = idx.invertedIndex[token];
+    if (!matchingIds) continue;
+    for (const sid of matchingIds) {
+      scoreMap.set(sid, (scoreMap.get(sid) ?? 0) + 1);
+    }
+  }
+  const candidates = [...scoreMap.entries()].filter(([, score]) => score > 0).sort((a, b) => {
+    const scoreDiff = b[1] - a[1];
+    if (scoreDiff !== 0) return scoreDiff;
+    const aMeta = idx.sessions[a[0]];
+    const bMeta = idx.sessions[b[0]];
+    return (bMeta?.updated ?? "").localeCompare(aMeta?.updated ?? "");
+  }).map(([sid]) => sid);
+  return candidates.length > 0 ? candidates : null;
+}
+function getIndexMtimeMap(historyDir2) {
+  const idx = loadIndex(historyDir2);
+  if (!idx) return null;
+  const map = {};
+  for (const entry of Object.values(idx.sessions)) {
+    map[entry.id] = entry._mtimeMs;
+  }
+  return map;
+}
+function addTokensToIndex(invertedIndex, text, sessionId) {
+  for (const token of tokenize(text)) {
+    const s = invertedIndex.get(token) ?? /* @__PURE__ */ new Set();
+    s.add(sessionId);
+    invertedIndex.set(token, s);
+  }
+}
+function tokenize(text) {
+  const tokens = /* @__PURE__ */ new Set();
+  const cjkOnly = text.replace(/[^\u4e00-\u9fff\u3400-\u4dbf]/g, "");
+  for (let i = 0; i < cjkOnly.length - 1; i++) {
+    tokens.add(cjkOnly.slice(i, i + 2));
+  }
+  const english = text.replace(/[\u4e00-\u9fff\u3400-\u4dbf]/g, " ").toLowerCase();
+  const words = english.split(/[^a-z0-9]+/).filter((w) => w.length >= 2);
+  for (const w of words) tokens.add(w);
+  return [...tokens];
+}
+
 // src/memory/chat-index.ts
 var MEMORY_DIR_NAME = "memory-index";
 var CHUNKS_FILE = "chunks.json";
@@ -285,14 +572,19 @@ function listSessionFiles() {
   const dir = historyDir();
   if (!fs.existsSync(dir)) return [];
   const out = [];
+  const indexMtimes = getIndexMtimeMap(dir);
   for (const name of fs.readdirSync(dir)) {
     if (!name.endsWith(".json")) continue;
     const id = name.replace(/\.json$/, "");
     const p = path.join(dir, name);
-    try {
-      const st = fs.statSync(p);
-      out.push({ id, path: p, mtime: st.mtimeMs });
-    } catch {
+    if (indexMtimes && indexMtimes[id] !== void 0) {
+      out.push({ id, path: p, mtime: indexMtimes[id] });
+    } else {
+      try {
+        const st = fs.statSync(p);
+        out.push({ id, path: p, mtime: st.mtimeMs });
+      } catch {
+      }
     }
   }
   return out;
@@ -461,6 +753,12 @@ export {
   redactString,
   redactJson,
   scanString,
+  safeDate,
+  readSessionMeta,
+  updateSessionInIndex,
+  removeSessionFromIndex,
+  listFromIndex,
+  searchCandidates,
   chunkSession,
   loadChatIndex,
   clearChatIndex,

package/dist/{chunk-TJK7AU65.js → chunk-WXFQ6LYN.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   VERSION
-} from "./chunk-ACTO5C6K.js";
+} from "./chunk-GDXKFWFL.js";
 
 // src/cli/ci-format.ts
 var DEFAULT_CI_THRESHOLDS = {

package/dist/{ci-V5V3JSJC.js → ci-OAFNH3MA.js}

@@ -3,14 +3,14 @@ import {
   CI_COMMENT_MARKER,
   countSeverity,
   runCi
-} from "./chunk-FQSAK75P.js";
-import "./chunk-TJK7AU65.js";
+} from "./chunk-CDOQNIVV.js";
+import "./chunk-WXFQ6LYN.js";
 import "./chunk-HLWUDRBO.js";
 import "./chunk-QYQI7ZWK.js";
 import "./chunk-O3XSFPYH.js";
-import "./chunk-5PKNKJYP.js";
+import "./chunk-BFTTW5LS.js";
 import "./chunk-5ULLIOVC.js";
-import "./chunk-ACTO5C6K.js";
+import "./chunk-GDXKFWFL.js";
 import "./chunk-IW3Q7AE5.js";
 export {
   CI_COMMENT_MARKER,

package/dist/{ci-format-XS7LKBO5.js → ci-format-4LSXJNND.js}

@@ -6,8 +6,8 @@ import {
   formatCiResult,
   formatCiSarif,
   normalizeCiThresholds
-} from "./chunk-TJK7AU65.js";
-import "./chunk-ACTO5C6K.js";
+} from "./chunk-WXFQ6LYN.js";
+import "./chunk-GDXKFWFL.js";
 export {
   DEFAULT_CI_THRESHOLDS,
   detectCiGateSignals,

package/dist/{constants-UROQJXLY.js → constants-ERIAS7GV.js}

@@ -38,7 +38,7 @@ import {
   TEST_TIMEOUT,
   VERSION,
   buildUserIdentityPrompt
-} from "./chunk-ACTO5C6K.js";
+} from "./chunk-GDXKFWFL.js";
 export {
   AGENTIC_BEHAVIOR_GUIDELINE,
   APP_NAME,

package/dist/{doctor-cli-BY3FIV2B.js → doctor-cli-VFSVWZU6.js}

@@ -2,14 +2,14 @@
 import {
   formatDoctorReport,
   runDoctorCli
-} from "./chunk-NXYXFRPA.js";
+} from "./chunk-7D5EJBHO.js";
 import "./chunk-QYQI7ZWK.js";
-import "./chunk-EZGZOK6E.js";
+import "./chunk-GFDRC2JZ.js";
 import "./chunk-O3XSFPYH.js";
-import "./chunk-5PKNKJYP.js";
+import "./chunk-BFTTW5LS.js";
 import "./chunk-5ULLIOVC.js";
 import "./chunk-HOSJZMQS.js";
-import "./chunk-ACTO5C6K.js";
+import "./chunk-GDXKFWFL.js";
 import "./chunk-IW3Q7AE5.js";
 export {
   formatDoctorReport,