@a-company/paradigm 1.5.0

package/dist/chunk-5C4SGQKH.js

@@ -0,0 +1,705 @@
+#!/usr/bin/env node
+import {
+  extractAspects,
+  extractComponents,
+  extractFeatures,
+  extractFlows,
+  extractGates,
+  extractSignals,
+  extractStates,
+  extractSymbolReferences,
+  getAllPurposeFiles
+} from "./chunk-PW2EXJQT.js";
+import {
+  findGateFiles,
+  parseGateConfig
+} from "./chunk-IRKUEJVW.js";
+
+// ../premise/core/dist/index.js
+import * as fs from "fs";
+import * as yaml from "js-yaml";
+import { z } from "zod";
+import * as path from "path";
+var SYMBOL_PREFIXES = {
+  component: "#",
+  flow: "$",
+  gate: "^",
+  signal: "!",
+  aspect: "~"
+};
+var PREFIX_TO_TYPE = {
+  "#": "component",
+  "$": "flow",
+  "^": "gate",
+  "!": "signal",
+  "~": "aspect"
+};
+var VALID_PREFIXES = ["#", "$", "^", "!", "~"];
+function isValidPrefix(prefix) {
+  return VALID_PREFIXES.includes(prefix);
+}
+var PositionSchema = z.object({
+  x: z.number(),
+  y: z.number()
+});
+var ViewportSchema = z.object({
+  x: z.number(),
+  y: z.number(),
+  zoom: z.number()
+});
+var PremiseSourceConfigSchema = z.object({
+  path: z.string(),
+  include: z.array(z.string()).optional(),
+  exclude: z.array(z.string()).optional()
+});
+var PremiseNodeSchema = z.object({
+  id: z.string(),
+  symbol: z.string(),
+  type: z.enum(["feature", "component", "flow", "state", "aspect", "gate", "signal", "idea"]),
+  content: z.string().optional(),
+  position: PositionSchema,
+  tags: z.array(z.string()).optional(),
+  created: z.string(),
+  modified: z.string().optional()
+});
+var PremiseConnectionSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  label: z.string().optional(),
+  type: z.string().optional()
+});
+var PremiseGroupSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  nodes: z.array(z.string()),
+  color: z.string().optional()
+});
+var PremiseLayoutSchema = z.object({
+  viewport: ViewportSchema,
+  groups: z.array(PremiseGroupSchema).optional()
+});
+var PremiseSnapshotStateSchema = z.object({
+  nodes: z.array(PremiseNodeSchema),
+  connections: z.array(PremiseConnectionSchema),
+  layout: PremiseLayoutSchema
+});
+var PremiseSnapshotSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  timestamp: z.string(),
+  description: z.string().optional(),
+  state: PremiseSnapshotStateSchema
+});
+var PremiseFileSchema = z.object({
+  version: z.string(),
+  metadata: z.object({
+    name: z.string(),
+    created: z.string(),
+    modified: z.string()
+  }),
+  sources: z.object({
+    purpose: z.array(PremiseSourceConfigSchema).optional(),
+    portal: z.array(PremiseSourceConfigSchema).optional()
+  }),
+  nodes: z.array(PremiseNodeSchema),
+  connections: z.array(PremiseConnectionSchema),
+  layout: PremiseLayoutSchema,
+  snapshots: z.array(PremiseSnapshotSchema).optional()
+});
+function parsePremiseFile(filePath) {
+  const errors = [];
+  let rawContent;
+  try {
+    rawContent = fs.readFileSync(filePath, "utf8");
+  } catch (e) {
+    errors.push(`Cannot read file: ${e.message}`);
+    return { data: null, errors, rawContent: void 0 };
+  }
+  return parsePremiseContent(rawContent);
+}
+function parsePremiseContent(content) {
+  const errors = [];
+  let data = null;
+  try {
+    data = yaml.load(content);
+  } catch (e) {
+    const yamlError = e;
+    const line = yamlError.mark?.line ? yamlError.mark.line + 1 : void 0;
+    errors.push(`YAML syntax error: ${yamlError.reason || e.message}${line ? ` (line ${line})` : ""}`);
+    return { data: null, errors, rawContent: content };
+  }
+  if (data === null || data === void 0) {
+    return {
+      data: createEmptyPremiseFile(),
+      errors: [],
+      rawContent: content
+    };
+  }
+  const parseResult = PremiseFileSchema.safeParse(data);
+  if (!parseResult.success) {
+    for (const issue of parseResult.error.issues) {
+      const path2 = issue.path.join(".");
+      errors.push(`Schema error at ${path2 || "/"}: ${issue.message}`);
+    }
+    return { data, errors, rawContent: content };
+  }
+  return { data: parseResult.data, errors: [], rawContent: content };
+}
+function createEmptyPremiseFile(name = "Untitled") {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: "1.0.0",
+    metadata: {
+      name,
+      created: now,
+      modified: now
+    },
+    sources: {
+      purpose: [{ path: "./" }],
+      portal: [{ path: "./portal.yaml" }]
+    },
+    nodes: [],
+    connections: [],
+    layout: {
+      viewport: { x: 0, y: 0, zoom: 1 }
+    }
+  };
+}
+function serializePremiseFile(data) {
+  data.metadata.modified = (/* @__PURE__ */ new Date()).toISOString();
+  return yaml.dump(data, {
+    indent: 2,
+    lineWidth: -1,
+    noRefs: true,
+    sortKeys: false
+  });
+}
+function getDefaultPremiseContent(projectName = "My Project") {
+  return serializePremiseFile(createEmptyPremiseFile(projectName));
+}
+function addPremiseNode(premiseFile, node) {
+  return {
+    ...premiseFile,
+    nodes: [...premiseFile.nodes, node],
+    metadata: {
+      ...premiseFile.metadata,
+      modified: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function updateNodePosition(premiseFile, nodeId, position) {
+  return {
+    ...premiseFile,
+    nodes: premiseFile.nodes.map(
+      (n) => n.id === nodeId ? { ...n, position, modified: (/* @__PURE__ */ new Date()).toISOString() } : n
+    ),
+    metadata: {
+      ...premiseFile.metadata,
+      modified: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function addConnection(premiseFile, connection) {
+  const exists = premiseFile.connections.some(
+    (c) => c.from === connection.from && c.to === connection.to
+  );
+  if (exists) return premiseFile;
+  return {
+    ...premiseFile,
+    connections: [...premiseFile.connections, connection],
+    metadata: {
+      ...premiseFile.metadata,
+      modified: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function createSnapshot(premiseFile, name, description) {
+  const snapshot = {
+    id: `snap-${Date.now()}`,
+    name,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    description,
+    state: {
+      nodes: [...premiseFile.nodes],
+      connections: [...premiseFile.connections],
+      layout: { ...premiseFile.layout }
+    }
+  };
+  return {
+    ...premiseFile,
+    snapshots: [...premiseFile.snapshots || [], snapshot],
+    metadata: {
+      ...premiseFile.metadata,
+      modified: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+async function aggregateFromPremise(premiseFile, rootDir) {
+  const symbols = [];
+  const errors = [];
+  const purposeFiles = [];
+  const portalFiles = [];
+  if (premiseFile.sources.purpose) {
+    for (const source of premiseFile.sources.purpose) {
+      const sourcePath = path.resolve(rootDir, source.path);
+      try {
+        const parsed = await getAllPurposeFiles(sourcePath);
+        purposeFiles.push(...parsed.map((p) => p.filePath));
+        const features = extractFeatures(parsed);
+        for (const [id, { item, filePath }] of features) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-feature-${id}`,
+            symbol: `#${id}`,
+            type: "component",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description,
+            tags: ["feature"]
+          }));
+        }
+        const components = extractComponents(parsed);
+        for (const [id, { item, filePath }] of components) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-component-${id}`,
+            symbol: `#${id}`,
+            type: "component",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description
+          }));
+        }
+        const gates = extractGates(parsed);
+        for (const [id, { item, filePath }] of gates) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-gate-${id}`,
+            symbol: `^${id}`,
+            type: "gate",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description
+          }));
+        }
+        const states = extractStates(parsed);
+        for (const [id, { item, filePath }] of states) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-state-${id}`,
+            symbol: `#${id}`,
+            type: "component",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description,
+            tags: ["state"]
+          }));
+        }
+        const flows = extractFlows(parsed);
+        for (const [id, { item, filePath }] of flows) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-flow-${id}`,
+            symbol: `$${id}`,
+            type: "flow",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description
+          }));
+        }
+        const signals = extractSignals(parsed);
+        for (const [id, { item, filePath }] of signals) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-signal-${id}`,
+            symbol: `!${id}`,
+            type: "signal",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description
+          }));
+        }
+        const aspects = extractAspects(parsed);
+        for (const [id, { item, filePath }] of aspects) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-aspect-${id}`,
+            symbol: `~${id}`,
+            type: "aspect",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description,
+            anchors: item.anchors?.map((a) => parseAnchorString(a)),
+            appliesTo: item["applies-to"]
+          }));
+        }
+        const symbolRefs = extractSymbolReferences(parsed);
+        const existingSymbols = new Set(symbols.map((s) => s.symbol));
+        for (const ref of symbolRefs) {
+          if (!existingSymbols.has(ref.symbol)) {
+            existingSymbols.add(ref.symbol);
+            symbols.push(createSymbolEntry({
+              id: `purpose-ref-${ref.type}-${ref.symbol.slice(1)}`,
+              symbol: ref.symbol,
+              type: ref.type,
+              source: "purpose",
+              filePath: ref.filePath,
+              data: { referencedFrom: ref.sourceSymbol },
+              description: `Referenced from ${ref.sourceSymbol}`
+            }));
+          }
+        }
+      } catch (e) {
+        errors.push({
+          source: "purpose",
+          filePath: sourcePath,
+          message: e.message
+        });
+      }
+    }
+  }
+  if (premiseFile.sources.portal) {
+    for (const source of premiseFile.sources.portal) {
+      const sourcePath = path.resolve(rootDir, source.path);
+      try {
+        let gateConfig;
+        if (sourcePath.endsWith(".yaml") || sourcePath.endsWith(".yml")) {
+          gateConfig = await parseGateConfig(sourcePath);
+          portalFiles.push(sourcePath);
+        } else {
+          const files = await findGateFiles(sourcePath);
+          portalFiles.push(...files);
+          if (files.length > 0) {
+            gateConfig = await parseGateConfig(files[0]);
+            for (let i = 1; i < files.length; i++) {
+              const additional = await parseGateConfig(files[i]);
+              gateConfig.gates.push(...additional.gates);
+              gateConfig.flows.push(...additional.flows);
+            }
+          } else {
+            continue;
+          }
+        }
+        for (const gate of gateConfig.gates) {
+          symbols.push(createGateSymbol(gate, sourcePath));
+          for (const prize of gate.prizes) {
+            symbols.push(createSymbolEntry({
+              id: `gate-signal-${gate.id}-${prize.id}`,
+              symbol: `!${prize.id}`,
+              type: "signal",
+              source: "portal",
+              filePath: sourcePath,
+              data: prize,
+              description: `Signal from gate ${gate.id}`
+            }));
+          }
+        }
+        for (const flow of gateConfig.flows) {
+          symbols.push(createFlowSymbol(flow, sourcePath));
+        }
+      } catch (e) {
+        errors.push({
+          source: "portal",
+          filePath: sourcePath,
+          message: e.message
+        });
+      }
+    }
+  }
+  for (const node of premiseFile.nodes) {
+    const hasIdeaTag = node.tags?.includes("idea");
+    if (!node.content && !hasIdeaTag) {
+      const existing = symbols.find((s) => s.symbol === node.symbol);
+      if (existing) {
+        existing.position = node.position;
+        existing.tags = node.tags;
+        continue;
+      }
+    }
+    symbols.push(createSymbolEntry({
+      id: node.id,
+      symbol: node.symbol,
+      type: node.type,
+      source: "premise",
+      filePath: ".premise",
+      data: node,
+      description: node.content,
+      position: node.position,
+      tags: node.tags,
+      created: node.created,
+      modified: node.modified
+    }));
+  }
+  resolveReferences(symbols);
+  return {
+    symbols,
+    purposeFiles,
+    portalFiles,
+    errors,
+    timestamp: Date.now()
+  };
+}
+function createSymbolEntry(partial) {
+  return {
+    ...partial,
+    data: partial.data ?? null,
+    references: partial.references ?? [],
+    referencedBy: partial.referencedBy ?? []
+  };
+}
+function createGateSymbol(gate, filePath) {
+  return createSymbolEntry({
+    id: `gate-${gate.id}`,
+    symbol: `^${gate.id}`,
+    type: "gate",
+    source: "portal",
+    filePath,
+    data: gate,
+    description: gate.description,
+    position: gate.position
+  });
+}
+function createFlowSymbol(flow, filePath) {
+  return createSymbolEntry({
+    id: `gate-flow-${flow.id}`,
+    symbol: `$${flow.id}`,
+    type: "flow",
+    source: "portal",
+    filePath,
+    data: flow,
+    description: flow.description
+  });
+}
+function parseAnchorString(raw) {
+  const colonIndex = raw.lastIndexOf(":");
+  if (colonIndex === -1 || colonIndex === raw.length - 1) {
+    return { path: raw, lines: 0, raw };
+  }
+  const afterColon = raw.slice(colonIndex + 1);
+  const filePath = raw.slice(0, colonIndex);
+  if (!/^[\d,\- ]+$/.test(afterColon)) {
+    return { path: raw, lines: 0, raw };
+  }
+  if (afterColon.includes("-")) {
+    const [start, end] = afterColon.split("-").map(Number);
+    return { path: filePath, lines: [start, end], raw };
+  } else if (afterColon.includes(",")) {
+    const lines = afterColon.split(",").map(Number);
+    return { path: filePath, lines, raw };
+  } else {
+    return { path: filePath, lines: Number(afterColon), raw };
+  }
+}
+var SYMBOL_BLOCKLIST = /* @__PURE__ */ new Set([
+  "$lib",
+  "$env",
+  "$app",
+  "$service-worker",
+  "$virtual",
+  "$schema",
+  "$ref",
+  "$id",
+  "$type"
+]);
+function resolveReferences(symbols) {
+  const symbolMap = new Map(symbols.map((s) => [s.symbol, s]));
+  for (const symbol of symbols) {
+    const dataStr = JSON.stringify(symbol.data);
+    const refPattern = /(?:\?[@#$%~^!]|[@#$%~^!?])[a-zA-Z][\w-]*/g;
+    const matches = (dataStr.match(refPattern) || []).filter((m) => !SYMBOL_BLOCKLIST.has(m));
+    for (const match of matches) {
+      if (match !== symbol.symbol && symbolMap.has(match)) {
+        if (!symbol.references.includes(match)) {
+          symbol.references.push(match);
+        }
+        const target = symbolMap.get(match);
+        if (target && !target.referencedBy.includes(symbol.symbol)) {
+          target.referencedBy.push(symbol.symbol);
+        }
+      }
+    }
+  }
+}
+async function aggregateFromDirectory(rootDir) {
+  const premiseFile = {
+    version: "1.0.0",
+    metadata: {
+      name: path.basename(rootDir),
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      modified: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    sources: {
+      purpose: [{ path: "./" }],
+      portal: [{ path: "./" }]
+    },
+    nodes: [],
+    connections: [],
+    layout: {
+      viewport: { x: 0, y: 0, zoom: 1 }
+    }
+  };
+  return aggregateFromPremise(premiseFile, rootDir);
+}
+function createSymbolIndex() {
+  return {
+    entries: /* @__PURE__ */ new Map(),
+    byType: /* @__PURE__ */ new Map(),
+    bySource: /* @__PURE__ */ new Map(),
+    timestamp: 0
+  };
+}
+function buildSymbolIndex(result) {
+  const index = createSymbolIndex();
+  index.timestamp = result.timestamp;
+  for (const symbol of result.symbols) {
+    index.entries.set(symbol.id, symbol);
+    if (!index.byType.has(symbol.type)) {
+      index.byType.set(symbol.type, []);
+    }
+    index.byType.get(symbol.type).push(symbol);
+    if (!index.bySource.has(symbol.source)) {
+      index.bySource.set(symbol.source, []);
+    }
+    index.bySource.get(symbol.source).push(symbol);
+  }
+  return index;
+}
+function getSymbol(index, symbol) {
+  for (const entry of index.entries.values()) {
+    if (entry.symbol === symbol) {
+      return entry;
+    }
+  }
+  return void 0;
+}
+function getSymbolById(index, id) {
+  return index.entries.get(id);
+}
+function getSymbolsByType(index, type) {
+  return index.byType.get(type) || [];
+}
+function getSymbolsBySource(index, source) {
+  return index.bySource.get(source) || [];
+}
+function searchSymbols(index, query) {
+  const lowerQuery = query.toLowerCase();
+  const results = [];
+  for (const entry of index.entries.values()) {
+    if (entry.symbol.toLowerCase().includes(lowerQuery)) {
+      results.push(entry);
+      continue;
+    }
+    if (entry.description?.toLowerCase().includes(lowerQuery)) {
+      results.push(entry);
+      continue;
+    }
+    if (entry.tags?.some((tag) => tag.toLowerCase().includes(lowerQuery))) {
+      results.push(entry);
+    }
+  }
+  return results;
+}
+function getReferencesTo(index, symbol) {
+  const entry = getSymbol(index, symbol);
+  if (!entry) return [];
+  return entry.referencedBy.map((ref) => getSymbol(index, ref)).filter((e) => e !== void 0);
+}
+function getReferencesFrom(index, symbol) {
+  const entry = getSymbol(index, symbol);
+  if (!entry) return [];
+  return entry.references.map((ref) => getSymbol(index, ref)).filter((e) => e !== void 0);
+}
+function getSymbolsByTag(index, tag) {
+  const results = [];
+  for (const entry of index.entries.values()) {
+    if (entry.tags?.includes(tag)) {
+      results.push(entry);
+    }
+  }
+  return results;
+}
+function getAllTags(index) {
+  const tags = /* @__PURE__ */ new Set();
+  for (const entry of index.entries.values()) {
+    for (const tag of entry.tags || []) {
+      tags.add(tag);
+    }
+  }
+  return Array.from(tags).sort();
+}
+function getSymbolCounts(index) {
+  const counts = {
+    component: 0,
+    flow: 0,
+    gate: 0,
+    signal: 0,
+    aspect: 0
+  };
+  for (const [type, symbols] of index.byType) {
+    if (type in counts) {
+      counts[type] = symbols.length;
+    }
+  }
+  return counts;
+}
+function getAllSymbols(index) {
+  return Array.from(index.entries.values());
+}
+function parseSymbol(symbol) {
+  if (symbol.length < 2) return null;
+  const prefix = symbol[0];
+  const name = symbol.slice(1);
+  if (!isValidPrefix(prefix)) {
+    return null;
+  }
+  const type = PREFIX_TO_TYPE[prefix];
+  return { type, name };
+}
+function createSymbolString(type, name) {
+  return `${SYMBOL_PREFIXES[type]}${name}`;
+}
+function isValidSymbol(symbol) {
+  return parseSymbol(symbol) !== null;
+}
+function getAutocompleteSuggestions(index, partial, limit = 10) {
+  const lowerPartial = partial.toLowerCase();
+  const parsed = parseSymbol(partial);
+  if (parsed) {
+    const typeSymbols = getSymbolsByType(index, parsed.type);
+    return typeSymbols.filter((s) => s.symbol.toLowerCase().includes(lowerPartial)).slice(0, limit);
+  }
+  return searchSymbols(index, partial).slice(0, limit);
+}
+
+export {
+  SYMBOL_PREFIXES,
+  PREFIX_TO_TYPE,
+  parsePremiseFile,
+  parsePremiseContent,
+  createEmptyPremiseFile,
+  serializePremiseFile,
+  getDefaultPremiseContent,
+  addPremiseNode,
+  updateNodePosition,
+  addConnection,
+  createSnapshot,
+  aggregateFromPremise,
+  aggregateFromDirectory,
+  createSymbolIndex,
+  buildSymbolIndex,
+  getSymbol,
+  getSymbolById,
+  getSymbolsByType,
+  getSymbolsBySource,
+  searchSymbols,
+  getReferencesTo,
+  getReferencesFrom,
+  getSymbolsByTag,
+  getAllTags,
+  getSymbolCounts,
+  getAllSymbols,
+  parseSymbol,
+  createSymbolString,
+  isValidSymbol,
+  getAutocompleteSuggestions
+};