@a-company/paradigm 3.28.0 → 3.43.0

package/dist/{chunk-MRENOFTR.js → chunk-EDOAWN7J.js}

@@ -8,6 +8,12 @@ import * as path from "path";
 import { glob } from "glob";
 var PurposeItemSchema = z.object({
   description: z.string(),
+  // Component type and hierarchy (v4)
+  type: z.string().optional(),
+  parent: z.string().optional(),
+  anchors: z.array(z.string()).optional(),
+  tags: z.array(z.string()).optional(),
+  // Standard fields
   endpoints: z.array(z.string()).optional(),
   tests: z.array(z.string()).optional(),
   rules: z.record(z.unknown()).optional(),
@@ -19,7 +25,6 @@ var PurposeItemSchema = z.object({
   states: z.array(z.string()).optional(),
   components: z.array(z.string()).optional(),
   // Extra fields preserved
-  tags: z.array(z.string()).optional(),
   location: z.string().optional(),
   locations: z.array(z.string()).optional(),
   uses: z.array(z.string()).optional(),

package/dist/chunk-F3BCHPYT.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+
+// src/graph-server/routes/symbols.ts
+import { Router } from "express";
+import * as fs from "fs";
+import * as path from "path";
+function createSymbolsRouter(projectDir) {
+  const router = Router();
+  router.get("/", (_req, res) => {
+    const indexPath = path.join(projectDir, ".paradigm", "scan-index.json");
+    if (!fs.existsSync(indexPath)) {
+      res.status(404).json({
+        error: "scan-index.json not found",
+        hint: "Run `paradigm scan` to generate the symbol index."
+      });
+      return;
+    }
+    try {
+      const raw = fs.readFileSync(indexPath, "utf-8");
+      const index = JSON.parse(raw);
+      const categoryMap = {
+        components: "component",
+        features: "component",
+        flows: "flow",
+        state: "component",
+        gates: "gate",
+        signals: "signal",
+        aspects: "aspect",
+        screens: "component"
+      };
+      const prefixMap = {
+        component: "#",
+        flow: "$",
+        gate: "^",
+        signal: "!",
+        aspect: "~"
+      };
+      const symbols = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const [sectionKey, category] of Object.entries(categoryMap)) {
+        const entries = index[sectionKey];
+        if (!entries || typeof entries !== "object") continue;
+        const items = Array.isArray(entries) ? entries : Object.values(entries);
+        for (const entry of items) {
+          const name = entry.name || entry.id || "";
+          if (!name || seen.has(name)) continue;
+          seen.add(name);
+          symbols.push({
+            id: name,
+            name,
+            category,
+            prefix: prefixMap[category] || "#",
+            description: entry.description || "",
+            path: entry.path || entry.file || "",
+            tags: entry.tags || [],
+            related: entry.related || []
+          });
+        }
+      }
+      res.json({
+        symbols,
+        meta: {
+          total: symbols.length,
+          projectDir,
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+    } catch (err) {
+      res.status(500).json({
+        error: "Failed to read scan-index.json",
+        details: err.message
+      });
+    }
+  });
+  return router;
+}
+
+// src/graph-server/routes/graphs.ts
+import { Router as Router2 } from "express";
+import * as fs2 from "fs";
+import * as path2 from "path";
+var GRAPHS_DIR = ".paradigm/graphs";
+function createGraphsRouter(projectDir) {
+  const router = Router2();
+  const graphsPath = path2.join(projectDir, GRAPHS_DIR);
+  router.get("/", (_req, res) => {
+    if (!fs2.existsSync(graphsPath)) {
+      res.json({ graphs: [] });
+      return;
+    }
+    try {
+      const files = fs2.readdirSync(graphsPath).filter((f) => f.endsWith(".graph.json"));
+      const graphs = files.map((file) => {
+        const filePath = path2.join(graphsPath, file);
+        const stat = fs2.statSync(filePath);
+        const slug = file.replace(/\.graph\.json$/, "");
+        let name = slug;
+        let nodeCount = 0;
+        let edgeCount = 0;
+        try {
+          const raw = JSON.parse(fs2.readFileSync(filePath, "utf8"));
+          name = raw.name || slug;
+          nodeCount = Array.isArray(raw.nodes) ? raw.nodes.length : 0;
+          edgeCount = Array.isArray(raw.edges) ? raw.edges.length : 0;
+        } catch {
+        }
+        return {
+          slug,
+          file,
+          name,
+          nodes: nodeCount,
+          edges: edgeCount,
+          size: stat.size,
+          modified: stat.mtime.toISOString()
+        };
+      });
+      graphs.sort((a, b) => b.modified.localeCompare(a.modified));
+      res.json({ graphs });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to list graphs", details: err.message });
+    }
+  });
+  router.get("/:slug", (req, res) => {
+    const slug = req.params.slug;
+    const filePath = path2.join(graphsPath, `${slug}.graph.json`);
+    if (!fs2.existsSync(filePath)) {
+      res.status(404).json({ error: `Graph "${slug}" not found` });
+      return;
+    }
+    try {
+      const raw = fs2.readFileSync(filePath, "utf8");
+      res.type("application/json").send(raw);
+    } catch (err) {
+      res.status(500).json({ error: "Failed to read graph", details: err.message });
+    }
+  });
+  return router;
+}
+
+export {
+  createSymbolsRouter,
+  createGraphsRouter
+};

package/dist/chunk-GT5QGC2H.js

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+
+// src/core/university/storage.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+var UNIVERSITY_DIR = ".paradigm/university";
+var CONTENT_DIR = "content";
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) return null;
+  try {
+    const frontmatter = yaml.load(match[1]);
+    return { frontmatter, body: match[2].trim() };
+  } catch {
+    return null;
+  }
+}
+function serializeFrontmatter(frontmatter, body) {
+  const fm = yaml.dump(frontmatter, { lineWidth: -1, noRefs: true, sortKeys: false });
+  return `---
+${fm}---
+
+${body}
+`;
+}
+function loadUniversityIndex(rootDir) {
+  const indexPath = path.join(rootDir, UNIVERSITY_DIR, "index.yaml");
+  if (!fs.existsSync(indexPath)) return null;
+  try {
+    return yaml.load(fs.readFileSync(indexPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function resolveFile(rootDir, id, ext) {
+  const base = path.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR);
+  for (const subdir of ["notes", "policies", "quizzes", "paths"]) {
+    const fp = path.join(base, subdir, `${id}${ext}`);
+    if (fs.existsSync(fp)) return fp;
+  }
+  return null;
+}
+function loadNote(rootDir, id) {
+  const fp = resolveFile(rootDir, id, ".md");
+  if (!fp) return null;
+  try {
+    const parsed = parseFrontmatter(fs.readFileSync(fp, "utf8"));
+    if (!parsed) return null;
+    const fm = parsed.frontmatter;
+    return {
+      frontmatter: {
+        ...fm,
+        tags: fm.tags || [],
+        symbols: fm.symbols || [],
+        prerequisites: fm.prerequisites || []
+      },
+      body: parsed.body
+    };
+  } catch {
+    return null;
+  }
+}
+function loadQuiz(rootDir, id) {
+  const fp = resolveFile(rootDir, id, ".yaml");
+  if (!fp) return null;
+  try {
+    const data = yaml.load(fs.readFileSync(fp, "utf8"));
+    if (!data?.id) return null;
+    return { ...data, tags: data.tags || [], symbols: data.symbols || [], questions: data.questions || [] };
+  } catch {
+    return null;
+  }
+}
+function loadPath(rootDir, id) {
+  const fp = resolveFile(rootDir, id, ".yaml");
+  if (!fp) return null;
+  try {
+    const data = yaml.load(fs.readFileSync(fp, "utf8"));
+    if (!data?.id) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+function loadDiplomas(rootDir, filter) {
+  const dir = path.join(rootDir, UNIVERSITY_DIR, "diplomas");
+  if (!fs.existsSync(dir)) return [];
+  const results = [];
+  try {
+    for (const file of fs.readdirSync(dir).filter((f) => f.endsWith(".yaml"))) {
+      try {
+        const d = yaml.load(fs.readFileSync(path.join(dir, file), "utf8"));
+        if (!d?.id) continue;
+        if (filter?.student && d.student !== filter.student) continue;
+        if (filter?.type && d.type !== filter.type) continue;
+        results.push(d);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return results.sort((a, b) => b.earnedAt.localeCompare(a.earnedAt));
+}
+function saveNote(rootDir, frontmatter, body) {
+  const subdir = frontmatter.type === "policy" ? "policies" : "notes";
+  const dir = path.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR, subdir);
+  fs.mkdirSync(dir, { recursive: true });
+  const fp = path.join(dir, `${frontmatter.id}.md`);
+  fs.writeFileSync(fp, serializeFrontmatter(frontmatter, body), "utf8");
+  return fp;
+}
+function saveQuiz(rootDir, quiz) {
+  const dir = path.join(rootDir, UNIVERSITY_DIR, CONTENT_DIR, "quizzes");
+  fs.mkdirSync(dir, { recursive: true });
+  const fp = path.join(dir, `${quiz.id}.yaml`);
+  fs.writeFileSync(fp, yaml.dump(quiz, { lineWidth: -1, noRefs: true }), "utf8");
+  return fp;
+}
+function saveDiploma(rootDir, diploma) {
+  const dir = path.join(rootDir, UNIVERSITY_DIR, "diplomas");
+  fs.mkdirSync(dir, { recursive: true });
+  const fp = path.join(dir, `${diploma.id}.yaml`);
+  fs.writeFileSync(fp, yaml.dump(diploma, { lineWidth: -1, noRefs: true }), "utf8");
+  return fp;
+}
+function rebuildUniversityIndex(rootDir) {
+  const uniDir = path.join(rootDir, UNIVERSITY_DIR);
+  const contentBase = path.join(uniDir, CONTENT_DIR);
+  const entries = [];
+  for (const subdir of ["notes", "policies"]) {
+    const dir = path.join(contentBase, subdir);
+    if (!fs.existsSync(dir)) continue;
+    try {
+      for (const file of fs.readdirSync(dir).filter((f) => f.endsWith(".md"))) {
+        try {
+          const raw = fs.readFileSync(path.join(dir, file), "utf8");
+          const parsed = parseFrontmatter(raw);
+          if (!parsed) continue;
+          const fm = parsed.frontmatter;
+          entries.push({
+            id: fm.id || file.replace(".md", ""),
+            title: fm.title || file,
+            type: fm.type || (subdir === "policies" ? "policy" : "note"),
+            author: fm.author || "unknown",
+            created: fm.created || "",
+            updated: fm.updated || "",
+            tags: Array.isArray(fm.tags) ? fm.tags : [],
+            symbols: Array.isArray(fm.symbols) ? fm.symbols : [],
+            difficulty: fm.difficulty || "beginner",
+            file: `${CONTENT_DIR}/${subdir}/${file}`
+          });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  const quizDir = path.join(contentBase, "quizzes");
+  if (fs.existsSync(quizDir)) {
+    try {
+      for (const file of fs.readdirSync(quizDir).filter((f) => f.endsWith(".yaml"))) {
+        try {
+          const data = yaml.load(fs.readFileSync(path.join(quizDir, file), "utf8"));
+          if (!data?.id) continue;
+          entries.push({
+            id: data.id,
+            title: data.title || file,
+            type: "quiz",
+            author: data.author || "unknown",
+            created: data.created || "",
+            updated: data.updated || "",
+            tags: data.tags || [],
+            symbols: data.symbols || [],
+            difficulty: data.difficulty || "beginner",
+            file: `${CONTENT_DIR}/quizzes/${file}`
+          });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  const pathDir = path.join(contentBase, "paths");
+  if (fs.existsSync(pathDir)) {
+    try {
+      for (const file of fs.readdirSync(pathDir).filter((f) => f.endsWith(".yaml"))) {
+        try {
+          const data = yaml.load(fs.readFileSync(path.join(pathDir, file), "utf8"));
+          if (!data?.id) continue;
+          entries.push({
+            id: data.id,
+            title: data.title || file,
+            type: "path",
+            author: data.author || "unknown",
+            created: data.created || "",
+            updated: data.updated || "",
+            tags: data.tags || [],
+            symbols: [],
+            file: `${CONTENT_DIR}/paths/${file}`
+          });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  let diplomaCount = 0;
+  const diplomaDir = path.join(uniDir, "diplomas");
+  if (fs.existsSync(diplomaDir)) {
+    try {
+      diplomaCount = fs.readdirSync(diplomaDir).filter((f) => f.endsWith(".yaml")).length;
+    } catch {
+    }
+  }
+  const index = {
+    version: "1.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalContent: entries.length,
+    entries,
+    diplomaCount
+  };
+  fs.mkdirSync(uniDir, { recursive: true });
+  fs.writeFileSync(path.join(uniDir, "index.yaml"), yaml.dump(index, { lineWidth: -1, noRefs: true }), "utf8");
+  return index;
+}
+function searchContent(rootDir, filter) {
+  const index = loadUniversityIndex(rootDir);
+  if (!index) return [];
+  let results = [...index.entries];
+  if (filter.type) results = results.filter((e) => e.type === filter.type);
+  if (filter.tag) results = results.filter((e) => e.tags.some((t) => t.startsWith(filter.tag)));
+  if (filter.difficulty) results = results.filter((e) => e.difficulty === filter.difficulty);
+  if (filter.symbol) results = results.filter((e) => e.symbols.includes(filter.symbol));
+  if (filter.query) {
+    const q = filter.query.toLowerCase();
+    results = results.filter((e) => e.title.toLowerCase().includes(q) || e.id.toLowerCase().includes(q));
+  }
+  return results.slice(0, filter.limit || 20);
+}
+
+export {
+  loadUniversityIndex,
+  loadNote,
+  loadQuiz,
+  loadPath,
+  loadDiplomas,
+  saveNote,
+  saveQuiz,
+  saveDiploma,
+  rebuildUniversityIndex,
+  searchContent
+};

package/dist/{chunk-N6RNYCZD.js → chunk-HIKKOCXY.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   BackgroundOrchestrator
-} from "./chunk-ZOH24ZPF.js";
+} from "./chunk-QWA26UNO.js";
 import {
   AGENT_MODEL_RECOMMENDATIONS,
   addActivity,

package/dist/{chunk-J26YQVAK.js → chunk-J4E6K5MG.js}

@@ -5,7 +5,7 @@ import {
 import {
   getProvider,
   initializeProviders
-} from "./chunk-5SXMV4SP.js";
+} from "./chunk-FS3WTUHY.js";
 import {
   loadAgentsManifest
 } from "./chunk-PMXRGPRQ.js";