@topogram/cli 0.3.63 → 0.3.65

package/src/resolver/shared.js

@@ -0,0 +1,278 @@
+import { blockEntries, getFieldValue, symbolValues, valueAsArray } from "../validator.js";
+
+export function groupBy(items, keyFn) {
+  const grouped = {};
+  for (const item of items) {
+    const key = keyFn(item);
+    if (!Object.hasOwn(grouped, key)) {
+      grouped[key] = [];
+    }
+    grouped[key].push(item);
+  }
+  return grouped;
+}
+
+export function resolveReference(registry, id) {
+  return registry.get(id) || null;
+}
+
+export function toRef(target) {
+  if (!target) {
+    return null;
+  }
+
+  return {
+    id: target.id,
+    kind: target.kind
+  };
+}
+
+export function resolveReferenceList(registry, value) {
+  return symbolValues(value).map((id) => ({
+    id,
+    target: toRef(resolveReference(registry, id))
+  }));
+}
+
+export function resolveDomainTag(statement, registry) {
+  const domainField = statement.fields.find((field) => field.key === "domain");
+  if (!domainField || domainField.value.type !== "symbol") {
+    return null;
+  }
+  const id = domainField.value.value;
+  return {
+    id,
+    target: toRef(resolveReference(registry, id))
+  };
+}
+
+export function normalizeDomainScopeList(statement, key) {
+  const field = statement.fields.find((f) => f.key === key);
+  if (!field) return [];
+  const items = field.value.type === "list" || field.value.type === "sequence"
+    ? field.value.items
+    : [field.value];
+  return items
+    .map((item) => (item.type === "string" || item.type === "symbol" ? item.value : null))
+    .filter((value) => value !== null);
+}
+
+export function normalizeSequence(items) {
+  return items.map((item) => {
+    if (item.type === "symbol" || item.type === "string") {
+      return item.value;
+    }
+    if (item.type === "list") {
+      return item.items.map((nested) => nested.value);
+    }
+    return item.type;
+  });
+}
+
+export function normalizeFieldsBlock(statement, key = "fields") {
+  return blockEntries(getFieldValue(statement, key)).map((entry) => {
+    const [name, type, requiredness, ...rest] = entry.items;
+    let defaultValue = null;
+
+    for (let i = 0; i < rest.length - 1; i += 1) {
+      if (rest[i].type === "symbol" && rest[i].value === "default") {
+        defaultValue = rest[i + 1]?.value ?? null;
+      }
+    }
+
+    return {
+      name: name?.value ?? null,
+      fieldType: type?.value ?? null,
+      requiredness: requiredness?.value ?? null,
+      defaultValue,
+      raw: normalizeSequence(entry.items),
+      loc: entry.loc
+    };
+  });
+}
+
+export function normalizeGenericBlock(statement, key) {
+  return blockEntries(getFieldValue(statement, key)).map((entry) => ({
+    raw: normalizeSequence(entry.items),
+    loc: entry.loc
+  }));
+}
+
+export function tokenValue(token) {
+  return token?.value ?? null;
+}
+
+export function parseDefaultLiteral(token) {
+  if (!token) return null;
+  if (token.type === "list") {
+    return (token.items || []).map((item) => parseDefaultLiteral(item));
+  }
+  if (token.type === "string") {
+    return token.value ?? null;
+  }
+  if (token.type === "symbol") {
+    if (token.value === "true") return true;
+    if (token.value === "false") return false;
+    if (token.value === "null") return null;
+    if (/^-?\d+$/.test(token.value)) return Number.parseInt(token.value, 10);
+    if (/^-?\d+\.\d+$/.test(token.value)) return Number.parseFloat(token.value);
+    return token.value;
+  }
+  return token.value ?? null;
+}
+
+export function parseLiteralToken(token) {
+  const value = tokenValue(token);
+  if (value == null) {
+    return null;
+  }
+
+  if (value === "true") {
+    return { kind: "boolean", value: true };
+  }
+  if (value === "false") {
+    return { kind: "boolean", value: false };
+  }
+  if (value === "null") {
+    return { kind: "null", value: null };
+  }
+  if (/^-?\d+$/.test(value)) {
+    return { kind: "integer", value: Number.parseInt(value, 10) };
+  }
+  if (/^-?\d+\.\d+$/.test(value)) {
+    return { kind: "number", value: Number.parseFloat(value) };
+  }
+
+  return { kind: "symbol", value };
+}
+
+export function parseComparison(left, operator, right) {
+  if (!left || !operator || !right) {
+    return null;
+  }
+
+  return {
+    type: "comparison",
+    left: tokenValue(left),
+    operator,
+    right: parseLiteralToken(right)
+  };
+}
+
+export function parseInvariantEntry(entry) {
+  const tokens = entry.items;
+  const values = tokens.map((item) => item.value);
+  const [a, b, c, d, e, f, g] = tokens;
+
+  if (tokenValue(b) === "requires") {
+    return {
+      type: "requires",
+      field: tokenValue(a),
+      predicate: parseComparison(c, tokenValue(d), e),
+      raw: values,
+      loc: entry.loc
+    };
+  }
+
+  if (tokenValue(b) === "length") {
+    return {
+      type: "length_check",
+      field: tokenValue(a),
+      operator: tokenValue(c),
+      value: parseLiteralToken(d),
+      raw: values,
+      loc: entry.loc
+    };
+  }
+
+  if (tokenValue(b) === "format") {
+    return {
+      type: "format_check",
+      field: tokenValue(a),
+      operator: tokenValue(c),
+      format: tokenValue(d),
+      raw: values,
+      loc: entry.loc
+    };
+  }
+
+  if (tokenValue(d) === "implies") {
+    return {
+      type: "implication",
+      when: parseComparison(a, tokenValue(b), c),
+      then:
+        tokenValue(f) === "is"
+          ? {
+              type: "state_check",
+              field: tokenValue(e),
+              operator: "is",
+              value: parseLiteralToken(g)
+            }
+          : parseComparison(e, tokenValue(f), g),
+      raw: values,
+      loc: entry.loc
+    };
+  }
+
+  if (["==", "!=", "<", "<=", ">", ">="].includes(tokenValue(b))) {
+    return {
+      type: "comparison",
+      left: tokenValue(a),
+      operator: tokenValue(b),
+      right: parseLiteralToken(c),
+      raw: values,
+      loc: entry.loc
+    };
+  }
+
+  return {
+    type: "unknown",
+    raw: values,
+    loc: entry.loc
+  };
+}
+
+export function parseRuleExpression(value) {
+  const text = valueAsArray(value).map((item) => item.value).join(" ").trim();
+  const match = text.match(/^(.+?)\s*(==|!=|<=|>=|<|>)\s*(.+)$/);
+  if (!match) {
+    return {
+      type: "unknown",
+      raw: text
+    };
+  }
+
+  return {
+    type: "comparison",
+    left: match[1].trim(),
+    operator: match[2],
+    right: {
+      kind: "symbol",
+      value: match[3].trim()
+    },
+    raw: text
+  };
+}
+
+export function parseSymbolNode(value) {
+  return {
+    type: "symbol",
+    id: value
+  };
+}
+
+export function parseSymbolNodes(values) {
+  return values.map((value, index) => ({
+    ...parseSymbolNode(value),
+    order: index
+  }));
+}
+
+export function parseReferenceNodes(values) {
+  return values.map((entry, index) => ({
+    type: "reference",
+    id: entry.id,
+    target: entry.target || { id: entry.id, kind: null },
+    order: index
+  }));
+}

