@a-company/paradigm 5.11.0 → 5.21.0

package/dist/chunk-5VKJBNJL.js

@@ -1,444 +0,0 @@
-#!/usr/bin/env node
-import {
-  __esm
-} from "./chunk-7N7GSU6K.js";
-
-// ../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";
-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;
-  if (partial.confidence !== void 0) entry.confidence = partial.confidence;
-  if (partial.assessment !== void 0) entry.assessment = partial.assessment;
-  if (partial.assessment_delta !== void 0) entry.assessment_delta = partial.assessment_delta;
-  fs.writeFileSync(entryPath, yaml.dump(entry, { lineWidth: -1, noRefs: true }));
-  await rebuildTimeline(rootDir);
-  return true;
-}
-function verdictToScore(verdict) {
-  switch (verdict) {
-    case "correct":
-      return 1;
-    case "partial":
-      return 0.5;
-    case "incorrect":
-      return 0;
-  }
-}
-async function addLoreAssessment(rootDir, entryId, assessment) {
-  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.assessment = assessment;
-  if (entry.confidence != null) {
-    entry.assessment_delta = verdictToScore(assessment.verdict) - entry.confidence;
-  }
-  fs.writeFileSync(entryPath, yaml.dump(entry, { lineWidth: -1, noRefs: true }));
-  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);
-  }
-  if (filter.hasConfidence !== void 0) {
-    result = result.filter((e) => filter.hasConfidence ? e.confidence != null : e.confidence == null);
-  }
-  if (filter.hasAssessment !== void 0) {
-    result = result.filter((e) => filter.hasAssessment ? e.assessment != null : e.assessment == 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")}`;
-}
-var LORE_DIR, ENTRIES_DIR, TIMELINE_FILE;
-var init_lore_loader = __esm({
-  "../paradigm-mcp/src/utils/lore-loader.ts"() {
-    LORE_DIR = ".paradigm/lore";
-    ENTRIES_DIR = "entries";
-    TIMELINE_FILE = "timeline.yaml";
-  }
-});
-
-export {
-  loadLoreEntries,
-  loadLoreEntry,
-  loadLoreTimeline,
-  recordLoreEntry,
-  addLoreReview,
-  rebuildTimeline,
-  updateLoreEntry,
-  addLoreAssessment,
-  deleteLoreEntry,
-  init_lore_loader
-};