@a-company/paradigm 3.5.0 → 3.7.0

package/dist/assessment-loader-T4GPBHLB.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import {
+  closeArc,
+  createArc,
+  loadArc,
+  loadArcs,
+  loadEntries,
+  loadEntry,
+  rebuildAssessmentIndex,
+  recordEntry,
+  searchEntries
+} from "./chunk-DSXS42FY.js";
+import "./chunk-MO4EEYFW.js";
+export {
+  closeArc,
+  createArc,
+  loadArc,
+  loadArcs,
+  loadEntries,
+  loadEntry,
+  rebuildAssessmentIndex,
+  recordEntry,
+  searchEntries
+};

package/dist/{chunk-CRICL4FQ.js → chunk-ADOBV4PH.js}

@@ -2168,13 +2168,13 @@ function v4(options, buf, offset) {
 }
 var v4_default = v4;
 
-// ../sentinel/dist/chunk-FOF7CPJ6.js
+// ../sentinel/dist/chunk-NTX74ZPM.js
 var import_sql = __toESM(require_sql_wasm(), 1);
 import * as path from "path";
 import * as fs from "fs";
 import * as fs2 from "fs";
 import * as path2 from "path";
-var SCHEMA_VERSION = 4;
+var SCHEMA_VERSION = 5;
 var DEFAULT_CONFIDENCE = {
   score: 50,
   timesMatched: 0,
@@ -2605,6 +2605,54 @@ var SentinelStorage = class {
       this.db.run(
         "INSERT OR REPLACE INTO metadata (key, value) VALUES ('schema_version', '4')"
       );
+      currentVersion = 4;
+    }
+    if (currentVersion < 5) {
+      try {
+        this.db.run(`
+          CREATE TABLE IF NOT EXISTS schemas (
+            id TEXT PRIMARY KEY,
+            version TEXT NOT NULL,
+            name TEXT NOT NULL,
+            description TEXT,
+            scope_json TEXT NOT NULL,
+            event_types_json TEXT NOT NULL,
+            causality_json TEXT,
+            visualization_json TEXT,
+            tags_json TEXT DEFAULT '[]',
+            registered_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+          );
+
+          CREATE TABLE IF NOT EXISTS events (
+            id TEXT PRIMARY KEY,
+            schema_id TEXT NOT NULL,
+            event_type TEXT NOT NULL,
+            category TEXT NOT NULL,
+            timestamp TEXT NOT NULL,
+            scope_value TEXT,
+            scope_ordinal INTEGER,
+            session_id TEXT,
+            service TEXT NOT NULL,
+            data_json TEXT,
+            severity TEXT DEFAULT 'info',
+            parent_event_id TEXT,
+            depth INTEGER DEFAULT 0
+          );
+
+          CREATE INDEX IF NOT EXISTS idx_events_schema ON events(schema_id);
+          CREATE INDEX IF NOT EXISTS idx_events_type ON events(event_type);
+          CREATE INDEX IF NOT EXISTS idx_events_scope ON events(schema_id, scope_value);
+          CREATE INDEX IF NOT EXISTS idx_events_scope_ord ON events(schema_id, scope_ordinal);
+          CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id);
+          CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
+          CREATE INDEX IF NOT EXISTS idx_events_service ON events(service);
+        `);
+      } catch {
+      }
+      this.db.run(
+        "INSERT OR REPLACE INTO metadata (key, value) VALUES ('schema_version', '5')"
+      );
     }
   }
   /**
@@ -4193,6 +4241,341 @@ var SentinelStorage = class {
       logs: obj.log_ids_json ? JSON.parse(obj.log_ids_json) : []
     };
   }
+  // ─── Schema Registry ─────────────────────────────────────────────
+  registerSchema(schema) {
+    this.initializeSync();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.run(
+      `INSERT INTO schemas (
+        id, version, name, description, scope_json, event_types_json,
+        causality_json, visualization_json, tags_json, registered_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         version = excluded.version,
+         name = excluded.name,
+         description = excluded.description,
+         scope_json = excluded.scope_json,
+         event_types_json = excluded.event_types_json,
+         causality_json = excluded.causality_json,
+         visualization_json = excluded.visualization_json,
+         tags_json = excluded.tags_json,
+         updated_at = excluded.updated_at`,
+      [
+        schema.id,
+        schema.version,
+        schema.name,
+        schema.description || null,
+        JSON.stringify(schema.scope),
+        JSON.stringify(schema.eventTypes),
+        schema.causality ? JSON.stringify(schema.causality) : null,
+        schema.visualization ? JSON.stringify(schema.visualization) : null,
+        JSON.stringify(schema.tags || []),
+        now,
+        now
+      ]
+    );
+    this.save();
+    return {
+      id: schema.id,
+      version: schema.version,
+      name: schema.name,
+      description: schema.description,
+      scope: schema.scope,
+      eventTypes: schema.eventTypes,
+      causality: schema.causality,
+      visualization: schema.visualization,
+      tags: schema.tags || [],
+      registeredAt: now,
+      updatedAt: now
+    };
+  }
+  getSchema(id) {
+    this.initializeSync();
+    const result = this.db.exec("SELECT * FROM schemas WHERE id = ?", [id]);
+    if (result.length === 0 || result[0].values.length === 0) return null;
+    return this.rowToSchema(result[0].columns, result[0].values[0]);
+  }
+  listSchemas() {
+    this.initializeSync();
+    const result = this.db.exec("SELECT * FROM schemas ORDER BY name ASC");
+    if (result.length === 0) return [];
+    return result[0].values.map(
+      (row) => this.rowToSchema(result[0].columns, row)
+    );
+  }
+  rowToSchema(columns, row) {
+    const obj = {};
+    columns.forEach((col, i) => {
+      obj[col] = row[i];
+    });
+    return {
+      id: obj.id,
+      version: obj.version,
+      name: obj.name,
+      description: obj.description || void 0,
+      scope: JSON.parse(obj.scope_json),
+      eventTypes: JSON.parse(obj.event_types_json),
+      causality: obj.causality_json ? JSON.parse(obj.causality_json) : void 0,
+      visualization: obj.visualization_json ? JSON.parse(obj.visualization_json) : void 0,
+      tags: JSON.parse(obj.tags_json || "[]"),
+      registeredAt: obj.registered_at,
+      updatedAt: obj.updated_at
+    };
+  }
+  // ─── Generic Events ────────────────────────────────────────────
+  insertEventBatch(schemaId, service, inputs) {
+    this.initializeSync();
+    const schema = this.getSchema(schemaId);
+    const typeMap = /* @__PURE__ */ new Map();
+    if (schema) {
+      for (const et of schema.eventTypes) {
+        typeMap.set(et.type, {
+          category: et.category,
+          severity: et.severity || "info"
+        });
+      }
+    }
+    let accepted = 0;
+    const errors = [];
+    for (const input of inputs) {
+      try {
+        const id = input.id || v4_default();
+        const timestamp = input.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+        const resolved = typeMap.get(input.type);
+        const category = resolved?.category || "unknown";
+        const severity = input.severity || resolved?.severity || "info";
+        const scopeValue = input.scopeValue != null ? String(input.scopeValue) : null;
+        const scopeOrdinal = typeof input.scopeValue === "number" ? input.scopeValue : null;
+        this.db.run(
+          `INSERT INTO events (
+            id, schema_id, event_type, category, timestamp, scope_value,
+            scope_ordinal, session_id, service, data_json, severity,
+            parent_event_id, depth
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            id,
+            schemaId,
+            input.type,
+            category,
+            timestamp,
+            scopeValue,
+            scopeOrdinal,
+            input.sessionId || null,
+            service,
+            input.data ? JSON.stringify(input.data) : null,
+            severity,
+            input.parentEventId || null,
+            input.depth ?? 0
+          ]
+        );
+        accepted++;
+      } catch (err) {
+        errors.push(err instanceof Error ? err.message : String(err));
+      }
+    }
+    this.save();
+    return { accepted, errors };
+  }
+  queryEvents(options = {}) {
+    this.initializeSync();
+    const { limit = 100, offset = 0 } = options;
+    const conditions = [];
+    const params = [];
+    if (options.schemaId) {
+      conditions.push("schema_id = ?");
+      params.push(options.schemaId);
+    }
+    if (options.eventType) {
+      conditions.push("event_type = ?");
+      params.push(options.eventType);
+    }
+    if (options.category) {
+      conditions.push("category = ?");
+      params.push(options.category);
+    }
+    if (options.service) {
+      conditions.push("service = ?");
+      params.push(options.service);
+    }
+    if (options.sessionId) {
+      conditions.push("session_id = ?");
+      params.push(options.sessionId);
+    }
+    if (options.scopeValue) {
+      conditions.push("scope_value = ?");
+      params.push(options.scopeValue);
+    }
+    if (options.scopeFrom) {
+      conditions.push("scope_value >= ?");
+      params.push(options.scopeFrom);
+    }
+    if (options.scopeTo) {
+      conditions.push("scope_value <= ?");
+      params.push(options.scopeTo);
+    }
+    if (options.severity) {
+      conditions.push("severity = ?");
+      params.push(options.severity);
+    }
+    if (options.since) {
+      conditions.push("timestamp >= ?");
+      params.push(options.since);
+    }
+    if (options.until) {
+      conditions.push("timestamp <= ?");
+      params.push(options.until);
+    }
+    if (options.search) {
+      conditions.push("data_json LIKE ?");
+      params.push(`%${options.search}%`);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = this.db.exec(
+      `SELECT * FROM events ${whereClause} ORDER BY timestamp DESC LIMIT ? OFFSET ?`,
+      [...params, limit, offset]
+    );
+    if (result.length === 0) return [];
+    return result[0].values.map(
+      (row) => this.rowToGenericEvent(result[0].columns, row)
+    );
+  }
+  queryEventsByScope(schemaId, scopeValue) {
+    this.initializeSync();
+    const result = this.db.exec(
+      `SELECT * FROM events
+       WHERE schema_id = ? AND scope_value = ?
+       ORDER BY timestamp ASC`,
+      [schemaId, scopeValue]
+    );
+    if (result.length === 0) return [];
+    return result[0].values.map(
+      (row) => this.rowToGenericEvent(result[0].columns, row)
+    );
+  }
+  getEventScopes(schemaId, options = {}) {
+    this.initializeSync();
+    const { limit = 100, offset = 0 } = options;
+    const conditions = ["schema_id = ?"];
+    const params = [schemaId];
+    if (options.sessionId) {
+      conditions.push("session_id = ?");
+      params.push(options.sessionId);
+    }
+    const whereClause = `WHERE ${conditions.join(" AND ")}`;
+    const result = this.db.exec(
+      `SELECT
+        scope_value,
+        MIN(scope_ordinal) as scope_ordinal,
+        COUNT(*) as event_count,
+        MIN(timestamp) as first_timestamp,
+        MAX(timestamp) as last_timestamp
+       FROM events
+       ${whereClause}
+       AND scope_value IS NOT NULL
+       GROUP BY scope_value
+       ORDER BY MIN(COALESCE(scope_ordinal, 0)) DESC, MIN(timestamp) DESC
+       LIMIT ? OFFSET ?`,
+      [...params, limit, offset]
+    );
+    if (result.length === 0) return [];
+    const scopes = [];
+    for (const row of result[0].values) {
+      const scopeValue = row[0];
+      const scopeOrdinal = row[1] != null ? row[1] : void 0;
+      const eventCount = row[2];
+      const firstTimestamp = row[3];
+      const lastTimestamp = row[4];
+      const catResult = this.db.exec(
+        `SELECT category, COUNT(*) as count FROM events
+         WHERE schema_id = ? AND scope_value = ?
+         GROUP BY category`,
+        [schemaId, scopeValue]
+      );
+      const categories = {};
+      if (catResult.length > 0) {
+        for (const catRow of catResult[0].values) {
+          categories[catRow[0]] = catRow[1];
+        }
+      }
+      scopes.push({
+        scopeValue,
+        scopeOrdinal,
+        eventCount,
+        categories,
+        firstTimestamp,
+        lastTimestamp
+      });
+    }
+    return scopes;
+  }
+  getEventCount(options = {}) {
+    this.initializeSync();
+    const conditions = [];
+    const params = [];
+    if (options.schemaId) {
+      conditions.push("schema_id = ?");
+      params.push(options.schemaId);
+    }
+    if (options.eventType) {
+      conditions.push("event_type = ?");
+      params.push(options.eventType);
+    }
+    if (options.service) {
+      conditions.push("service = ?");
+      params.push(options.service);
+    }
+    if (options.since) {
+      conditions.push("timestamp >= ?");
+      params.push(options.since);
+    }
+    if (options.until) {
+      conditions.push("timestamp <= ?");
+      params.push(options.until);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = this.db.exec(
+      `SELECT COUNT(*) as count FROM events ${whereClause}`,
+      params
+    );
+    if (result.length === 0 || result[0].values.length === 0) return 0;
+    return result[0].values[0][0];
+  }
+  pruneEvents(maxCount) {
+    this.initializeSync();
+    if (maxCount <= 0) return 0;
+    const currentCount = this.getEventCount();
+    if (currentCount <= maxCount) return 0;
+    const deleteCount = currentCount - maxCount;
+    this.db.run(
+      `DELETE FROM events WHERE id IN (
+        SELECT id FROM events ORDER BY timestamp ASC LIMIT ?
+      )`,
+      [deleteCount]
+    );
+    this.save();
+    return deleteCount;
+  }
+  rowToGenericEvent(columns, row) {
+    const obj = {};
+    columns.forEach((col, i) => {
+      obj[col] = row[i];
+    });
+    return {
+      id: obj.id,
+      schemaId: obj.schema_id,
+      eventType: obj.event_type,
+      category: obj.category,
+      timestamp: obj.timestamp,
+      scopeValue: obj.scope_value || void 0,
+      scopeOrdinal: obj.scope_ordinal != null ? obj.scope_ordinal : void 0,
+      sessionId: obj.session_id || void 0,
+      service: obj.service,
+      data: obj.data_json ? JSON.parse(obj.data_json) : void 0,
+      severity: obj.severity || "info",
+      parentEventId: obj.parent_event_id || void 0,
+      depth: obj.depth || 0
+    };
+  }
   close() {
     if (this.db) {
       this.save();

package/dist/{chunk-IRVA7NKV.js → chunk-BC6XKMUA.js}

@@ -548,6 +548,8 @@ ${purposeLines}
 function createMinimalStructure(paradigmDir, projectName) {
   fs.mkdirSync(path.join(paradigmDir, "specs"), { recursive: true });
   fs.mkdirSync(path.join(paradigmDir, "docs"), { recursive: true });
+  fs.mkdirSync(path.join(paradigmDir, "tasks"), { recursive: true });
+  fs.mkdirSync(path.join(paradigmDir, "assessments"), { recursive: true });
   const minimalConfig = `# Paradigm Configuration
 version: "1.0"
 project: "${projectName}"

package/dist/chunk-CSD7IHSN.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+// ../paradigm-mcp/src/utils/task-loader.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+var TASKS_ROOT = ".paradigm/tasks";
+var ENTRIES_DIR = "entries";
+var INDEX_FILE = "index.yaml";
+function generateTaskId(rootDir, dateStr) {
+  const datePath = path.join(rootDir, TASKS_ROOT, ENTRIES_DIR, dateStr);
+  if (!fs.existsSync(datePath)) {
+    return `T-${dateStr}-001`;
+  }
+  const existing = fs.readdirSync(datePath).filter((f) => f.startsWith("T-") && f.endsWith(".yaml")).map((f) => {
+    const match = f.match(/T-\d{4}-\d{2}-\d{2}-(\d+)\.yaml/);
+    return match ? parseInt(match[1], 10) : 0;
+  });
+  const next = existing.length > 0 ? Math.max(...existing) + 1 : 1;
+  return `T-${dateStr}-${String(next).padStart(3, "0")}`;
+}
+var PRIORITY_ORDER = { high: 0, medium: 1, low: 2 };
+function applyFilter(tasks, filter) {
+  let result = tasks;
+  if (filter.status && filter.status !== "all") {
+    result = result.filter((t) => t.status === filter.status);
+  }
+  if (filter.priority) {
+    result = result.filter((t) => t.priority === filter.priority);
+  }
+  if (filter.tag) {
+    result = result.filter((t) => t.tags.includes(filter.tag));
+  }
+  result.sort((a, b) => {
+    const priDiff = (PRIORITY_ORDER[a.priority] ?? 1) - (PRIORITY_ORDER[b.priority] ?? 1);
+    if (priDiff !== 0) return priDiff;
+    return new Date(b.created).getTime() - new Date(a.created).getTime();
+  });
+  if (filter.limit) {
+    result = result.slice(0, filter.limit);
+  }
+  return result;
+}
+async function loadTasks(rootDir, filter) {
+  const entriesPath = path.join(rootDir, TASKS_ROOT, ENTRIES_DIR);
+  if (!fs.existsSync(entriesPath)) return [];
+  const effectiveFilter = { status: "open", limit: 20, ...filter };
+  const tasks = [];
+  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((f) => f.endsWith(".yaml")).sort();
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(path.join(dirPath, file), "utf8");
+        const task = yaml.load(content);
+        tasks.push(task);
+      } catch {
+      }
+    }
+  }
+  return applyFilter(tasks, effectiveFilter);
+}
+async function loadTask(rootDir, taskId) {
+  const dateMatch = taskId.match(/^T-(\d{4}-\d{2}-\d{2})-/);
+  if (dateMatch) {
+    const filePath = path.join(rootDir, TASKS_ROOT, ENTRIES_DIR, dateMatch[1], `${taskId}.yaml`);
+    if (fs.existsSync(filePath)) {
+      try {
+        return yaml.load(fs.readFileSync(filePath, "utf8"));
+      } catch {
+        return null;
+      }
+    }
+  }
+  const tasks = await loadTasks(rootDir, { status: "all", limit: 9999 });
+  return tasks.find((t) => t.id === taskId) || null;
+}
+async function createTask(rootDir, task) {
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = now.toISOString().slice(0, 10);
+  const datePath = path.join(rootDir, TASKS_ROOT, ENTRIES_DIR, dateStr);
+  fs.mkdirSync(datePath, { recursive: true });
+  const id = generateTaskId(rootDir, dateStr);
+  const entry = {
+    id,
+    blurb: task.blurb,
+    priority: task.priority || "medium",
+    status: "open",
+    tags: task.tags || [],
+    created: now.toISOString(),
+    session_link: task.session_link,
+    related_lore: task.related_lore
+  };
+  fs.writeFileSync(path.join(datePath, `${id}.yaml`), yaml.dump(entry, { lineWidth: -1, noRefs: true }));
+  await rebuildTaskIndex(rootDir);
+  return id;
+}
+async function updateTask(rootDir, taskId, partial) {
+  const task = await loadTask(rootDir, taskId);
+  if (!task) return false;
+  const dateStr = task.created.slice(0, 10);
+  const taskPath = path.join(rootDir, TASKS_ROOT, ENTRIES_DIR, dateStr, `${taskId}.yaml`);
+  if (!fs.existsSync(taskPath)) return false;
+  const { id: _id, created: _created, ...safePartial } = partial;
+  const updated = { ...task, ...safePartial };
+  fs.writeFileSync(taskPath, yaml.dump(updated, { lineWidth: -1, noRefs: true }));
+  await rebuildTaskIndex(rootDir);
+  return true;
+}
+async function completeTask(rootDir, taskId) {
+  return updateTask(rootDir, taskId, { status: "done", completed: (/* @__PURE__ */ new Date()).toISOString() });
+}
+async function shelveTask(rootDir, taskId) {
+  return updateTask(rootDir, taskId, { status: "shelved", shelved: (/* @__PURE__ */ new Date()).toISOString() });
+}
+async function rebuildTaskIndex(rootDir) {
+  const entriesPath = path.join(rootDir, TASKS_ROOT, ENTRIES_DIR);
+  const tasksRootPath = path.join(rootDir, TASKS_ROOT);
+  let total = 0, open = 0, done = 0, shelved = 0;
+  if (fs.existsSync(entriesPath)) {
+    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((f) => f.endsWith(".yaml"));
+      for (const file of files) {
+        try {
+          const task = yaml.load(fs.readFileSync(path.join(dirPath, file), "utf8"));
+          total++;
+          if (task.status === "open") open++;
+          else if (task.status === "done") done++;
+          else if (task.status === "shelved") shelved++;
+        } catch {
+        }
+      }
+    }
+  }
+  const index = { version: "1.0", total, open, done, shelved, last_updated: (/* @__PURE__ */ new Date()).toISOString() };
+  fs.mkdirSync(tasksRootPath, { recursive: true });
+  fs.writeFileSync(path.join(tasksRootPath, INDEX_FILE), yaml.dump(index, { lineWidth: -1, noRefs: true }));
+  return index;
+}
+
+export {
+  loadTasks,
+  loadTask,
+  createTask,
+  updateTask,
+  completeTask,
+  shelveTask,
+  rebuildTaskIndex
+};