package/src/resolver/widgets.js

@@ -0,0 +1,132 @@
+import { blockEntries, getFieldValue, symbolValues } from "../validator.js";
+import { normalizeSequence, parseDefaultLiteral, parseReferenceNodes, tokenValue } from "./shared.js";
+
+export function normalizeWidgetProps(statement) {
+  return blockEntries(getFieldValue(statement, "props")).map((entry) => {
+    const [name, type, requiredness, ...rest] = entry.items;
+    let defaultValue = null;
+
+    for (let i = 0; i < rest.length - 1; i += 1) {
+      if (rest[i].type === "symbol" && rest[i].value === "default") {
+        defaultValue = parseDefaultLiteral(rest[i + 1]);
+      }
+    }
+
+    return {
+      name: name?.value ?? null,
+      fieldType: type?.value ?? null,
+      requiredness: requiredness?.value ?? null,
+      defaultValue,
+      raw: normalizeSequence(entry.items),
+      loc: entry.loc
+    };
+  });
+}
+
+export function normalizeWidgetEvents(statement, registry) {
+  return blockEntries(getFieldValue(statement, "events")).map((entry) => {
+    const [eventName, shapeRef] = entry.items;
+    const shapeId = tokenValue(shapeRef);
+    return {
+      id: tokenValue(eventName),
+      shape: shapeId
+        ? {
+            id: shapeId,
+            kind: registry.get(shapeId)?.kind || null
+          }
+        : null,
+      raw: normalizeSequence(entry.items),
+      loc: entry.loc
+    };
+  });
+}
+
+export function normalizeWidgetSlots(statement) {
+  return blockEntries(getFieldValue(statement, "slots")).map((entry) => ({
+    id: tokenValue(entry.items[0]),
+    description: tokenValue(entry.items[1]),
+    raw: normalizeSequence(entry.items),
+    loc: entry.loc
+  }));
+}
+
+export function normalizeBehaviorValue(token) {
+  if (!token) {
+    return null;
+  }
+  if (token.type === "list") {
+    return token.items.map((item) => normalizeBehaviorValue(item));
+  }
+  return parseDefaultLiteral(token);
+}
+
+export function normalizeWidgetBehaviors(statement) {
+  const structured = blockEntries(getFieldValue(statement, "behaviors")).map((entry) => {
+    const kind = tokenValue(entry.items[0]);
+    const directives = {};
+    for (let i = 1; i < entry.items.length; i += 2) {
+      const key = tokenValue(entry.items[i]);
+      if (!key) {
+        continue;
+      }
+      directives[key] = normalizeBehaviorValue(entry.items[i + 1]);
+    }
+    return {
+      kind,
+      directives,
+      source: "structured",
+      raw: normalizeSequence(entry.items),
+      loc: entry.loc
+    };
+  });
+
+  const structuredKinds = new Set(structured.map((entry) => entry.kind));
+  const shorthand = symbolValues(getFieldValue(statement, "behavior"))
+    .filter((kind) => !structuredKinds.has(kind))
+    .map((kind) => ({
+      kind,
+      directives: {},
+      source: "shorthand",
+      raw: [kind],
+      loc: null
+    }));
+
+  return [...structured, ...shorthand];
+}
+
+export function buildWidgetContract(statement) {
+  return {
+    type: "ui_widget_contract",
+    id: statement.id,
+    name: statement.name || statement.id,
+    description: statement.description || null,
+    category: statement.category || null,
+    version: statement.version || null,
+    status: statement.status || null,
+    props: (statement.props || []).map((prop) => ({
+      name: prop.name,
+      type: prop.fieldType,
+      requiredness: prop.requiredness,
+      defaultValue: prop.defaultValue ?? null
+    })),
+    events: (statement.events || []).map((event) => ({
+      id: event.id,
+      shape: event.shape || null
+    })),
+    slots: (statement.slots || []).map((slot) => ({
+      id: slot.id,
+      description: slot.description || null
+    })),
+    behavior: [...(statement.behavior || [])],
+    behaviors: (statement.behaviors || []).map((behavior) => ({
+      kind: behavior.kind,
+      directives: { ...(behavior.directives || {}) },
+      source: behavior.source || null
+    })),
+    patterns: [...(statement.patterns || [])],
+    regions: [...(statement.regions || [])],
+    approvals: [...(statement.approvals || [])],
+    lookups: parseReferenceNodes(statement.lookups || []),
+    dependencies: parseReferenceNodes(statement.dependencies || [])
+  };
+}

