jinzd-ai-cli 0.4.241 → 0.4.243

package/dist/chunk-PNNZRJ67.js

@@ -0,0 +1,523 @@
+import {
+  DEFAULT_PATTERNS,
+  redactString
+} from "./chunk-YVTASHS5.js";
+import {
+  MEMORY_FILE_NAME,
+  MEMORY_MAX_CHARS,
+  MEMORY_STORE_FILE_NAME
+} from "./chunk-GEWPLNKA.js";
+import {
+  atomicWriteFileSync
+} from "./chunk-6BUTA5VW.js";
+
+// src/memory/persistent-memory.ts
+import { copyFileSync, existsSync as existsSync2, mkdirSync, readFileSync, statSync } from "fs";
+import { randomUUID, createHash } from "crypto";
+import { dirname, join as join2, resolve } from "path";
+
+// src/tools/git-context.ts
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+function runGit(cmd, cwd) {
+  try {
+    return execSync(`git ${cmd}`, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5e3
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function getGitRoot(cwd = process.cwd()) {
+  return runGit("rev-parse --show-toplevel", cwd);
+}
+function getGitContext(cwd = process.cwd()) {
+  if (!existsSync(join(cwd, ".git"))) {
+    const result = runGit("rev-parse --git-dir", cwd);
+    if (!result) return null;
+  }
+  const branch = runGit("rev-parse --abbrev-ref HEAD", cwd);
+  if (!branch) return null;
+  const statusOutput = runGit("status --porcelain", cwd) ?? "";
+  const statusLines = statusOutput ? statusOutput.split("\n").filter(Boolean) : [];
+  const stagedFiles = [];
+  const changedFiles = [];
+  for (const line of statusLines) {
+    const xy = line.slice(0, 2);
+    const file = line.slice(3).trim();
+    const indexStatus = xy[0];
+    const workStatus = xy[1];
+    if (indexStatus && indexStatus !== " " && indexStatus !== "?") {
+      stagedFiles.push(`${indexStatus} ${file}`);
+    }
+    if (workStatus && workStatus !== " ") {
+      changedFiles.push(`${workStatus} ${file}`);
+    }
+  }
+  const logOutput = runGit("log --oneline -3", cwd) ?? "";
+  const recentCommits = logOutput ? logOutput.split("\n").filter(Boolean) : [];
+  const unpushedOutput = runGit("log @{u}..HEAD --oneline", cwd);
+  const hasUnpushed = unpushedOutput !== null && unpushedOutput.trim().length > 0;
+  return {
+    branch,
+    changedFiles,
+    stagedFiles,
+    recentCommits,
+    hasUnpushed
+  };
+}
+function formatGitContextForPrompt(ctx) {
+  const lines = ["# Git Repository Status", ""];
+  lines.push(`- **Branch**: \`${ctx.branch}\``);
+  if (ctx.stagedFiles.length > 0) {
+    lines.push(`- **Staged** (${ctx.stagedFiles.length} files):`);
+    for (const f of ctx.stagedFiles.slice(0, 10)) {
+      lines.push(`  - ${f}`);
+    }
+    if (ctx.stagedFiles.length > 10) {
+      lines.push(`  - ... and ${ctx.stagedFiles.length - 10} more`);
+    }
+  }
+  if (ctx.changedFiles.length > 0) {
+    lines.push(`- **Modified** (${ctx.changedFiles.length} files):`);
+    for (const f of ctx.changedFiles.slice(0, 10)) {
+      lines.push(`  - ${f}`);
+    }
+    if (ctx.changedFiles.length > 10) {
+      lines.push(`  - ... and ${ctx.changedFiles.length - 10} more`);
+    }
+  }
+  if (ctx.stagedFiles.length === 0 && ctx.changedFiles.length === 0) {
+    lines.push("- **Working tree**: clean");
+  }
+  if (ctx.recentCommits.length > 0) {
+    lines.push("- **Recent commits**:");
+    for (const c of ctx.recentCommits) {
+      lines.push(`  - ${c}`);
+    }
+  }
+  if (ctx.hasUnpushed) {
+    lines.push("- \u26A0\uFE0F Has unpushed commits");
+  }
+  return lines.join("\n");
+}
+
+// src/memory/persistent-memory.ts
+function parseWritableScope(value) {
+  return value === "personal" || value === "project" ? value : void 0;
+}
+function memoryStorePath(configDir) {
+  return join2(configDir, MEMORY_STORE_FILE_NAME);
+}
+function memoryMarkdownPath(configDir) {
+  return join2(configDir, MEMORY_FILE_NAME);
+}
+function getProjectKey(cwd = process.cwd()) {
+  return resolve(getGitRoot(cwd) ?? cwd);
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function isValidScope(value) {
+  return value === "personal" || value === "project" || value === "session" || value === "team";
+}
+function isValidSensitivity(value) {
+  return value === "low" || value === "medium" || value === "high";
+}
+function isValidSource(value) {
+  return value === "tool" || value === "manual";
+}
+function normalizeEntry(value) {
+  if (!value || typeof value !== "object") return null;
+  const raw = value;
+  const content = typeof raw.content === "string" ? raw.content.trim() : "";
+  if (!content) return null;
+  const createdAt = typeof raw.createdAt === "string" ? raw.createdAt : nowIso();
+  return {
+    id: typeof raw.id === "string" && raw.id ? raw.id : randomUUID(),
+    content,
+    scope: isValidScope(raw.scope) ? raw.scope : "personal",
+    source: isValidSource(raw.source) ? raw.source : void 0,
+    sourceSession: typeof raw.sourceSession === "string" && raw.sourceSession ? raw.sourceSession : void 0,
+    sourceProject: typeof raw.sourceProject === "string" && raw.sourceProject ? raw.sourceProject : void 0,
+    createdAt,
+    updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : createdAt,
+    expiresAt: typeof raw.expiresAt === "string" && raw.expiresAt ? raw.expiresAt : void 0,
+    lastReferencedAt: typeof raw.lastReferencedAt === "string" && raw.lastReferencedAt ? raw.lastReferencedAt : void 0,
+    sensitivity: isValidSensitivity(raw.sensitivity) ? raw.sensitivity : "low",
+    approved: raw.approved === true,
+    redactedKinds: Array.isArray(raw.redactedKinds) ? raw.redactedKinds.filter((x) => typeof x === "string") : void 0
+  };
+}
+function legacyEntriesFromMarkdown(configDir) {
+  const file = memoryMarkdownPath(configDir);
+  if (!existsSync2(file)) return [];
+  const content = readFileSync(file, "utf-8").trim();
+  if (!content) return [];
+  const parts = content.split(/\n(?=##\s+\d{4}-\d{2}-\d{2})/g);
+  const chunks = parts.length > 1 ? parts : [content];
+  return chunks.map((chunk, index) => {
+    const match = chunk.match(/^##\s+([^\n]+)\n([\s\S]*)$/);
+    const body = (match ? match[2] : chunk).trim();
+    const parsed = match ? Date.parse(match[1].replace(" ", "T")) : NaN;
+    const createdAt = Number.isFinite(parsed) ? new Date(parsed).toISOString() : nowIso();
+    const id = "legacy-" + createHash("sha1").update(`${index}
+${chunk}`).digest("hex").slice(0, 12);
+    return normalizeEntry({ id, content: body, scope: "personal", createdAt, updatedAt: createdAt, sensitivity: "low", approved: true });
+  }).filter((entry) => Boolean(entry));
+}
+function loadMemoryEntries(configDir) {
+  const file = memoryStorePath(configDir);
+  if (!existsSync2(file)) return legacyEntriesFromMarkdown(configDir);
+  const text = readFileSync(file, "utf-8").trim();
+  if (!text) return [];
+  const entries = [];
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const entry = normalizeEntry(JSON.parse(trimmed));
+      if (entry) entries.push(entry);
+    } catch {
+    }
+  }
+  return entries;
+}
+function saveMemoryEntries(configDir, entries) {
+  mkdirSync(configDir, { recursive: true });
+  const jsonl = entries.map((entry) => JSON.stringify(entry)).join("\n");
+  atomicWriteFileSync(memoryStorePath(configDir), jsonl ? jsonl + "\n" : "");
+}
+function isMemoryExpired(entry, at = /* @__PURE__ */ new Date()) {
+  return Boolean(entry.expiresAt && Date.parse(entry.expiresAt) <= at.getTime());
+}
+function isMemoryVisibleInProject(entry, cwd = process.cwd()) {
+  if (entry.scope !== "project") return true;
+  return entry.sourceProject === getProjectKey(cwd);
+}
+function listMemoryEntries(configDir, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  return loadMemoryEntries(configDir).filter((entry) => options.includeRejected || entry.approved).filter((entry) => options.includeExpired || !isMemoryExpired(entry)).filter((entry) => isMemoryVisibleInProject(entry, cwd));
+}
+function addMemoryEntry(configDir, content, options = {}) {
+  const original = content.trim();
+  if (!original) throw new Error("memory content is required");
+  const redact = options.redact ?? true;
+  const redacted = redact ? redactString(original, { enabled: true, patterns: options.patterns ?? DEFAULT_PATTERNS, customRegexes: options.customPatterns }) : { redacted: original, hits: [] };
+  const sensitivity = options.sensitivity ?? (redacted.hits.length > 0 ? "high" : "low");
+  const approved = options.approved ?? (sensitivity === "low" && redacted.hits.length === 0 && options.source !== "tool");
+  const scope = options.scope ?? "personal";
+  const timestamp = nowIso();
+  const entry = {
+    id: randomUUID(),
+    content: redacted.redacted.trim(),
+    scope,
+    source: options.source,
+    sourceSession: options.sourceSession,
+    sourceProject: scope === "project" ? getProjectKey(options.cwd) : void 0,
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    expiresAt: options.expiresAt,
+    sensitivity,
+    approved,
+    redactedKinds: [...new Set(redacted.hits.map((hit) => hit.kind))]
+  };
+  const entries = loadMemoryEntries(configDir);
+  entries.push(entry);
+  saveMemoryEntries(configDir, entries);
+  return entry;
+}
+function updateMemoryEntry(configDir, idPrefix, newContent, options = {}) {
+  const content = newContent.trim();
+  if (!content) throw new Error("memory content is required");
+  const entries = loadMemoryEntries(configDir);
+  const entry = findUnique(entries, idPrefix);
+  const redact = options.redact ?? true;
+  const redacted = redact ? redactString(content, { enabled: true, patterns: options.patterns ?? DEFAULT_PATTERNS, customRegexes: options.customPatterns }) : { redacted: content, hits: [] };
+  entry.content = redacted.redacted.trim();
+  entry.updatedAt = nowIso();
+  entry.redactedKinds = [...new Set(redacted.hits.map((hit) => hit.kind))];
+  if (redacted.hits.length > 0) {
+    entry.sensitivity = "high";
+    entry.approved = false;
+  } else if (options.source === "tool") {
+    entry.approved = false;
+  }
+  saveMemoryEntries(configDir, entries);
+  return entry;
+}
+function updateMemoryApproval(configDir, idPrefix, approved) {
+  const entries = loadMemoryEntries(configDir);
+  const entry = findUnique(entries, idPrefix);
+  entry.approved = approved;
+  entry.updatedAt = nowIso();
+  saveMemoryEntries(configDir, entries);
+  return entry;
+}
+function deleteMemoryEntry(configDir, idPrefix) {
+  const entries = loadMemoryEntries(configDir);
+  const entry = findUnique(entries, idPrefix);
+  saveMemoryEntries(configDir, entries.filter((candidate) => candidate.id !== entry.id));
+  return entry;
+}
+function expireMemoryEntry(configDir, idPrefix, expiresAt = nowIso()) {
+  const entries = loadMemoryEntries(configDir);
+  const entry = findUnique(entries, idPrefix);
+  entry.expiresAt = expiresAt;
+  entry.updatedAt = nowIso();
+  saveMemoryEntries(configDir, entries);
+  return entry;
+}
+function countPendingMemories(configDir) {
+  return loadMemoryEntries(configDir).filter((entry) => !entry.approved && !isMemoryExpired(entry)).length;
+}
+function clearMemoryEntries(configDir) {
+  const entries = loadMemoryEntries(configDir);
+  const storePath = memoryStorePath(configDir);
+  let backupPath = null;
+  if (entries.length > 0) {
+    const sourceFile = existsSync2(storePath) ? storePath : memoryMarkdownPath(configDir);
+    if (existsSync2(sourceFile)) {
+      backupPath = `${sourceFile}.bak.${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+      copyFileSync(sourceFile, backupPath);
+    }
+  }
+  mkdirSync(configDir, { recursive: true });
+  atomicWriteFileSync(storePath, "");
+  atomicWriteFileSync(memoryMarkdownPath(configDir), "");
+  return { backupPath, cleared: entries.length };
+}
+function exportMemoryEntries(configDir, cwd = process.cwd(), format = "json") {
+  if (format === "md") {
+    const active = listMemoryEntries(configDir, { cwd }).filter((entry) => entry.approved && !isMemoryExpired(entry));
+    return renderMemoryMarkdown(active);
+  }
+  return JSON.stringify(listMemoryEntries(configDir, { cwd, includeExpired: true, includeRejected: true }), null, 2);
+}
+function findUnique(entries, idPrefix) {
+  const matches = entries.filter((entry) => entry.id.startsWith(idPrefix));
+  if (matches.length === 0) throw new Error(`memory id not found: ${idPrefix}`);
+  if (matches.length > 1) throw new Error(`memory id is ambiguous: ${idPrefix}`);
+  return matches[0];
+}
+function renderMemoryMarkdown(entries) {
+  return entries.map((entry) => {
+    const date = entry.createdAt.replace("T", " ").slice(0, 19);
+    const source = [
+      `id:${entry.id.slice(0, 8)}`,
+      `scope:${entry.scope}`,
+      entry.source ? `source:${entry.source}` : "",
+      entry.sourceSession ? `session:${entry.sourceSession.slice(0, 8)}` : "",
+      entry.sourceProject ? `project:${entry.sourceProject}` : "",
+      `sensitivity:${entry.sensitivity}`
+    ].filter(Boolean).join(" \xB7 ");
+    return `## ${date}
+<!-- ${source} -->
+${entry.content}
+`;
+  }).join("\n");
+}
+function syncLegacyMarkdown(configDir, entries = loadMemoryEntries(configDir)) {
+  mkdirSync(dirname(memoryMarkdownPath(configDir)), { recursive: true });
+  const active = entries.filter((entry) => entry.approved && !isMemoryExpired(entry));
+  atomicWriteFileSync(memoryMarkdownPath(configDir), renderMemoryMarkdown(active));
+}
+function formatMemoryForPrompt(configDir, cwd = process.cwd(), maxChars = MEMORY_MAX_CHARS) {
+  const entries = listMemoryEntries(configDir, { cwd }).filter((entry) => entry.approved && !isMemoryExpired(entry));
+  if (entries.length === 0) return null;
+  let content = entries.map((entry) => {
+    const meta = [
+      `id ${entry.id.slice(0, 8)}`,
+      entry.scope,
+      entry.source ?? "unknown",
+      entry.createdAt.slice(0, 10)
+    ].join(" \xB7 ");
+    return `## ${meta}
+${entry.content}`;
+  }).join("\n\n");
+  let entryCount = entries.length;
+  let truncated = false;
+  if (content.length > maxChars) {
+    truncated = true;
+    content = content.slice(-maxChars);
+    const firstEntry = content.indexOf("\n## ");
+    if (firstEntry !== -1) content = content.slice(firstEntry + 1);
+    entryCount = Math.max(1, (content.match(/^## /gm) ?? []).length);
+    content = `(Note: persistent memory exceeded the ${maxChars}-char budget \u2014 showing the newest ${entryCount} of ${entries.length} entries; older entries were dropped. The user can prune with /memory show and /memory delete <id>.)
+
+` + content;
+  }
+  return { content, entryCount, totalCount: entries.length, truncated };
+}
+function findSimilarMemory(entries, content) {
+  const normalize = (s) => s.toLowerCase().replace(/\s+/g, " ").trim();
+  const target = normalize(content);
+  if (target.length < 8) return null;
+  for (const entry of entries) {
+    const existing = normalize(entry.content);
+    if (existing === target || existing.includes(target) || target.includes(existing)) return entry;
+  }
+  return null;
+}
+function listOrphanedProjectMemories(configDir) {
+  return loadMemoryEntries(configDir).filter((entry) => entry.scope === "project" && entry.sourceProject !== void 0 && !existsSync2(entry.sourceProject));
+}
+function rebindMemoryProject(configDir, idPrefix, newProjectPath) {
+  const entries = loadMemoryEntries(configDir);
+  const entry = findUnique(entries, idPrefix);
+  if (entry.scope !== "project") throw new Error(`memory ${entry.id.slice(0, 8)} is not project-scoped (scope: ${entry.scope})`);
+  entry.sourceProject = getProjectKey(resolve(newProjectPath));
+  entry.updatedAt = nowIso();
+  saveMemoryEntries(configDir, entries);
+  return entry;
+}
+function detectStaleLegacyMarkdownEdit(configDir) {
+  const jsonlPath = memoryStorePath(configDir);
+  const mdPath = memoryMarkdownPath(configDir);
+  if (!existsSync2(jsonlPath) || !existsSync2(mdPath)) return false;
+  try {
+    if (!readFileSync(mdPath, "utf-8").trim()) return false;
+    const jsonlMtime = statSync(jsonlPath).mtimeMs;
+    const mdMtime = statSync(mdPath).mtimeMs;
+    return mdMtime > jsonlMtime + 2e3;
+  } catch {
+    return false;
+  }
+}
+function touchMemoryReferences(configDir, ids) {
+  if (ids.length === 0) return;
+  const wanted = new Set(ids);
+  const entries = loadMemoryEntries(configDir);
+  let changed = false;
+  const ts = nowIso();
+  for (const entry of entries) {
+    if (wanted.has(entry.id)) {
+      entry.lastReferencedAt = ts;
+      changed = true;
+    }
+  }
+  if (changed) saveMemoryEntries(configDir, entries);
+}
+function isMemoryStale(entry, days, at = /* @__PURE__ */ new Date()) {
+  const reference = Date.parse(entry.lastReferencedAt ?? entry.updatedAt);
+  if (!Number.isFinite(reference)) return false;
+  return at.getTime() - reference > days * 864e5;
+}
+function tokenizeQuery(query) {
+  const tokens = [];
+  for (const word of query.toLowerCase().split(/\s+/).filter(Boolean)) {
+    const cjkRuns = word.match(/[一-鿿぀-ヿ가-힯]+/g) ?? [];
+    const nonCjk = word.replace(/[一-鿿぀-ヿ가-힯]+/g, " ").split(/\s+/).filter((t) => t.length >= 2);
+    tokens.push(...nonCjk);
+    for (const run of cjkRuns) {
+      if (run.length === 1) tokens.push(run);
+      for (let i = 0; i + 2 <= run.length; i++) tokens.push(run.slice(i, i + 2));
+    }
+  }
+  return [...new Set(tokens)];
+}
+function searchPersistentMemories(configDir, query, cwd = process.cwd(), limit = 3) {
+  const tokens = tokenizeQuery(query);
+  if (tokens.length === 0) return [];
+  const entries = listMemoryEntries(configDir, { cwd }).filter((entry) => entry.approved && !isMemoryExpired(entry));
+  const hits = [];
+  for (const entry of entries) {
+    const haystack = entry.content.toLowerCase();
+    const matched = tokens.filter((token) => haystack.includes(token)).length;
+    const score = matched / tokens.length;
+    if (score >= 0.34) hits.push({ entry, score });
+  }
+  return hits.sort((a, b) => b.score - a.score).slice(0, limit);
+}
+function backupMemoryStore(configDir, outPath) {
+  const entries = loadMemoryEntries(configDir);
+  if (entries.length === 0) throw new Error("memory is empty \u2014 nothing to back up");
+  const storePath = memoryStorePath(configDir);
+  if (!existsSync2(storePath)) saveMemoryEntries(configDir, entries);
+  const backupPath = outPath ?? `${storePath}.bak.${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+  copyFileSync(storePath, backupPath);
+  return { backupPath, count: entries.length };
+}
+function restoreMemoryEntries(configDir, filePath) {
+  const text = readFileSync(filePath, "utf-8").trim();
+  if (!text) throw new Error(`restore file is empty: ${filePath}`);
+  let rawItems;
+  try {
+    const parsed = JSON.parse(text);
+    rawItems = Array.isArray(parsed) ? parsed : [parsed];
+  } catch {
+    rawItems = text.split("\n").map((line) => {
+      try {
+        return JSON.parse(line.trim());
+      } catch {
+        return null;
+      }
+    }).filter((x) => x !== null);
+  }
+  const candidates = rawItems.map((item) => normalizeEntry(item)).filter((entry) => Boolean(entry));
+  if (candidates.length === 0) throw new Error(`no valid memory entries found in ${filePath}`);
+  const existing = loadMemoryEntries(configDir);
+  const existingIds = new Set(existing.map((entry) => entry.id));
+  let backupPath = null;
+  if (existing.length > 0) {
+    backupPath = backupMemoryStore(configDir).backupPath;
+  }
+  let imported = 0;
+  let skipped = 0;
+  for (const candidate of candidates) {
+    if (existingIds.has(candidate.id)) {
+      skipped++;
+      continue;
+    }
+    const redacted = redactString(candidate.content, { enabled: true, patterns: DEFAULT_PATTERNS });
+    if (redacted.hits.length > 0) {
+      candidate.content = redacted.redacted.trim();
+      candidate.sensitivity = "high";
+      candidate.approved = false;
+      candidate.redactedKinds = [...new Set(redacted.hits.map((hit) => hit.kind))];
+    }
+    existing.push(candidate);
+    existingIds.add(candidate.id);
+    imported++;
+  }
+  saveMemoryEntries(configDir, existing);
+  return { imported, skipped, backupPath };
+}
+
+export {
+  getGitRoot,
+  getGitContext,
+  formatGitContextForPrompt,
+  parseWritableScope,
+  memoryStorePath,
+  memoryMarkdownPath,
+  getProjectKey,
+  loadMemoryEntries,
+  isMemoryExpired,
+  isMemoryVisibleInProject,
+  listMemoryEntries,
+  addMemoryEntry,
+  updateMemoryEntry,
+  updateMemoryApproval,
+  deleteMemoryEntry,
+  expireMemoryEntry,
+  countPendingMemories,
+  clearMemoryEntries,
+  exportMemoryEntries,
+  renderMemoryMarkdown,
+  syncLegacyMarkdown,
+  formatMemoryForPrompt,
+  findSimilarMemory,
+  listOrphanedProjectMemories,
+  rebindMemoryProject,
+  detectStaleLegacyMarkdownEdit,
+  touchMemoryReferences,
+  isMemoryStale,
+  searchPersistentMemories,
+  backupMemoryStore,
+  restoreMemoryEntries
+};

package/dist/{chunk-CHFFEVVT.js → chunk-QNK7GUUB.js}

@@ -2,7 +2,7 @@
 import {
   evaluateCiGate,
   normalizeCiThresholds
-} from "./chunk-PGHTAKIA.js";
+} from "./chunk-DJGCG7SF.js";
 import {
   buildReviewPrompt,
   buildSecurityReviewPrompt,
@@ -13,10 +13,10 @@ import {
 } from "./chunk-QYQI7ZWK.js";
 import {
   ConfigManager
-} from "./chunk-IV6GCDVR.js";
+} from "./chunk-X73Y4JZI.js";
 import {
   VERSION
-} from "./chunk-SMQHEJSH.js";
+} from "./chunk-66CE3E6X.js";
 
 // src/cli/ci.ts
 import { execFileSync } from "child_process";