@a-company/paradigm 3.46.0 → 5.3.3

package/dist/chunk-EZ3GOCYC.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+// ../paradigm-mcp/src/utils/decision-loader.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+var DECISIONS_DIR = ".paradigm/decisions";
+function generateDecisionId() {
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toISOString().slice(0, 10);
+  const counter = String(Math.floor(Math.random() * 999) + 1).padStart(3, "0");
+  return `TD-${date}-${counter}`;
+}
+function recordDecision(rootDir, entry) {
+  const now = /* @__PURE__ */ new Date();
+  const id = generateDecisionId();
+  const full = {
+    id,
+    timestamp: now.toISOString(),
+    ...entry
+  };
+  const dir = path.join(rootDir, DECISIONS_DIR);
+  fs.mkdirSync(dir, { recursive: true });
+  const filePath = path.join(dir, `${id}.yaml`);
+  fs.writeFileSync(filePath, yaml.dump(full, { lineWidth: 120, noRefs: true }), "utf8");
+  return full;
+}
+function updateDecision(rootDir, id, updates) {
+  const existing = loadDecision(rootDir, id);
+  if (!existing) return null;
+  const updated = { ...existing, ...updates };
+  const dir = path.join(rootDir, DECISIONS_DIR);
+  const filePath = path.join(dir, `${id}.yaml`);
+  fs.writeFileSync(filePath, yaml.dump(updated, { lineWidth: 120, noRefs: true }), "utf8");
+  return updated;
+}
+function supersedeDecision(rootDir, oldId, newEntry) {
+  const old = loadDecision(rootDir, oldId);
+  if (!old) return null;
+  const newDecision = recordDecision(rootDir, newEntry);
+  const updatedOld = updateDecision(rootDir, oldId, {
+    status: "superseded",
+    superseded_by: newDecision.id
+  });
+  if (!updatedOld) return null;
+  return { old: updatedOld, new: newDecision };
+}
+function loadDecisions(rootDir, filter) {
+  const dir = path.join(rootDir, DECISIONS_DIR);
+  if (!fs.existsSync(dir)) return [];
+  const entries = [];
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith(".yaml"));
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(path.join(dir, file), "utf8");
+      const entry = yaml.load(content);
+      if (entry && entry.id) {
+        entries.push(entry);
+      }
+    } catch {
+    }
+  }
+  let filtered = entries;
+  if (filter?.status) {
+    filtered = filtered.filter((e) => e.status === filter.status);
+  }
+  if (filter?.participant) {
+    filtered = filtered.filter(
+      (e) => e.participants.some((p) => p.id === filter.participant)
+    );
+  }
+  if (filter?.symbol) {
+    filtered = filtered.filter((e) => e.symbols_affected?.includes(filter.symbol));
+  }
+  if (filter?.tag) {
+    filtered = filtered.filter((e) => e.tags?.some((t) => t.startsWith(filter.tag)));
+  }
+  if (filter?.dateFrom) {
+    filtered = filtered.filter((e) => e.timestamp >= filter.dateFrom);
+  }
+  if (filter?.dateTo) {
+    filtered = filtered.filter((e) => e.timestamp <= filter.dateTo);
+  }
+  filtered.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+  if (filter?.limit) {
+    filtered = filtered.slice(0, filter.limit);
+  }
+  return filtered;
+}
+function loadDecision(rootDir, id) {
+  const dir = path.join(rootDir, DECISIONS_DIR);
+  const filePath = path.join(dir, `${id}.yaml`);
+  if (!fs.existsSync(filePath)) return null;
+  const content = fs.readFileSync(filePath, "utf8");
+  return yaml.load(content);
+}
+function findDecisionsForSymbol(rootDir, symbol) {
+  return loadDecisions(rootDir, { symbol, status: "active" });
+}
+function getDecisionSummary(rootDir) {
+  const all = loadDecisions(rootDir);
+  const byStatus = {};
+  const symbols = /* @__PURE__ */ new Set();
+  for (const d of all) {
+    byStatus[d.status] = (byStatus[d.status] || 0) + 1;
+    d.symbols_affected?.forEach((s) => symbols.add(s));
+  }
+  return {
+    total: all.length,
+    active: byStatus["active"] || 0,
+    superseded: byStatus["superseded"] || 0,
+    deprecated: byStatus["deprecated"] || 0,
+    proposed: byStatus["proposed"] || 0,
+    recentDecisions: all.slice(0, 10).map((d) => ({
+      id: d.id,
+      title: d.title,
+      status: d.status,
+      timestamp: d.timestamp
+    })),
+    symbolsCovered: [...symbols].sort()
+  };
+}
+
+export {
+  recordDecision,
+  updateDecision,
+  supersedeDecision,
+  loadDecisions,
+  loadDecision,
+  findDecisionsForSymbol,
+  getDecisionSummary
+};