@a-company/paradigm 5.11.0 → 5.21.0

package/dist/chunk-ZGUAAVMA.js

@@ -1,756 +0,0 @@
-#!/usr/bin/env node
-import {
-  extractAspects,
-  extractComponents,
-  extractFeatures,
-  extractFlows,
-  extractGates,
-  extractSignals,
-  extractStates,
-  extractSymbolReferences,
-  getAllPurposeFiles
-} from "./chunk-EDOAWN7J.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) {
-          const featureTags = ["feature", ...item.tags || []];
-          symbols.push(createSymbolEntry({
-            id: `purpose-feature-${id}`,
-            symbol: `#${id}`,
-            type: "component",
-            source: "purpose",
-            filePath,
-            data: item,
-            description: item.description,
-            tags: featureTags,
-            componentType: item.type,
-            parentSymbol: item.parent,
-            anchors: item.anchors?.map((a) => parseAnchorString(a))
-          }));
-        }
-        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,
-            tags: item.tags,
-            componentType: item.type,
-            parentSymbol: item.parent,
-            anchors: item.anchors?.map((a) => parseAnchorString(a))
-          }));
-        }
-        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"],
-            tags: item.tags,
-            enforcement: item.enforcement
-          }));
-        }
-        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);
-  const symbolFileMap = /* @__PURE__ */ new Map();
-  for (const sym of symbols) {
-    const files = symbolFileMap.get(sym.symbol) || [];
-    if (!files.includes(sym.filePath)) {
-      files.push(sym.filePath);
-    }
-    symbolFileMap.set(sym.symbol, files);
-  }
-  const duplicateSymbols = [];
-  for (const [symbol, files] of symbolFileMap) {
-    if (files.length > 1) {
-      duplicateSymbols.push({ symbol, files });
-    }
-  }
-  return {
-    symbols,
-    purposeFiles,
-    portalFiles,
-    errors,
-    timestamp: Date.now(),
-    ...duplicateSymbols.length > 0 ? { duplicateSymbols } : {}
-  };
-}
-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);
-      continue;
-    }
-    if (entry.componentType?.toLowerCase().includes(lowerQuery)) {
-      results.push(entry);
-      continue;
-    }
-  }
-  return results;
-}
-function getComponentsByType(index, componentType) {
-  const components = getSymbolsByType(index, "component");
-  return components.filter((c) => c.componentType === componentType);
-}
-function getAllComponentTypes(index) {
-  const types = /* @__PURE__ */ new Set();
-  const components = getSymbolsByType(index, "component");
-  for (const comp of components) {
-    if (comp.componentType) {
-      types.add(comp.componentType);
-    }
-  }
-  return Array.from(types).sort();
-}
-function getChildComponents(index, parentSymbol) {
-  const components = getSymbolsByType(index, "component");
-  return components.filter((c) => c.parentSymbol === parentSymbol);
-}
-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,
-  getComponentsByType,
-  getAllComponentTypes,
-  getChildComponents,
-  getReferencesTo,
-  getReferencesFrom,
-  getSymbolsByTag,
-  getAllTags,
-  getSymbolCounts,
-  getAllSymbols,
-  parseSymbol,
-  createSymbolString,
-  isValidSymbol,
-  getAutocompleteSuggestions
-};