@a-company/paradigm 3.44.0 → 5.3.3

package/dist/chunk-MCMOGQMU.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import {
+  __esm,
+  __export
+} from "./chunk-7N7GSU6K.js";
+
+// ../paradigm-mcp/src/utils/journal-loader.ts
+var journal_loader_exports = {};
+__export(journal_loader_exports, {
+  getJournalStats: () => getJournalStats,
+  loadAllJournalEntries: () => loadAllJournalEntries,
+  loadJournalEntries: () => loadJournalEntries,
+  loadJournalEntry: () => loadJournalEntry,
+  recordJournalEntry: () => recordJournalEntry
+});
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+function getJournalDir(agentId) {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return path.join(home, ".paradigm", "agents", agentId, "journal");
+}
+function generateJournalId() {
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toISOString().slice(0, 10);
+  const time = now.toISOString().slice(11, 19).replace(/:/g, "");
+  const counter = String(Math.floor(Math.random() * 999) + 1).padStart(3, "0");
+  return `LJ-${date}-${time}-${counter}`;
+}
+function recordJournalEntry(agentId, entry) {
+  const now = /* @__PURE__ */ new Date();
+  const id = generateJournalId();
+  const full = {
+    id,
+    agent: agentId,
+    timestamp: now.toISOString(),
+    ...entry
+  };
+  const dir = getJournalDir(agentId);
+  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 loadJournalEntries(agentId, filter) {
+  const dir = getJournalDir(agentId);
+  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?.trigger) {
+    filtered = filtered.filter((e) => e.trigger === filter.trigger);
+  }
+  if (filter?.project) {
+    filtered = filtered.filter((e) => e.project === filter.project);
+  }
+  if (filter?.transferable !== void 0) {
+    filtered = filtered.filter((e) => e.transferable === filter.transferable);
+  }
+  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 loadJournalEntry(agentId, id) {
+  const dir = getJournalDir(agentId);
+  const filePath = path.join(dir, `${id}.yaml`);
+  if (!fs.existsSync(filePath)) return null;
+  const content = fs.readFileSync(filePath, "utf8");
+  return yaml.load(content);
+}
+function loadAllJournalEntries(filter) {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  const agentsDir = path.join(home, ".paradigm", "agents");
+  if (!fs.existsSync(agentsDir)) return [];
+  const entries = [];
+  const agents = fs.readdirSync(agentsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const agentDir of agents) {
+    if (filter?.agent && agentDir.name !== filter.agent) continue;
+    const agentEntries = loadJournalEntries(agentDir.name, filter);
+    entries.push(...agentEntries);
+  }
+  entries.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+  if (filter?.limit) {
+    return entries.slice(0, filter.limit);
+  }
+  return entries;
+}
+function getJournalStats(agentId) {
+  const entries = loadJournalEntries(agentId);
+  const byTrigger = {};
+  const byProject = {};
+  let transferableCount = 0;
+  for (const e of entries) {
+    byTrigger[e.trigger] = (byTrigger[e.trigger] || 0) + 1;
+    byProject[e.project] = (byProject[e.project] || 0) + 1;
+    if (e.transferable) transferableCount++;
+  }
+  return {
+    total: entries.length,
+    byTrigger,
+    byProject,
+    transferableCount,
+    recentInsights: entries.slice(0, 5).map((e) => ({
+      id: e.id,
+      trigger: e.trigger,
+      insight: e.insight.slice(0, 200),
+      timestamp: e.timestamp
+    }))
+  };
+}
+var init_journal_loader = __esm({
+  "../paradigm-mcp/src/utils/journal-loader.ts"() {
+  }
+});
+
+export {
+  recordJournalEntry,
+  loadJournalEntries,
+  loadJournalEntry,
+  loadAllJournalEntries,
+  getJournalStats,
+  journal_loader_exports,
+  init_journal_loader
+};

package/dist/{chunk-ZXMDA7VB.js → chunk-PDX44BCA.js}

@@ -1,16 +1,11 @@
 #!/usr/bin/env node
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 
 export {
-  __require,
-  __commonJS
+  __require
 };

package/dist/{chunk-SOBTKFSP.js → chunk-S2HO5MLR.js}

@@ -246,6 +246,9 @@ function appendToOutbox(agentId, message) {
   ensureAgentDir(agentId);
   appendJsonlLine(outboxPath(agentId), message);
 }
+function readOutbox(agentId) {
+  return readJsonlFile(outboxPath(agentId));
+}
 function acknowledgeMessages(agentId, lastMessageId) {
   const filePath = ackPath(agentId);
   ensureAgentDir(agentId);
@@ -596,7 +599,9 @@ export {
   markAgentPollTime,
   isAgentAsleep,
   discoverClaudeCodeSessions,
+  appendToInbox,
   readInbox,
+  readOutbox,
   acknowledgeMessages,
   garbageCollect,
   createThread,

package/dist/{chunk-2SKXFXIT.js → chunk-S3ORKP3V.js}

@@ -2,7 +2,7 @@
 import {
   detectIDE,
   getAdapter
-} from "./chunk-KB4XJWE3.js";
+} from "./chunk-6N3JTACN.js";
 import {
   parseParadigmConfig
 } from "./chunk-YO6DVTL7.js";
@@ -13,6 +13,7 @@ import {
 // src/commands/doctor/index.ts
 import * as fs from "fs";
 import * as path from "path";
+import * as yaml from "js-yaml";
 import chalk from "chalk";
 async function doctorCommand(options = {}) {
   const cwd = options.rootDir || process.cwd();
@@ -245,8 +246,7 @@ async function doctorCommand(options = {}) {
     if (fs.existsSync(configPath)) {
       try {
         const configContent = fs.readFileSync(configPath, "utf8");
-        const { parse } = await import("./dist-PSF5CP4I.js");
-        const config = parse(configContent);
+        const config = yaml.load(configContent);
         const purposeRequired = config?.["purpose-required"];
         if (purposeRequired && Array.isArray(purposeRequired)) {
           const missingDirs = [];
@@ -314,8 +314,7 @@ async function doctorCommand(options = {}) {
     if (fs.existsSync(portalPath)) {
       try {
         const portalContent = fs.readFileSync(portalPath, "utf8");
-        const { parse } = await import("./dist-PSF5CP4I.js");
-        const portal = parse(portalContent);
+        const portal = yaml.load(portalContent);
         if (portal?.version && portal?.gates) {
           const gateCount = Object.keys(portal.gates || {}).length;
           const routeCount = Object.keys(portal.routes || {}).length;
@@ -343,7 +342,7 @@ async function doctorCommand(options = {}) {
     }
     if (fs.existsSync(portalPath)) {
       try {
-        const { checkPortalCompliance, getComplianceSummary } = await import("./portal-compliance-VU4NIFEN.js");
+        const { checkPortalCompliance, getComplianceSummary } = await import("./portal-compliance-J7DGAPFX.js");
         const complianceReport = await checkPortalCompliance(cwd);
         const summary = getComplianceSummary(complianceReport);
         results.push({
@@ -359,8 +358,7 @@ async function doctorCommand(options = {}) {
     if (fs.existsSync(flowsPath)) {
       try {
         const flowsContent = fs.readFileSync(flowsPath, "utf8");
-        const { parse } = await import("./dist-PSF5CP4I.js");
-        const flows = parse(flowsContent);
+        const flows = yaml.load(flowsContent);
         if (flows?.version && flows?.flows) {
           const flowCount = Object.keys(flows.flows || {}).length;
           const emptyFlows = Object.entries(flows.flows || {}).filter(
@@ -449,8 +447,7 @@ async function doctorCommand(options = {}) {
           if (fs.existsSync(quizDir)) {
             for (const file of fs.readdirSync(quizDir).filter((f) => f.endsWith(".yaml"))) {
               try {
-                const { parse } = await import("./dist-PSF5CP4I.js");
-                const quiz = parse(fs.readFileSync(path.join(quizDir, file), "utf8"));
+                const quiz = yaml.load(fs.readFileSync(path.join(quizDir, file), "utf8"));
                 if (quiz?.questions) {
                   for (const q of quiz.questions) {
                     if (q.choices && q.correct && !(q.correct in q.choices)) {
@@ -466,8 +463,7 @@ async function doctorCommand(options = {}) {
           if (fs.existsSync(pathDir)) {
             for (const file of fs.readdirSync(pathDir).filter((f) => f.endsWith(".yaml"))) {
               try {
-                const { parse } = await import("./dist-PSF5CP4I.js");
-                const lp = parse(fs.readFileSync(path.join(pathDir, file), "utf8"));
+                const lp = yaml.load(fs.readFileSync(path.join(pathDir, file), "utf8"));
                 if (lp?.steps) {
                   for (const step of lp.steps) {
                     if (step.content && !step.content.startsWith("plsat:")) {
@@ -551,8 +547,7 @@ async function doctorCommand(options = {}) {
     if (fs.existsSync(habitsPath)) {
       try {
         const habitsContent = fs.readFileSync(habitsPath, "utf8");
-        const { parse } = await import("./dist-PSF5CP4I.js");
-        const habits = parse(habitsContent);
+        const habits = yaml.load(habitsContent);
         if (habits?.version && Array.isArray(habits?.habits)) {
           const enabled = habits.habits.filter((h) => h.enabled !== false).length;
           results.push({
@@ -633,7 +628,7 @@ async function doctorCommand(options = {}) {
       }
     }
   }
-  const { runContextAudit } = await import("./context-audit-557EO6PK.js");
+  const { runContextAudit } = await import("./context-audit-RLO3ETRP.js");
   const contextResults = await runContextAudit(cwd, { quiet });
   let contextErrorCount = 0;
   let contextWarnCount = 0;