@a-company/paradigm 5.10.0 → 5.21.0

package/dist/chunk-RAB5IKPR.js

@@ -1,487 +0,0 @@
-#!/usr/bin/env node
-
-// src/lore-server/routes/lore.ts
-import { Router } from "express";
-import * as fs from "fs";
-import * as path from "path";
-import * as yaml from "js-yaml";
-var LORE_DIR = ".paradigm/lore";
-var ENTRIES_DIR = "entries";
-function isLoreFile(filename) {
-  return filename.endsWith(".yaml") || filename.endsWith(".lore");
-}
-function normalizeEntry(raw) {
-  const author = raw.author;
-  if (typeof author === "object" && author && !Array.isArray(author)) {
-    const old = author;
-    if (old.type === "agent") {
-      raw.author = old.id || "unknown";
-      const model = old.model || old.id || "unknown";
-      const lower = model.toLowerCase();
-      let provider = "unknown";
-      if (lower.includes("claude") || lower.includes("anthropic")) provider = "anthropic";
-      else if (lower.includes("gpt") || lower.includes("openai")) provider = "openai";
-      raw.agent = { provider, model };
-    } else {
-      raw.author = old.id || "unknown";
-    }
-    delete raw.assistedBy;
-  } else if (typeof author !== "string") {
-    raw.author = "unknown";
-  }
-  if (raw.symbols_touched && !Array.isArray(raw.symbols_touched)) {
-    raw.symbols_touched = [String(raw.symbols_touched)];
-  }
-  if (raw.symbols_created && !Array.isArray(raw.symbols_created)) {
-    raw.symbols_created = [String(raw.symbols_created)];
-  }
-  return raw;
-}
-function resolveEntryPath(projectDir, dateStr, entryId) {
-  const dirPath = path.join(projectDir, 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;
-}
-function loadAllEntries(projectDir) {
-  const entriesPath = path.join(projectDir, LORE_DIR, ENTRIES_DIR);
-  if (!fs.existsSync(entriesPath)) {
-    return [];
-  }
-  const entries = [];
-  const dateDirs = fs.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort().reverse();
-  for (const dateDir of dateDirs) {
-    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(normalizeEntry(raw));
-      } catch {
-      }
-    }
-  }
-  return entries;
-}
-function createLoreRouter(projectDir) {
-  const router = Router();
-  router.get("/", (req, res) => {
-    let entries = loadAllEntries(projectDir);
-    const { author, authorType, hasAgent, symbol, type, tag, from, to, tags, hasReview, hasBody, hasConfidence, hasAssessment, limit, offset } = req.query;
-    if (author) {
-      entries = entries.filter((e) => e.author === author);
-    }
-    if (hasAgent !== void 0) {
-      entries = entries.filter(
-        (e) => hasAgent === "true" ? e.agent != null : e.agent == null
-      );
-    } else if (authorType) {
-      entries = entries.filter(
-        (e) => authorType === "agent" ? e.agent != null : e.agent == null
-      );
-    }
-    if (symbol) {
-      entries = entries.filter(
-        (e) => e.symbols_touched?.includes(symbol) || e.symbols_created?.includes(symbol)
-      );
-    }
-    if (type) {
-      entries = entries.filter((e) => e.type === type);
-    }
-    if (tag) {
-      const prefix = tag;
-      entries = entries.filter(
-        (e) => e.tags?.some((t) => t === prefix || t.startsWith(prefix + ":") || prefix.includes(":") && t === prefix)
-      );
-    }
-    if (hasBody === "true") {
-      entries = entries.filter((e) => e.body != null && e.body.length > 0);
-    } else if (hasBody === "false") {
-      entries = entries.filter((e) => !e.body || e.body.length === 0);
-    }
-    if (from) {
-      const fromDate = new Date(from).getTime();
-      entries = entries.filter((e) => new Date(e.timestamp).getTime() >= fromDate);
-    }
-    if (to) {
-      const toDate = new Date(to).getTime();
-      entries = entries.filter((e) => new Date(e.timestamp).getTime() <= toDate);
-    }
-    if (tags) {
-      const tagList = tags.split(",");
-      entries = entries.filter((e) => tagList.some((t) => e.tags?.includes(t)));
-    }
-    if (hasReview === "true") {
-      entries = entries.filter((e) => e.review != null);
-    } else if (hasReview === "false") {
-      entries = entries.filter((e) => e.review == null);
-    }
-    if (hasConfidence === "true") {
-      entries = entries.filter((e) => e.confidence != null);
-    } else if (hasConfidence === "false") {
-      entries = entries.filter((e) => e.confidence == null);
-    }
-    if (hasAssessment === "true") {
-      entries = entries.filter((e) => e.assessment != null);
-    } else if (hasAssessment === "false") {
-      entries = entries.filter((e) => e.assessment == null);
-    }
-    entries.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
-    const off = parseInt(offset || "0", 10);
-    const lim = parseInt(limit || "100", 10);
-    const total = entries.length;
-    entries = entries.slice(off, off + lim);
-    res.json({ total, offset: off, limit: lim, entries });
-  });
-  router.get("/timeline", (_req, res) => {
-    const timelinePath = path.join(projectDir, LORE_DIR, "timeline.yaml");
-    if (!fs.existsSync(timelinePath)) {
-      res.json({ version: "1.0", project: "unknown", entries: 0, last_updated: "", authors: [] });
-      return;
-    }
-    try {
-      const content = fs.readFileSync(timelinePath, "utf8");
-      res.json(yaml.load(content));
-    } catch {
-      res.status(500).json({ error: "Failed to load timeline" });
-    }
-  });
-  router.get("/symbols", (_req, res) => {
-    const entries = loadAllEntries(projectDir);
-    const symbolCounts = {};
-    for (const entry of entries) {
-      if (entry.symbols_touched) {
-        for (const sym of entry.symbols_touched) {
-          symbolCounts[sym] = (symbolCounts[sym] || 0) + 1;
-        }
-      }
-      if (entry.symbols_created) {
-        for (const sym of entry.symbols_created) {
-          symbolCounts[sym] = (symbolCounts[sym] || 0) + 1;
-        }
-      }
-    }
-    const symbols = Object.entries(symbolCounts).map(([symbol, count]) => ({ symbol, count })).sort((a, b) => b.count - a.count);
-    res.json({ symbols });
-  });
-  router.get("/tags", (_req, res) => {
-    const entries = loadAllEntries(projectDir);
-    const tagCounts = {};
-    for (const entry of entries) {
-      if (entry.tags) {
-        for (const tag of entry.tags) {
-          tagCounts[tag] = (tagCounts[tag] || 0) + 1;
-        }
-      }
-    }
-    const tags = Object.entries(tagCounts).map(([tag, count]) => ({ tag, count })).sort((a, b) => b.count - a.count);
-    res.json({ tags });
-  });
-  router.get("/authors", (_req, res) => {
-    const entries = loadAllEntries(projectDir);
-    const authorMap = {};
-    for (const entry of entries) {
-      const aid = entry.author;
-      if (!authorMap[aid]) {
-        authorMap[aid] = { hasAgent: entry.agent != null, count: 0, lastActive: entry.timestamp };
-      }
-      authorMap[aid].count++;
-      if (entry.agent != null) authorMap[aid].hasAgent = true;
-      if (entry.timestamp > authorMap[aid].lastActive) {
-        authorMap[aid].lastActive = entry.timestamp;
-      }
-    }
-    const authors = Object.entries(authorMap).map(([id, info]) => ({ id, ...info })).sort((a, b) => b.count - a.count);
-    res.json({ authors });
-  });
-  router.get("/calibration", (_req, res) => {
-    const entries = loadAllEntries(projectDir).filter((e) => e.assessment != null);
-    const withConfidence = entries.filter((e) => e.confidence != null);
-    const totalAssessed = entries.length;
-    const totalWithConfidence = withConfidence.length;
-    const verdictBreakdown = { correct: 0, partial: 0, incorrect: 0 };
-    let totalImpliedScore = 0;
-    let totalConfidence = 0;
-    let totalAbsDelta = 0;
-    for (const e of entries) {
-      const v = e.assessment.verdict;
-      verdictBreakdown[v]++;
-      const implied = v === "correct" ? 1 : v === "partial" ? 0.5 : 0;
-      totalImpliedScore += implied;
-      if (e.confidence != null) {
-        totalConfidence += e.confidence;
-        totalAbsDelta += Math.abs(implied - e.confidence);
-      }
-    }
-    const accuracyRate = totalAssessed > 0 ? totalImpliedScore / totalAssessed : 0;
-    const avgConfidence = totalWithConfidence > 0 ? totalConfidence / totalWithConfidence : null;
-    const calibrationScore = totalWithConfidence > 0 ? 1 - totalAbsDelta / totalWithConfidence : null;
-    res.json({
-      totalAssessed,
-      totalWithConfidence,
-      accuracyRate: Math.round(accuracyRate * 1e3) / 1e3,
-      avgConfidence: avgConfidence != null ? Math.round(avgConfidence * 1e3) / 1e3 : null,
-      calibrationScore: calibrationScore != null ? Math.round(calibrationScore * 1e3) / 1e3 : null,
-      verdictBreakdown
-    });
-  });
-  router.get("/:id", (req, res) => {
-    const entries = loadAllEntries(projectDir);
-    const entry = entries.find((e) => e.id === req.params.id);
-    if (!entry) {
-      res.status(404).json({ error: "Entry not found" });
-      return;
-    }
-    res.json(entry);
-  });
-  router.put("/:id/assess", (req, res) => {
-    const entryId = req.params.id;
-    const entries = loadAllEntries(projectDir);
-    const entry = entries.find((e) => e.id === entryId);
-    if (!entry) {
-      res.status(404).json({ error: "Entry not found" });
-      return;
-    }
-    const dateStr = entry.timestamp.slice(0, 10);
-    const entryPath = resolveEntryPath(projectDir, dateStr, entryId);
-    if (!entryPath) {
-      res.status(404).json({ error: "Entry file not found" });
-      return;
-    }
-    const verdict = req.body.verdict;
-    if (!["correct", "partial", "incorrect"].includes(verdict)) {
-      res.status(400).json({ error: "Invalid verdict. Must be: correct, partial, incorrect" });
-      return;
-    }
-    entry.assessment = {
-      verdict,
-      assessed_by: req.body.assessed_by || "anonymous",
-      assessed_at: (/* @__PURE__ */ new Date()).toISOString(),
-      notes: req.body.notes
-    };
-    if (entry.confidence != null) {
-      const impliedScore = verdict === "correct" ? 1 : verdict === "partial" ? 0.5 : 0;
-      entry.assessment_delta = impliedScore - entry.confidence;
-    }
-    fs.writeFileSync(entryPath, yaml.dump(entry, { lineWidth: -1, noRefs: true }));
-    res.json({ success: true, entry });
-  });
-  router.put("/:id/review", (req, res) => {
-    const entryId = req.params.id;
-    const entries = loadAllEntries(projectDir);
-    const entry = entries.find((e) => e.id === entryId);
-    if (!entry) {
-      res.status(404).json({ error: "Entry not found" });
-      return;
-    }
-    const dateStr = entry.timestamp.slice(0, 10);
-    const entryPath = resolveEntryPath(projectDir, dateStr, entryId);
-    if (!entryPath) {
-      res.status(404).json({ error: "Entry file not found" });
-      return;
-    }
-    entry.review = {
-      reviewer: req.body.reviewer || "anonymous",
-      completeness: req.body.completeness || 3,
-      quality: req.body.quality || 3,
-      notes: req.body.notes,
-      reviewed_at: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    fs.writeFileSync(entryPath, yaml.dump(entry, { lineWidth: -1, noRefs: true }));
-    res.json({ success: true, entry });
-  });
-  return router;
-}
-
-// src/lore-server/routes/info.ts
-import { Router as Router2 } from "express";
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as yaml2 from "js-yaml";
-function createInfoRouter(projectDir) {
-  const router = Router2();
-  router.get("/", (_req, res) => {
-    const configPath = path2.join(projectDir, ".paradigm", "config.yaml");
-    let project = path2.basename(projectDir);
-    if (fs2.existsSync(configPath)) {
-      try {
-        const config = yaml2.load(fs2.readFileSync(configPath, "utf8"));
-        project = config.project || config.name || project;
-      } catch {
-      }
-    }
-    res.json({
-      project,
-      projectDir,
-      paradigmVersion: "2.0"
-    });
-  });
-  return router;
-}
-
-// src/lore-server/routes/sessions.ts
-import { Router as Router3 } from "express";
-import * as fs3 from "fs";
-import * as path3 from "path";
-import * as yaml3 from "js-yaml";
-import * as os from "os";
-var LORE_DIR2 = ".paradigm/lore";
-var ENTRIES_DIR2 = "entries";
-var SESSION_GAP_MS = 4 * 60 * 60 * 1e3;
-function isLoreFile2(filename) {
-  return filename.endsWith(".yaml") || filename.endsWith(".lore");
-}
-function normalizeEntry2(raw) {
-  const author = raw.author;
-  if (typeof author === "object" && author && !Array.isArray(author)) {
-    const old = author;
-    if (old.type === "agent") {
-      raw.author = old.id || "unknown";
-      const model = old.model || old.id || "unknown";
-      const lower = model.toLowerCase();
-      let provider = "unknown";
-      if (lower.includes("claude") || lower.includes("anthropic")) provider = "anthropic";
-      else if (lower.includes("gpt") || lower.includes("openai")) provider = "openai";
-      raw.agent = { provider, model };
-    } else {
-      raw.author = old.id || "unknown";
-    }
-    delete raw.assistedBy;
-  } else if (typeof author !== "string") {
-    raw.author = "unknown";
-  }
-  if (raw.symbols_touched && !Array.isArray(raw.symbols_touched)) {
-    raw.symbols_touched = [String(raw.symbols_touched)];
-  }
-  if (raw.symbols_created && !Array.isArray(raw.symbols_created)) {
-    raw.symbols_created = [String(raw.symbols_created)];
-  }
-  return raw;
-}
-function loadAllEntries2(projectDir) {
-  const entriesPath = path3.join(projectDir, LORE_DIR2, ENTRIES_DIR2);
-  if (!fs3.existsSync(entriesPath)) {
-    return [];
-  }
-  const entries = [];
-  const dateDirs = fs3.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort().reverse();
-  for (const dateDir of dateDirs) {
-    const dirPath = path3.join(entriesPath, dateDir);
-    const files = fs3.readdirSync(dirPath).filter(isLoreFile2).sort();
-    for (const file of files) {
-      try {
-        const content = fs3.readFileSync(path3.join(dirPath, file), "utf8");
-        const raw = yaml3.load(content);
-        entries.push(normalizeEntry2(raw));
-      } catch {
-      }
-    }
-  }
-  return entries;
-}
-function loadBreadcrumbs(projectDir) {
-  const localPath = path3.join(projectDir, ".paradigm", "session-breadcrumbs.json");
-  if (fs3.existsSync(localPath)) {
-    try {
-      return JSON.parse(fs3.readFileSync(localPath, "utf8"));
-    } catch {
-    }
-  }
-  const globalDir = path3.join(os.homedir(), ".paradigm", "sessions");
-  if (fs3.existsSync(globalDir)) {
-    try {
-      const dirs = fs3.readdirSync(globalDir).sort().reverse();
-      for (const dir of dirs.slice(0, 5)) {
-        const bcPath = path3.join(globalDir, dir, "breadcrumbs.json");
-        if (fs3.existsSync(bcPath)) {
-          return JSON.parse(fs3.readFileSync(bcPath, "utf8"));
-        }
-      }
-    } catch {
-    }
-  }
-  return [];
-}
-function deriveSessionsFromEntries(entries, breadcrumbs) {
-  if (entries.length === 0) return [];
-  const sorted = [...entries].sort(
-    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
-  );
-  const sessions = [];
-  let currentGroup = [sorted[0]];
-  for (let i = 1; i < sorted.length; i++) {
-    const prev = sorted[i - 1];
-    const curr = sorted[i];
-    const gap = new Date(curr.timestamp).getTime() - new Date(prev.timestamp).getTime();
-    const sameAuthor = curr.author === prev.author;
-    if (gap <= SESSION_GAP_MS && sameAuthor) {
-      currentGroup.push(curr);
-    } else {
-      sessions.push(groupToSession(currentGroup));
-      currentGroup = [curr];
-    }
-  }
-  sessions.push(groupToSession(currentGroup));
-  if (breadcrumbs.length > 0 && sessions.length > 0) {
-    sessions[sessions.length - 1].breadcrumbs = breadcrumbs;
-  }
-  sessions.sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime());
-  return sessions;
-}
-function groupToSession(group) {
-  const allSymbols = /* @__PURE__ */ new Set();
-  let hasAgent = false;
-  for (const entry of group) {
-    if (entry.symbols_touched) {
-      for (const sym of entry.symbols_touched) allSymbols.add(sym);
-    }
-    if (entry.symbols_created) {
-      for (const sym of entry.symbols_created) allSymbols.add(sym);
-    }
-    if (entry.agent) hasAgent = true;
-  }
-  const startTime = group[0].timestamp;
-  const endTime = group[group.length - 1].timestamp;
-  const date = startTime.slice(0, 10);
-  return {
-    id: `session-${date}-${group[0].author}-${group[0].id.slice(0, 8)}`,
-    date,
-    author: { name: group[0].author, hasAgent },
-    startTime,
-    endTime,
-    entryCount: group.length,
-    symbolsTouched: Array.from(allSymbols),
-    entryIds: group.map((e) => e.id)
-  };
-}
-function createSessionsRouter(projectDir) {
-  const router = Router3();
-  router.get("/", (_req, res) => {
-    const entries = loadAllEntries2(projectDir);
-    const breadcrumbs = loadBreadcrumbs(projectDir);
-    const sessions = deriveSessionsFromEntries(entries, breadcrumbs);
-    res.json({ sessions });
-  });
-  router.get("/:id", (req, res) => {
-    const entries = loadAllEntries2(projectDir);
-    const breadcrumbs = loadBreadcrumbs(projectDir);
-    const sessions = deriveSessionsFromEntries(entries, breadcrumbs);
-    const session = sessions.find((s) => s.id === req.params.id);
-    if (!session) {
-      res.status(404).json({ error: "Session not found" });
-      return;
-    }
-    const sessionEntries = entries.filter((e) => session.entryIds.includes(e.id));
-    res.json({ ...session, entries: sessionEntries });
-  });
-  return router;
-}
-
-export {
-  createLoreRouter,
-  createInfoRouter,
-  createSessionsRouter
-};