@a-company/paradigm 3.17.2 → 3.19.0

package/dist/chunk-3DYYXGDC.js

@@ -0,0 +1,403 @@
+#!/usr/bin/env node
+
+// ../paradigm-mcp/src/utils/lore-loader.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+import { execSync } from "child_process";
+import * as os from "os";
+var LORE_DIR = ".paradigm/lore";
+var ENTRIES_DIR = "entries";
+var TIMELINE_FILE = "timeline.yaml";
+function inferProvider(model) {
+  const lower = model.toLowerCase();
+  if (lower.includes("claude") || lower.includes("anthropic")) return "anthropic";
+  if (lower.includes("gpt") || lower.includes("openai") || lower.includes("o1") || lower.includes("o3")) return "openai";
+  if (lower.includes("gemini") || lower.includes("google") || lower.includes("palm")) return "google";
+  if (lower.includes("llama") || lower.includes("meta")) return "meta";
+  if (lower.includes("mistral") || lower.includes("mixtral")) return "mistral";
+  if (lower.includes("deepseek")) return "deepseek";
+  if (lower.includes("cohere") || lower.includes("command")) return "cohere";
+  return "unknown";
+}
+function normalizeLoreEntry(raw) {
+  const entry = raw;
+  const author = entry.author;
+  if (!entry.type) {
+    entry.type = "agent-session";
+  }
+  if (typeof author === "string") {
+    return raw;
+  }
+  if (author && typeof author === "object" && !Array.isArray(author)) {
+    const old = author;
+    if (old.type === "agent") {
+      entry.author = "unknown";
+      entry.agent = {
+        provider: old.model ? inferProvider(old.model) : inferProvider(old.id),
+        model: old.model || old.id
+      };
+    } else {
+      entry.author = old.id || "unknown";
+    }
+    delete entry.assistedBy;
+  }
+  return entry;
+}
+function sanitizeAuthor(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 20) || "unknown";
+}
+function resolveAuthor() {
+  const envAuthor = process.env.PARADIGM_AUTHOR;
+  if (envAuthor) return sanitizeAuthor(envAuthor);
+  try {
+    const gitName = execSync("git config user.name", { encoding: "utf-8", timeout: 3e3 }).trim();
+    if (gitName) return sanitizeAuthor(gitName);
+  } catch {
+  }
+  try {
+    const username = os.userInfo().username;
+    if (username) return sanitizeAuthor(username);
+  } catch {
+  }
+  return "unknown";
+}
+function isLoreFile(filename) {
+  return filename.endsWith(".yaml") || filename.endsWith(".lore");
+}
+function resolveEntryPath(rootDir, dateStr, entryId) {
+  const dirPath = path.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr);
+  const lorePath = path.join(dirPath, `${entryId}.lore`);
+  if (fs.existsSync(lorePath)) return lorePath;
+  const yamlPath = path.join(dirPath, `${entryId}.yaml`);
+  if (fs.existsSync(yamlPath)) return yamlPath;
+  return null;
+}
+async function loadLoreEntries(rootDir, filter) {
+  const entriesPath = path.join(rootDir, LORE_DIR, ENTRIES_DIR);
+  if (!fs.existsSync(entriesPath)) {
+    return [];
+  }
+  migrateLegacyEntries(rootDir);
+  const entries = [];
+  const dateDirs = fs.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort().reverse();
+  for (const dateDir of dateDirs) {
+    if (filter?.dateFrom && dateDir < filter.dateFrom.slice(0, 10)) continue;
+    if (filter?.dateTo && dateDir > filter.dateTo.slice(0, 10)) continue;
+    const dirPath = path.join(entriesPath, dateDir);
+    const files = fs.readdirSync(dirPath).filter(isLoreFile).sort();
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(path.join(dirPath, file), "utf8");
+        const raw = yaml.load(content);
+        entries.push(normalizeLoreEntry(raw));
+      } catch {
+      }
+    }
+  }
+  return filter ? applyFilter(entries, filter) : entries;
+}
+async function loadLoreEntry(rootDir, entryId) {
+  const dateMatch = entryId.match(/^L-(\d{4}-\d{2}-\d{2})-/);
+  if (dateMatch) {
+    const dateStr = dateMatch[1];
+    const entryPath = resolveEntryPath(rootDir, dateStr, entryId);
+    if (entryPath) {
+      try {
+        const content = fs.readFileSync(entryPath, "utf8");
+        const raw = yaml.load(content);
+        return normalizeLoreEntry(raw);
+      } catch {
+        return null;
+      }
+    }
+  }
+  const entries = await loadLoreEntries(rootDir);
+  return entries.find((e) => e.id === entryId) || null;
+}
+async function loadLoreTimeline(rootDir) {
+  const timelinePath = path.join(rootDir, LORE_DIR, TIMELINE_FILE);
+  if (!fs.existsSync(timelinePath)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(timelinePath, "utf8");
+    return yaml.load(content);
+  } catch {
+    return null;
+  }
+}
+function captureGitContext(cwd) {
+  try {
+    const ref = execSync("git rev-parse HEAD", { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const status = execSync("git status --porcelain", { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return { ref, branch, dirty: status.length > 0 };
+  } catch {
+    return void 0;
+  }
+}
+async function recordLoreEntry(rootDir, entry) {
+  const lorePath = path.join(rootDir, LORE_DIR);
+  const dateStr = entry.timestamp.slice(0, 10);
+  const datePath = path.join(lorePath, ENTRIES_DIR, dateStr);
+  if (!fs.existsSync(datePath)) {
+    fs.mkdirSync(datePath, { recursive: true });
+  }
+  if (!entry.author) {
+    entry.author = resolveAuthor();
+  }
+  if (!entry.git_context) {
+    entry.git_context = captureGitContext(rootDir);
+  }
+  if (!entry.id) {
+    entry.id = generateLoreId(rootDir, dateStr, entry.author, entry.timestamp);
+  }
+  const entryPath = path.join(datePath, `${entry.id}.lore`);
+  fs.writeFileSync(entryPath, yaml.dump(entry, { lineWidth: -1, noRefs: true }));
+  await rebuildTimeline(rootDir);
+  return entry.id;
+}
+async function addLoreReview(rootDir, entryId, review) {
+  const entry = await loadLoreEntry(rootDir, entryId);
+  if (!entry) return false;
+  const dateStr = entry.timestamp.slice(0, 10);
+  const entryPath = resolveEntryPath(rootDir, dateStr, entryId);
+  if (!entryPath) return false;
+  entry.review = review;
+  fs.writeFileSync(entryPath, yaml.dump(entry, { lineWidth: -1, noRefs: true }));
+  return true;
+}
+async function rebuildTimeline(rootDir) {
+  const lorePath = path.join(rootDir, LORE_DIR);
+  const entriesPath = path.join(lorePath, ENTRIES_DIR);
+  if (!fs.existsSync(entriesPath)) return;
+  migrateLegacyEntries(rootDir);
+  const authors = /* @__PURE__ */ new Set();
+  let entryCount = 0;
+  let lastUpdated = "";
+  const dateDirs = fs.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d));
+  for (const dateDir of dateDirs) {
+    const dirPath = path.join(entriesPath, dateDir);
+    const files = fs.readdirSync(dirPath).filter(isLoreFile);
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(path.join(dirPath, file), "utf8");
+        const raw = yaml.load(content);
+        const entry = normalizeLoreEntry(raw);
+        authors.add(entry.author);
+        entryCount++;
+        if (!lastUpdated || entry.timestamp > lastUpdated) {
+          lastUpdated = entry.timestamp;
+        }
+      } catch {
+      }
+    }
+  }
+  let project = "unknown";
+  const configPath = path.join(rootDir, ".paradigm", "config.yaml");
+  if (fs.existsSync(configPath)) {
+    try {
+      const config = yaml.load(fs.readFileSync(configPath, "utf8"));
+      project = config.project || config.name || "unknown";
+    } catch {
+    }
+  }
+  const timeline = {
+    version: "1.0",
+    project,
+    entries: entryCount,
+    last_updated: lastUpdated || (/* @__PURE__ */ new Date()).toISOString(),
+    authors: Array.from(authors)
+  };
+  if (!fs.existsSync(lorePath)) {
+    fs.mkdirSync(lorePath, { recursive: true });
+  }
+  fs.writeFileSync(
+    path.join(lorePath, TIMELINE_FILE),
+    yaml.dump(timeline, { lineWidth: -1, noRefs: true })
+  );
+}
+function migrateLegacyEntries(rootDir) {
+  const entriesPath = path.join(rootDir, LORE_DIR, ENTRIES_DIR);
+  if (!fs.existsSync(entriesPath)) return 0;
+  const rootFiles = fs.readdirSync(entriesPath).filter((f) => isLoreFile(f) && !f.startsWith("."));
+  let migrated = 0;
+  for (const file of rootFiles) {
+    const filePath = path.join(entriesPath, file);
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile()) continue;
+    try {
+      const content = fs.readFileSync(filePath, "utf8");
+      const raw = yaml.load(content);
+      if (raw.author && typeof raw.author === "object") continue;
+      if (typeof raw.author === "string" && raw.timestamp) continue;
+      const dateStr = typeof raw.date === "string" ? raw.date.slice(0, 10) : (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const datePath = path.join(entriesPath, dateStr);
+      if (!fs.existsSync(datePath)) {
+        fs.mkdirSync(datePath, { recursive: true });
+      }
+      const author = resolveAuthor();
+      const timestamp = `${dateStr}T00:00:00.000Z`;
+      const id = generateLoreId(rootDir, dateStr, author, timestamp);
+      const oldType = String(raw.type || "agent-session");
+      const v2Type = ["agent-session", "human-note", "decision", "review", "incident", "milestone"].includes(oldType) ? oldType : "agent-session";
+      let verification;
+      if (raw.test_results && typeof raw.test_results === "object") {
+        const tr = raw.test_results;
+        verification = {
+          status: tr.total === tr.passed ? "pass" : "partial",
+          details: { tests: tr.total === tr.passed ? "pass" : "fail" }
+        };
+      }
+      const v2Entry = {
+        id,
+        type: v2Type,
+        timestamp,
+        author: "unknown",
+        agent: { provider: "unknown", model: "unknown" },
+        title: String(raw.title || file.replace(/\.(yaml|lore)$/, "")),
+        summary: String(raw.summary || ""),
+        symbols_touched: Array.isArray(raw.symbols_touched) ? raw.symbols_touched : [],
+        files_modified: Array.isArray(raw.files_modified) ? raw.files_modified : void 0,
+        ...verification ? { verification } : {},
+        tags: ["migrated", oldType]
+      };
+      fs.writeFileSync(
+        path.join(datePath, `${id}.lore`),
+        yaml.dump(v2Entry, { lineWidth: -1, noRefs: true })
+      );
+      fs.unlinkSync(filePath);
+      migrated++;
+    } catch {
+    }
+  }
+  return migrated;
+}
+async function updateLoreEntry(rootDir, entryId, partial) {
+  const entry = await loadLoreEntry(rootDir, entryId);
+  if (!entry) return false;
+  const dateStr = entry.timestamp.slice(0, 10);
+  const entryPath = resolveEntryPath(rootDir, dateStr, entryId);
+  if (!entryPath) return false;
+  if (partial.title !== void 0) entry.title = partial.title;
+  if (partial.summary !== void 0) entry.summary = partial.summary;
+  if (partial.type !== void 0) entry.type = partial.type;
+  if (partial.duration_minutes !== void 0) entry.duration_minutes = partial.duration_minutes;
+  if (partial.symbols_touched !== void 0) entry.symbols_touched = partial.symbols_touched;
+  if (partial.symbols_created !== void 0) entry.symbols_created = partial.symbols_created;
+  if (partial.files_created !== void 0) entry.files_created = partial.files_created;
+  if (partial.files_modified !== void 0) entry.files_modified = partial.files_modified;
+  if (partial.lines_added !== void 0) entry.lines_added = partial.lines_added;
+  if (partial.lines_removed !== void 0) entry.lines_removed = partial.lines_removed;
+  if (partial.commit !== void 0) entry.commit = partial.commit;
+  if (partial.decisions !== void 0) entry.decisions = partial.decisions;
+  if (partial.errors_encountered !== void 0) entry.errors_encountered = partial.errors_encountered;
+  if (partial.learnings !== void 0) entry.learnings = partial.learnings;
+  if (partial.verification !== void 0) entry.verification = partial.verification;
+  if (partial.tags !== void 0) entry.tags = partial.tags;
+  if (partial.body !== void 0) entry.body = partial.body;
+  if (partial.linked_lore !== void 0) entry.linked_lore = partial.linked_lore;
+  if (partial.linked_tasks !== void 0) entry.linked_tasks = partial.linked_tasks;
+  if (partial.linked_commits !== void 0) entry.linked_commits = partial.linked_commits;
+  fs.writeFileSync(entryPath, yaml.dump(entry, { lineWidth: -1, noRefs: true }));
+  await rebuildTimeline(rootDir);
+  return true;
+}
+async function deleteLoreEntry(rootDir, entryId) {
+  const entry = await loadLoreEntry(rootDir, entryId);
+  if (!entry) return false;
+  const dateStr = entry.timestamp.slice(0, 10);
+  const entryPath = resolveEntryPath(rootDir, dateStr, entryId);
+  if (!entryPath) return false;
+  fs.unlinkSync(entryPath);
+  const dateDir = path.dirname(entryPath);
+  const remaining = fs.readdirSync(dateDir).filter(isLoreFile);
+  if (remaining.length === 0) {
+    fs.rmdirSync(dateDir);
+  }
+  await rebuildTimeline(rootDir);
+  return true;
+}
+function applyFilter(entries, filter) {
+  let result = entries;
+  if (filter.author) {
+    result = result.filter((e) => e.author === filter.author);
+  }
+  if (filter.hasAgent !== void 0) {
+    result = result.filter(
+      (e) => filter.hasAgent ? e.agent != null : e.agent == null
+    );
+  } else if (filter.authorType) {
+    result = result.filter(
+      (e) => filter.authorType === "agent" ? e.agent != null : e.agent == null
+    );
+  }
+  if (filter.symbol) {
+    result = result.filter(
+      (e) => e.symbols_touched.includes(filter.symbol) || e.symbols_created?.includes(filter.symbol)
+    );
+  }
+  if (filter.dateFrom) {
+    const from = new Date(filter.dateFrom).getTime();
+    result = result.filter((e) => new Date(e.timestamp).getTime() >= from);
+  }
+  if (filter.dateTo) {
+    const to = new Date(filter.dateTo).getTime();
+    result = result.filter((e) => new Date(e.timestamp).getTime() <= to);
+  }
+  if (filter.type) {
+    result = result.filter((e) => e.type === filter.type);
+  }
+  if (filter.tag) {
+    const prefix = filter.tag;
+    result = result.filter(
+      (e) => e.tags?.some((t) => t === prefix || t.startsWith(prefix + ":") || prefix.includes(":") && t === prefix)
+    );
+  }
+  if (filter.tags && filter.tags.length > 0) {
+    result = result.filter((e) => filter.tags.some((tag) => e.tags?.includes(tag)));
+  }
+  if (filter.hasBody !== void 0) {
+    result = result.filter(
+      (e) => filter.hasBody ? e.body != null && e.body.length > 0 : !e.body || e.body.length === 0
+    );
+  }
+  if (filter.hasReview !== void 0) {
+    result = result.filter((e) => filter.hasReview ? e.review != null : e.review == null);
+  }
+  result.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+  if (filter.offset) result = result.slice(filter.offset);
+  if (filter.limit) result = result.slice(0, filter.limit);
+  return result;
+}
+function generateLoreId(rootDir, dateStr, author, timestamp) {
+  const sanitized = sanitizeAuthor(author);
+  const ts = new Date(timestamp);
+  const hh = String(ts.getUTCHours()).padStart(2, "0");
+  const mm = String(ts.getUTCMinutes()).padStart(2, "0");
+  const ss = String(ts.getUTCSeconds()).padStart(2, "0");
+  const timeStr = `${hh}${mm}${ss}`;
+  const prefix = `L-${dateStr}-${sanitized}-${timeStr}`;
+  const datePath = path.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr);
+  if (!fs.existsSync(datePath)) {
+    return `${prefix}-001`;
+  }
+  const existing = fs.readdirSync(datePath).filter((f) => f.startsWith(prefix) && isLoreFile(f)).map((f) => {
+    const match = f.match(/-(\d{3})\.(yaml|lore)$/);
+    return match ? parseInt(match[1], 10) : 0;
+  });
+  const next = existing.length > 0 ? Math.max(...existing) + 1 : 1;
+  return `${prefix}-${String(next).padStart(3, "0")}`;
+}
+
+export {
+  loadLoreEntries,
+  loadLoreEntry,
+  loadLoreTimeline,
+  recordLoreEntry,
+  addLoreReview,
+  rebuildTimeline,
+  updateLoreEntry,
+  deleteLoreEntry
+};