package/src/resolver.d.ts

@@ -0,0 +1 @@
+export function resolveWorkspace(ast: any): any;

package/src/runtime-support.js

@@ -0,0 +1,29 @@
+// @ts-check
+
+export const MINIMUM_NODE_MAJOR = 20;
+
+/**
+ * @param {string} version
+ * @returns {{ ok: boolean, major: number, minimum: number, message: string|null }}
+ */
+export function nodeVersionSupport(version = process.versions.node) {
+  const major = Number.parseInt(String(version).split(".")[0] || "0", 10);
+  const ok = Number.isFinite(major) && major >= MINIMUM_NODE_MAJOR;
+  return {
+    ok,
+    major,
+    minimum: MINIMUM_NODE_MAJOR,
+    message: ok ? null : `Topogram requires Node.js ${MINIMUM_NODE_MAJOR}+; current runtime is ${version}.`
+  };
+}
+
+/**
+ * @param {string} [version]
+ * @returns {void}
+ */
+export function assertSupportedNode(version = process.versions.node) {
+  const support = nodeVersionSupport(version);
+  if (!support.ok) {
+    throw new Error(support.message || `Topogram requires Node.js ${MINIMUM_NODE_MAJOR}+.`);
+  }
+}

package/src/sdlc/adopt.d.ts

