@a-company/paradigm 3.18.0 → 3.19.0

package/dist/chunk-DSXS42FY.js

@@ -1,283 +0,0 @@
-#!/usr/bin/env node
-
-// ../paradigm-mcp/src/utils/assessment-loader.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as yaml from "js-yaml";
-var ASSESSMENTS_DIR = ".paradigm/assessments";
-var ARCS_DIR = "arcs";
-var INDEX_FILE = "index.yaml";
-function generateAssessmentId(rootDir, dateStr) {
-  const arcsPath = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR);
-  let maxSeq = 0;
-  if (fs.existsSync(arcsPath)) {
-    const arcDirs = fs.readdirSync(arcsPath).filter((d) => {
-      try {
-        return fs.statSync(path.join(arcsPath, d)).isDirectory();
-      } catch {
-        return false;
-      }
-    });
-    for (const arcDir of arcDirs) {
-      const entriesPath = path.join(arcsPath, arcDir, "entries");
-      if (!fs.existsSync(entriesPath)) continue;
-      const files = fs.readdirSync(entriesPath).filter(
-        (f) => f.startsWith(`A-${dateStr}-`) && f.endsWith(".yaml")
-      );
-      for (const file of files) {
-        const match = file.match(/A-\d{4}-\d{2}-\d{2}-(\d+)\.yaml/);
-        if (match) {
-          const seq = parseInt(match[1], 10);
-          if (seq > maxSeq) maxSeq = seq;
-        }
-      }
-    }
-  }
-  return `A-${dateStr}-${String(maxSeq + 1).padStart(3, "0")}`;
-}
-function computeArcStats(rootDir, arc) {
-  const entriesPath = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR, arc.id, "entries");
-  const symbolSet = /* @__PURE__ */ new Set();
-  let entryCount = 0;
-  let latestDate;
-  if (fs.existsSync(entriesPath)) {
-    const files = fs.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml"));
-    for (const file of files) {
-      try {
-        const entry = yaml.load(fs.readFileSync(path.join(entriesPath, file), "utf8"));
-        entryCount++;
-        if (entry.symbols) entry.symbols.forEach((s) => symbolSet.add(s));
-        if (!latestDate || entry.date > latestDate) latestDate = entry.date;
-      } catch {
-      }
-    }
-  }
-  return { ...arc, entry_count: entryCount, symbols: Array.from(symbolSet), latest_entry: latestDate };
-}
-async function loadArcs(rootDir, status) {
-  const arcsPath = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR);
-  if (!fs.existsSync(arcsPath)) return [];
-  const arcDirs = fs.readdirSync(arcsPath).filter((d) => {
-    try {
-      return fs.statSync(path.join(arcsPath, d)).isDirectory();
-    } catch {
-      return false;
-    }
-  });
-  const arcs = [];
-  for (const arcDir of arcDirs) {
-    const arcFile = path.join(arcsPath, arcDir, "arc.yaml");
-    if (!fs.existsSync(arcFile)) continue;
-    try {
-      const arc = yaml.load(fs.readFileSync(arcFile, "utf8"));
-      if (status && status !== "all" && arc.status !== status) continue;
-      arcs.push(computeArcStats(rootDir, arc));
-    } catch {
-    }
-  }
-  arcs.sort((a, b) => {
-    const aDate = a.latest_entry || a.created;
-    const bDate = b.latest_entry || b.created;
-    return bDate.localeCompare(aDate);
-  });
-  return arcs;
-}
-async function loadArc(rootDir, arcId) {
-  const arcFile = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR, arcId, "arc.yaml");
-  if (!fs.existsSync(arcFile)) return null;
-  try {
-    const arc = yaml.load(fs.readFileSync(arcFile, "utf8"));
-    return computeArcStats(rootDir, arc);
-  } catch {
-    return null;
-  }
-}
-var ARC_ID_PATTERN = /^arc-[a-z0-9-]+$/;
-async function createArc(rootDir, arc) {
-  if (!ARC_ID_PATTERN.test(arc.id)) {
-    throw new Error(`Invalid arc ID "${arc.id}": must match arc-{kebab-case} (lowercase alphanumeric + hyphens)`);
-  }
-  const arcPath = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR, arc.id);
-  const entriesPath = path.join(arcPath, "entries");
-  fs.mkdirSync(entriesPath, { recursive: true });
-  const arcData = {
-    id: arc.id,
-    name: arc.name,
-    description: arc.description,
-    created: (/* @__PURE__ */ new Date()).toISOString(),
-    status: "active",
-    tags: arc.tags
-  };
-  fs.writeFileSync(path.join(arcPath, "arc.yaml"), yaml.dump(arcData, { lineWidth: -1, noRefs: true }));
-  await rebuildAssessmentIndex(rootDir);
-  return arc.id;
-}
-async function closeArc(rootDir, arcId, status) {
-  const arcFile = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR, arcId, "arc.yaml");
-  if (!fs.existsSync(arcFile)) return false;
-  try {
-    const arc = yaml.load(fs.readFileSync(arcFile, "utf8"));
-    arc.status = status;
-    fs.writeFileSync(arcFile, yaml.dump(arc, { lineWidth: -1, noRefs: true }));
-    await rebuildAssessmentIndex(rootDir);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function loadEntries(rootDir, arcId) {
-  const entriesPath = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR, arcId, "entries");
-  if (!fs.existsSync(entriesPath)) return [];
-  const entries = [];
-  const files = fs.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml")).sort();
-  for (const file of files) {
-    try {
-      const entry = yaml.load(fs.readFileSync(path.join(entriesPath, file), "utf8"));
-      entries.push(entry);
-    } catch {
-    }
-  }
-  entries.sort((a, b) => b.date.localeCompare(a.date));
-  return entries;
-}
-async function loadEntry(rootDir, entryId) {
-  const arcsPath = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR);
-  if (!fs.existsSync(arcsPath)) return null;
-  const arcDirs = fs.readdirSync(arcsPath).filter((d) => {
-    try {
-      return fs.statSync(path.join(arcsPath, d)).isDirectory();
-    } catch {
-      return false;
-    }
-  });
-  for (const arcDir of arcDirs) {
-    const entryFile = path.join(arcsPath, arcDir, "entries", `${entryId}.yaml`);
-    if (fs.existsSync(entryFile)) {
-      try {
-        const entry = yaml.load(fs.readFileSync(entryFile, "utf8"));
-        const arcFile = path.join(arcsPath, arcDir, "arc.yaml");
-        const arc = yaml.load(fs.readFileSync(arcFile, "utf8"));
-        return { entry, arc };
-      } catch {
-        return null;
-      }
-    }
-  }
-  return null;
-}
-async function recordEntry(rootDir, entry, arcName, arcDescription) {
-  const arcPath = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR, entry.arc_id);
-  if (!fs.existsSync(path.join(arcPath, "arc.yaml"))) {
-    if (!arcName) {
-      throw new Error(`Arc "${entry.arc_id}" does not exist. Provide arc_name to create it.`);
-    }
-    await createArc(rootDir, { id: entry.arc_id, name: arcName, description: arcDescription, tags: entry.symbols });
-  }
-  const now = /* @__PURE__ */ new Date();
-  const dateStr = now.toISOString().slice(0, 10);
-  const id = generateAssessmentId(rootDir, dateStr);
-  const fullEntry = {
-    id,
-    arc_id: entry.arc_id,
-    title: entry.title,
-    summary: entry.summary,
-    body: entry.body,
-    symbols: entry.symbols,
-    tags: entry.tags,
-    linked_lore: entry.linked_lore,
-    linked_tasks: entry.linked_tasks,
-    linked_commits: entry.linked_commits,
-    date: now.toISOString(),
-    author: { type: "agent", id: "claude", model: "claude-opus-4-6" },
-    type: entry.type || "retro"
-  };
-  const entriesPath = path.join(arcPath, "entries");
-  fs.mkdirSync(entriesPath, { recursive: true });
-  fs.writeFileSync(path.join(entriesPath, `${id}.yaml`), yaml.dump(fullEntry, { lineWidth: -1, noRefs: true }));
-  await rebuildAssessmentIndex(rootDir);
-  return id;
-}
-async function searchEntries(rootDir, filter) {
-  const arcsPath = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR);
-  if (!fs.existsSync(arcsPath)) return [];
-  const limit = filter.limit || 20;
-  const results = [];
-  const arcDirs = fs.readdirSync(arcsPath).filter((d) => {
-    try {
-      return fs.statSync(path.join(arcsPath, d)).isDirectory();
-    } catch {
-      return false;
-    }
-  });
-  for (const arcDir of arcDirs) {
-    const entriesPath = path.join(arcsPath, arcDir, "entries");
-    if (!fs.existsSync(entriesPath)) continue;
-    const files = fs.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml"));
-    for (const file of files) {
-      try {
-        const entry = yaml.load(fs.readFileSync(path.join(entriesPath, file), "utf8"));
-        if (filter.symbol && !(entry.symbols || []).includes(filter.symbol)) continue;
-        if (filter.tag && !(entry.tags || []).includes(filter.tag)) continue;
-        if (filter.type && entry.type !== filter.type) continue;
-        if (filter.dateFrom && entry.date < filter.dateFrom) continue;
-        if (filter.dateTo && entry.date > filter.dateTo) continue;
-        results.push(entry);
-      } catch {
-      }
-    }
-  }
-  results.sort((a, b) => b.date.localeCompare(a.date));
-  return results.slice(0, limit);
-}
-async function rebuildAssessmentIndex(rootDir) {
-  const arcsPath = path.join(rootDir, ASSESSMENTS_DIR, ARCS_DIR);
-  const assessmentsPath = path.join(rootDir, ASSESSMENTS_DIR);
-  let totalArcs = 0, totalEntries = 0, activeArcs = 0;
-  const arcSummaries = [];
-  if (fs.existsSync(arcsPath)) {
-    const arcDirs = fs.readdirSync(arcsPath).filter((d) => {
-      try {
-        return fs.statSync(path.join(arcsPath, d)).isDirectory();
-      } catch {
-        return false;
-      }
-    });
-    for (const arcDir of arcDirs) {
-      const arcFile = path.join(arcsPath, arcDir, "arc.yaml");
-      if (!fs.existsSync(arcFile)) continue;
-      try {
-        const arc = yaml.load(fs.readFileSync(arcFile, "utf8"));
-        const entriesPath = path.join(arcsPath, arcDir, "entries");
-        const entryCount = fs.existsSync(entriesPath) ? fs.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml")).length : 0;
-        totalArcs++;
-        totalEntries += entryCount;
-        if (arc.status === "active") activeArcs++;
-        arcSummaries.push({ id: arc.id, name: arc.name, status: arc.status, entries: entryCount });
-      } catch {
-      }
-    }
-  }
-  const index = {
-    version: "1.0",
-    total_arcs: totalArcs,
-    total_entries: totalEntries,
-    active_arcs: activeArcs,
-    last_updated: (/* @__PURE__ */ new Date()).toISOString(),
-    arcs: arcSummaries
-  };
-  fs.mkdirSync(assessmentsPath, { recursive: true });
-  fs.writeFileSync(path.join(assessmentsPath, INDEX_FILE), yaml.dump(index, { lineWidth: -1, noRefs: true }));
-  return index;
-}
-
-export {
-  loadArcs,
-  loadArc,
-  createArc,
-  closeArc,
-  loadEntries,
-  loadEntry,
-  recordEntry,
-  searchEntries,
-  rebuildAssessmentIndex
-};