unforgit 0.8.4 → 0.9.0

package/dist/{chunk-VESJIIT2.js → chunk-JXSAAZ3I.js}

@@ -10,6 +10,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 import OpenAI from "openai";
 import { createHash } from "crypto";
 import OpenAI2 from "openai";
+import { createHash as createHash2 } from "crypto";
 var DEFAULT_TTL_SECONDS_BY_TYPE = {
   episodic: 30 * 24 * 60 * 60,
   semantic: void 0,
@@ -1461,6 +1462,198 @@ function formatTemplateList() {
   }
   return lines.join("\n");
 }
+var HEADING_TAGS = [
+  [/conventions?/i, "convention"],
+  [/gotchas?|warnings?|pitfalls?/i, "gotcha"],
+  [/playbooks?|procedures?|workflows?|commands?/i, "playbook"],
+  [/decisions?/i, "decision"],
+  [/architecture/i, "architecture"]
+];
+var SECRET_PATTERNS = [
+  /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/,
+  /\b(?:sk|pk)_[A-Za-z0-9]{20,}\b/,
+  /\b(?:token|secret|password)\s+(?:is|:)\s+\S+/i,
+  /\b[A-Za-z0-9_]*SECRET[A-Za-z0-9_]*\s*=\s*\S+/i,
+  /-----BEGIN (?:RSA |OPENSSH |EC |DSA )?PRIVATE KEY-----/
+];
+var PROMPT_INJECTION_PATTERNS = [
+  /ignore (?:all )?(?:previous|prior) instructions/i,
+  /reveal (?:all )?(?:secrets|tokens|keys)/i,
+  /system prompt/i
+];
+function checksumFor(text) {
+  return createHash2("sha256").update(text.trim(), "utf8").digest("hex");
+}
+function isTagChar(char) {
+  const code = char.charCodeAt(0);
+  return code >= 97 && code <= 122 || code >= 48 && code <= 57 || char === "_" || char === "-";
+}
+function normalizeTag(tag) {
+  const slug = tag.trim().toLowerCase().split("").map((char) => isTagChar(char) ? char : "-").join("");
+  let start = 0;
+  let end = slug.length;
+  while (start < end && slug[start] === "-") start += 1;
+  while (end > start && slug[end - 1] === "-") end -= 1;
+  return slug.slice(start, end);
+}
+function uniqueTags(tags) {
+  return Array.from(new Set(tags.map(normalizeTag).filter(Boolean)));
+}
+function inferType(headingPath, text, explicit) {
+  if (explicit) return explicit;
+  const haystack = `${headingPath.join(" ")} ${text}`;
+  if (/playbooks?|procedures?|workflows?|commands?|\bto\s+\w+[,，:]?\s+run\b/i.test(haystack)) {
+    return "procedural";
+  }
+  if (/incidents?|bugs?|found|fixed|session|today|yesterday/i.test(haystack)) {
+    return "episodic";
+  }
+  return "semantic";
+}
+function inferTags(headingPath, explicitTags = []) {
+  const tags = [...explicitTags];
+  for (const heading of headingPath) {
+    for (const [pattern, tag] of HEADING_TAGS) {
+      if (pattern.test(heading)) tags.push(tag);
+    }
+  }
+  return uniqueTags(tags);
+}
+function parseMetadata(line) {
+  const match = line.match(/<!--\s*unforgit:([^>]*)-->/i);
+  if (!match) return void 0;
+  const metadata = {};
+  const body = match[1];
+  for (const part of body.split(/\s+/).filter(Boolean)) {
+    const [key, rawValue] = part.split("=");
+    const value = rawValue?.trim();
+    if (!value) continue;
+    if (key === "id") metadata.id = value;
+    if (key === "type" && ["episodic", "semantic", "procedural"].includes(value)) {
+      metadata.memoryType = value;
+    }
+    if (key === "tags") metadata.tags = value.split(",").map((tag) => tag.trim());
+  }
+  return metadata;
+}
+function stripBullet(line) {
+  const match = line.match(/^\s*(?:[-*+]\s+|\d+[.)]\s+)(.+?)\s*$/);
+  return match?.[1]?.trim();
+}
+function headingLevel(line) {
+  const match = line.match(/^(#{1,6})\s+(.+?)\s*#*\s*$/);
+  if (!match) return void 0;
+  return { level: match[1].length, text: match[2].trim() };
+}
+function parseMarkdownMemories(markdown, options) {
+  const lines = markdown.replace(/\r\n/g, "\n").split("\n");
+  const headings = [];
+  const memories = [];
+  let pendingMetadata;
+  let inFence = false;
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (/^\s*```/.test(line)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+    const heading = headingLevel(line);
+    if (heading) {
+      while (headings.length > 0 && headings[headings.length - 1].level >= heading.level) {
+        headings.pop();
+      }
+      headings.push(heading);
+      pendingMetadata = void 0;
+      continue;
+    }
+    const metadata = parseMetadata(line);
+    if (metadata) {
+      pendingMetadata = metadata;
+      continue;
+    }
+    const text = stripBullet(line);
+    if (!text) continue;
+    const headingPath = headings.map((h) => h.text);
+    const memoryType = inferType(headingPath, text, pendingMetadata?.memoryType);
+    const tags = inferTags(headingPath, pendingMetadata?.tags);
+    memories.push({
+      id: pendingMetadata?.id,
+      text,
+      memoryType,
+      tags,
+      headingPath,
+      sourceFile: options.sourceFile,
+      lineStart: i + 1,
+      lineEnd: i + 1,
+      checksum: checksumFor(text)
+    });
+    pendingMetadata = void 0;
+  }
+  return memories;
+}
+function findUnsafeMarkdownMemoryFindings(memories) {
+  const findings = [];
+  for (const memory of memories) {
+    if (SECRET_PATTERNS.some((pattern) => pattern.test(memory.text))) {
+      findings.push({
+        checksum: memory.checksum,
+        reason: "possible-secret",
+        severity: "error",
+        message: `Possible secret in ${memory.sourceFile}:${memory.lineStart}`
+      });
+    }
+    if (PROMPT_INJECTION_PATTERNS.some((pattern) => pattern.test(memory.text))) {
+      findings.push({
+        checksum: memory.checksum,
+        reason: "prompt-injection",
+        severity: "warn",
+        message: `Prompt-injection-like instruction in ${memory.sourceFile}:${memory.lineStart}`
+      });
+    }
+  }
+  return findings;
+}
+function shouldImportMarkdownMemory(memory, findings) {
+  return !findings.some((finding) => finding.checksum === memory.checksum);
+}
+function sectionFor(memory) {
+  if (memory.memoryType === "procedural" || memory.tags.includes("playbook")) return "Playbooks";
+  if (memory.tags.includes("gotcha")) return "Gotchas";
+  if (memory.tags.includes("decision")) return "Decisions";
+  return "Conventions";
+}
+function sortExportMemories(a, b) {
+  const section = sectionFor(a).localeCompare(sectionFor(b));
+  if (section !== 0) return section;
+  return a.id.localeCompare(b.id);
+}
+function exportMarkdownMemories(memories, options = {}) {
+  const title = options.title ?? (options.format === "claude" ? "CLAUDE.md" : "Memory");
+  const sorted = [...memories].sort(sortExportMemories);
+  const lines = [
+    `# ${title}`,
+    "",
+    "Generated from Unforgit. Edit carefully; run `unforgit md sync` to import reviewed changes.",
+    ""
+  ];
+  let currentSection = "";
+  for (const memory of sorted) {
+    const section = sectionFor(memory);
+    if (section !== currentSection) {
+      if (currentSection) lines.push("");
+      lines.push(`## ${section}`, "");
+      currentSection = section;
+    }
+    const tags = uniqueTags(memory.tags);
+    lines.push(
+      `<!-- unforgit:id=${memory.id} type=${memory.memoryType} tags=${tags.join(",")} -->`,
+      `- ${memory.text}`
+    );
+  }
+  return `${lines.join("\n")}
+`;
+}
 
 // ../../packages/config/dist/index.js
 import fs from "fs";
@@ -3784,6 +3977,10 @@ export {
   getTemplate,
   applyTemplate,
   formatTemplateList,
+  parseMarkdownMemories,
+  findUnsafeMarkdownMemoryFindings,
+  shouldImportMarkdownMemory,
+  exportMarkdownMemories,
   validateMemoryType,
   parseConfidence,
   parseThreshold,
@@ -3801,4 +3998,4 @@ export {
   RemoteClient,
   LocalStore
 };
-//# sourceMappingURL=chunk-VESJIIT2.js.map
+//# sourceMappingURL=chunk-JXSAAZ3I.js.map