@@ -0,0 +1 @@
+export function sdlcAdopt(...args: any[]): any;

package/src/sdlc/check.d.ts

@@ -0,0 +1 @@
+export function checkWorkspace(...args: any[]): any;

package/src/sdlc/explain.d.ts

@@ -0,0 +1 @@
+export function explain(...args: any[]): any;

package/src/sdlc/release.d.ts

@@ -0,0 +1 @@
+export function runRelease(...args: any[]): any;

package/src/sdlc/scaffold.d.ts

@@ -0,0 +1 @@
+export function scaffoldNew(...args: any[]): any;

package/src/sdlc/transition.d.ts

@@ -0,0 +1 @@
+export function transitionStatement(...args: any[]): any;

package/src/template-trust/constants.js

@@ -0,0 +1,62 @@
+// @ts-check
+
+export const TEMPLATE_TRUST_FILE = ".topogram-template-trust.json";
+export const TEMPLATE_TRUST_POLICY = "topogram-template-executable-implementation-v1";
+export const IGNORED_IMPLEMENTATION_ENTRIES = new Set([".DS_Store", "node_modules", ".tmp"]);
+export const MAX_TEXT_DIFF_BYTES = 256 * 1024;
+export const TRUST_REVIEW_COMMANDS = "`topogram trust status`, `topogram trust diff`, and `topogram trust template`";
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+export function normalizeRoot(value) {
+  return String(value || "").replace(/\\/g, "/");
+}
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+export function normalizeRelativePath(value) {
+  return value.replace(/\\/g, "/");
+}
+
+/**
+ * @param {string} relativePath
+ * @returns {string}
+ */
+export function unsupportedImplementationSymlinkMessage(relativePath) {
+  return `Template implementation contains unsupported symlink '${relativePath}'. Implementation trust hashes real files under implementation/; symlinks can point outside the trusted root. Replace symlinks with real files under implementation/, then run ${TRUST_REVIEW_COMMANDS} after review.`;
+}
+
+/**
+ * @param {string} modulePath
+ * @returns {string}
+ */
+export function implementationOutsideRootMessage(modulePath) {
+  return `Template implementation module '${modulePath}' must be under implementation/ for template-attached projects. Keep executable template code inside implementation/ so the trust record covers what topogram generate may load. Move the module back under implementation/, then run ${TRUST_REVIEW_COMMANDS} after review.`;
+}
+
+/**
+ * @param {string|string[]} issueOrIssues
+ * @returns {string}
+ */
+export function templateTrustRecoveryGuidance(issueOrIssues) {
+  const issues = Array.isArray(issueOrIssues) ? issueOrIssues : [issueOrIssues];
+  const text = issues.join("\n");
+  if (issues.length > 0 && issues.every((issue) =>
+    issue.includes("topogram trust status") &&
+    issue.includes("topogram trust diff") &&
+    issue.includes("topogram trust template")
+  )) {
+    return "";
+  }
+  if (text.includes("unsupported symlink")) {
+    return `Replace symlinks with real files under implementation/, then run ${TRUST_REVIEW_COMMANDS} after review.`;
+  }
+  if (text.includes("must be under implementation/")) {
+    return `Keep executable template code under implementation/ so it can be hashed and trusted; move the module back under implementation/, then run ${TRUST_REVIEW_COMMANDS} after review.`;
+  }
+  return `Run \`topogram trust status\` and \`topogram trust diff\` to review implementation changes; after review, run \`topogram trust template\` to trust the current files.`;
+}