@topogram/cli 0.3.78 → 0.3.80

package/src/validator/per-kind/journey.js

@@ -0,0 +1,233 @@
+// @ts-check
+
+import {
+  JOURNEY_IDENTIFIER_PATTERN
+} from "../kinds.js";
+import {
+  pushError
+} from "../utils.js";
+import {
+  parseRecordBlock,
+  recordField,
+  recordString,
+  recordStringList,
+  recordSymbol,
+  recordSymbolList
+} from "../../record-blocks.js";
+
+const STEP_FIELDS = new Set(["id", "intent", "commands", "expects", "after", "notes"]);
+const ALTERNATE_FIELDS = new Set(["id", "from", "condition", "commands", "expects", "notes"]);
+
+/**
+ * @param {ValidationErrors} errors
+ * @param {TopogramStatement} statement
+ * @returns {void}
+ */
+function validateJourneyIdentifier(errors, statement) {
+  if (!JOURNEY_IDENTIFIER_PATTERN.test(statement.id)) {
+    pushError(
+      errors,
+      `Journey identifier '${statement.id}' must match ${JOURNEY_IDENTIFIER_PATTERN.source}`,
+      statement.loc
+    );
+  }
+}
+
+/**
+ * @param {ValidationErrors} errors
+ * @param {TopogramStatement} statement
+ * @param {TopogramField} field
+ * @param {Set<string>} allowedFields
+ * @param {string[]} requiredFields
+ * @returns {import("../../record-blocks.js").TopogramRecordBlock | null}
+ */
+function validateRecordBlock(errors, statement, field, allowedFields, requiredFields) {
+  if (field.value.type !== "block") {
+    pushError(errors, `Field '${field.key}' on journey ${statement.id} must be a block`, field.loc);
+    return null;
+  }
+
+  const record = parseRecordBlock(/** @type {import("../../parser.js").AstBlock} */ (/** @type {unknown} */ (field.value)));
+  for (const recordFieldEntry of record.fieldOrder) {
+    if (!recordFieldEntry.key) {
+      pushError(errors, `Each '${field.key}' record entry on journey ${statement.id} must start with a field name`, recordFieldEntry.loc);
+      continue;
+    }
+    if (!allowedFields.has(recordFieldEntry.key)) {
+      pushError(errors, `Unsupported '${field.key}' field '${recordFieldEntry.key}' on journey ${statement.id}`, recordFieldEntry.loc);
+    }
+    const entries = record.fields.get(recordFieldEntry.key) || [];
+    if (entries.length > 1 && entries[1] === recordFieldEntry) {
+      pushError(errors, `Duplicate '${field.key}' field '${recordFieldEntry.key}' on journey ${statement.id}`, recordFieldEntry.loc);
+    }
+  }
+
+  for (const required of requiredFields) {
+    if (!record.fields.has(required)) {
+      pushError(errors, `Journey ${statement.id} ${field.key} record requires '${required}'`, field.loc);
+    }
+  }
+
+  return record;
+}
+
+/**
+ * @param {ValidationErrors} errors
+ * @param {TopogramStatement} statement
+ * @param {import("../../record-blocks.js").TopogramRecordBlock} record
+ * @param {string} fieldName
+ * @param {"symbol" | "string" | "symbol_list" | "string_list"} expected
+ * @returns {void}
+ */
+function validateRecordFieldShape(errors, statement, record, fieldName, expected) {
+  const field = recordField(record, fieldName);
+  if (!field || !field.value) return;
+  if (expected === "symbol" && field.value.type !== "symbol") {
+    pushError(errors, `Journey ${statement.id} record field '${fieldName}' must be a symbol`, field.loc);
+  }
+  if (expected === "string" && field.value.type !== "string") {
+    pushError(errors, `Journey ${statement.id} record field '${fieldName}' must be a string`, field.loc);
+  }
+  if (expected === "symbol_list" && field.value.type !== "list") {
+    pushError(errors, `Journey ${statement.id} record field '${fieldName}' must be a list of symbols`, field.loc);
+  }
+  if (expected === "string_list" && field.value.type !== "list") {
+    pushError(errors, `Journey ${statement.id} record field '${fieldName}' must be a list of strings`, field.loc);
+  }
+}
+
+/**
+ * @param {ValidationErrors} errors
+ * @param {TopogramStatement} statement
+ * @param {TopogramFieldMap} fieldMap
+ * @returns {Set<string>}
+ */
+function validateStepRecords(errors, statement, fieldMap) {
+  const fields = fieldMap.get("step") || [];
+  /** @type {Set<string>} */
+  const stepIds = new Set();
+  if (fields.length === 0) {
+    pushError(errors, `Journey ${statement.id} must include at least one step`, statement.loc);
+    return stepIds;
+  }
+
+  for (const field of fields) {
+    const record = validateRecordBlock(errors, statement, field, STEP_FIELDS, ["id", "intent"]);
+    if (!record) continue;
+    validateRecordFieldShape(errors, statement, record, "id", "symbol");
+    validateRecordFieldShape(errors, statement, record, "intent", "string");
+    validateRecordFieldShape(errors, statement, record, "commands", "string_list");
+    validateRecordFieldShape(errors, statement, record, "expects", "string_list");
+    validateRecordFieldShape(errors, statement, record, "after", "symbol_list");
+    validateRecordFieldShape(errors, statement, record, "notes", "string");
+
+    const stepId = recordSymbol(record, "id");
+    if (!stepId) continue;
+    if (!/^[a-z][a-z0-9_]*$/.test(stepId)) {
+      pushError(errors, `Journey ${statement.id} step id must match /^[a-z][a-z0-9_]*$/`, recordField(record, "id")?.loc || field.loc);
+    }
+    if (stepIds.has(stepId)) {
+      pushError(errors, `Journey ${statement.id} has duplicate step '${stepId}'`, recordField(record, "id")?.loc || field.loc);
+    }
+    stepIds.add(stepId);
+  }
+
+  for (const field of fields) {
+    if (field.value.type !== "block") continue;
+    const record = parseRecordBlock(/** @type {import("../../parser.js").AstBlock} */ (/** @type {unknown} */ (field.value)));
+    const stepId = recordSymbol(record, "id") || "unknown";
+    for (const afterId of recordSymbolList(record, "after")) {
+      if (!stepIds.has(afterId)) {
+        pushError(errors, `Journey ${statement.id} step '${stepId}' after references missing step '${afterId}'`, recordField(record, "after")?.loc || field.loc);
+      }
+    }
+  }
+
+  return stepIds;
+}
+
+/**
+ * @param {ValidationErrors} errors
+ * @param {TopogramStatement} statement
+ * @param {TopogramFieldMap} fieldMap
+ * @param {Set<string>} stepIds
+ * @returns {void}
+ */
+function validateAlternateRecords(errors, statement, fieldMap, stepIds) {
+  const fields = fieldMap.get("alternate") || [];
+  /** @type {Set<string>} */
+  const alternateIds = new Set();
+  for (const field of fields) {
+    const record = validateRecordBlock(errors, statement, field, ALTERNATE_FIELDS, ["id", "from", "condition"]);
+    if (!record) continue;
+    validateRecordFieldShape(errors, statement, record, "id", "symbol");
+    validateRecordFieldShape(errors, statement, record, "from", "symbol");
+    validateRecordFieldShape(errors, statement, record, "condition", "string");
+    validateRecordFieldShape(errors, statement, record, "commands", "string_list");
+    validateRecordFieldShape(errors, statement, record, "expects", "string_list");
+    validateRecordFieldShape(errors, statement, record, "notes", "string");
+
+    const alternateId = recordSymbol(record, "id");
+    if (alternateId) {
+      if (!/^[a-z][a-z0-9_]*$/.test(alternateId)) {
+        pushError(errors, `Journey ${statement.id} alternate id must match /^[a-z][a-z0-9_]*$/`, recordField(record, "id")?.loc || field.loc);
+      }
+      if (alternateIds.has(alternateId)) {
+        pushError(errors, `Journey ${statement.id} has duplicate alternate '${alternateId}'`, recordField(record, "id")?.loc || field.loc);
+      }
+      alternateIds.add(alternateId);
+    }
+
+    const fromStep = recordSymbol(record, "from");
+    if (fromStep && !stepIds.has(fromStep)) {
+      pushError(errors, `Journey ${statement.id} alternate '${alternateId || "unknown"}' from references missing step '${fromStep}'`, recordField(record, "from")?.loc || field.loc);
+    }
+  }
+}
+
+/**
+ * @param {ValidationErrors} errors
+ * @param {TopogramStatement} statement
+ * @param {TopogramFieldMap} fieldMap
+ * @returns {void}
+ */
+function validateTopLevelListShapes(errors, statement, fieldMap) {
+  const stringListFields = ["success_signals", "failure_signals", "tags"];
+  for (const key of stringListFields) {
+    const field = fieldMap.get(key)?.[0];
+    if (!field || field.value.type !== "list") continue;
+    for (const item of field.value.items) {
+      if (item.type !== "string" && key !== "tags") {
+        pushError(errors, `Journey ${statement.id} field '${key}' must contain strings`, item.loc);
+      }
+      if (key === "tags" && item.type !== "symbol" && item.type !== "string") {
+        pushError(errors, `Journey ${statement.id} field '${key}' must contain symbols or strings`, item.loc);
+      }
+    }
+  }
+}
+
+/**
+ * Keep referenced imports used by checkJs while making the expected record
+ * helper vocabulary obvious to future validators.
+ */
+void recordString;
+void recordStringList;
+
+/**
+ * @param {ValidationErrors} errors
+ * @param {TopogramStatement} statement
+ * @param {TopogramFieldMap} fieldMap
+ * @param {TopogramRegistry} registry
+ * @returns {void}
+ */
+export function validateJourney(errors, statement, fieldMap, registry) {
+  void registry;
+  if (statement.kind !== "journey") {
+    return;
+  }
+  validateJourneyIdentifier(errors, statement);
+  validateTopLevelListShapes(errors, statement, fieldMap);
+  const stepIds = validateStepRecords(errors, statement, fieldMap);
+  validateAlternateRecords(errors, statement, fieldMap, stepIds);
+}

package/src/workflows/docs-generate.js

@@ -215,7 +215,10 @@ export function generateDocsWorkflow(inputPath) {
 export function generateJourneyDraftsWorkflow(inputPath) {
   const paths = normalizeWorkspacePaths(inputPath);
   const graph = loadResolvedGraph(paths.topogramRoot);
-  const canonicalJourneys = (graph.docs || []).filter((/** @type {any} */ doc) => doc.kind === "journey");
+  const canonicalJourneys = [
+    ...(graph.byKind?.journey || []),
+    ...(graph.docs || []).filter((/** @type {any} */ doc) => doc.kind === "journey")
+  ];
   const { drafts, skippedEntities } = buildJourneyDraftsReconcile(graph);
   /** @type {WorkflowFiles} */
   /** @type {WorkflowFiles} */

package/src/workflows/reconcile/bundle-core/index.js

@@ -62,9 +62,11 @@ export function bundleLabelFromConceptId(conceptId) {
 /** @param {ResolvedGraph} graph @returns {any} */
 export function canonicalJourneyCoverage(graph) {
   const journeyDocs = (graph?.docs || []).filter((/** @type {any} */ doc) => doc.kind === "journey");
+  const journeyStatements = graph?.byKind?.journey || [];
+  const journeys = [...journeyStatements, ...journeyDocs];
   return {
-    byEntityId: new Set(journeyDocs.flatMap((/** @type {any} */ doc) => doc.relatedEntities || [])),
-    byCapabilityId: new Set(journeyDocs.flatMap((/** @type {any} */ doc) => doc.relatedCapabilities || []))
+    byEntityId: new Set(journeys.flatMap((/** @type {any} */ journey) => journey.relatedEntities || [])),
+    byCapabilityId: new Set(journeys.flatMap((/** @type {any} */ journey) => journey.relatedCapabilities || []))
   };
 }
 

package/src/workflows/reconcile/canonical-surface.js

@@ -133,7 +133,10 @@ export function collectCanonicalWorkflowSurface(graph) {
 
 /** @param {ResolvedGraph} graph @returns {any} */
 export function collectCanonicalActorRoleSurface(graph) {
-  const journeyDocs = (graph.docs || []).filter((/** @type {any} */ doc) => doc.kind === "journey");
+  const journeyDocs = [
+    ...(graph.byKind?.journey || []),
+    ...(graph.docs || []).filter((/** @type {any} */ doc) => doc.kind === "journey")
+  ];
   const workflowDocs = (graph.docs || []).filter((/** @type {any} */ doc) => doc.kind === "workflow");
   return {
     actor_ids: ((graph.byKind.actor || []).map((/** @type {any} */ entry) => entry.id)).sort(),

package/src/cli/commands/new.js

@@ -1,94 +0,0 @@
-// @ts-check
-
-import path from "node:path";
-
-import { resolveCatalogTemplateAlias } from "../catalog-alias.js";
-import { GENERATOR_POLICY_FILE } from "../../generator-policy.js";
-import { createNewProject } from "../../new-project.js";
-
-const ENGINE_ROOT = path.resolve(decodeURIComponent(new URL("../../../", import.meta.url).pathname));
-const TEMPLATES_ROOT = path.join(ENGINE_ROOT, "templates");
-
-/**
- * @param {ReturnType<typeof createNewProject>} result
- * @param {string} cwd
- * @returns {string}
- */
-function displayProjectRootForNewProject(result, cwd) {
-  const relativeProjectRoot = path.relative(cwd, result.projectRoot);
-  return !relativeProjectRoot || relativeProjectRoot.startsWith("..")
-    ? result.projectRoot
-    : relativeProjectRoot;
-}
-
-/**
- * @param {ReturnType<typeof createNewProject>} result
- * @param {string} cwd
- * @returns {void}
- */
-export function printNewProjectResult(result, cwd) {
-  const template = result.template || {};
-  console.log(`Created Topogram project at ${result.projectRoot}.`);
-  console.log(`Template: ${result.templateName}`);
-  console.log(`Source: ${template.source || "unknown"}`);
-  if (template.sourceSpec) {
-    console.log(`Source spec: ${template.sourceSpec}`);
-  }
-  if (template.catalog) {
-    console.log(`Catalog: ${template.catalog.id} from ${template.catalog.source}`);
-    console.log(`Package: ${template.catalog.packageSpec}`);
-  }
-  console.log(`Executable implementation: ${template.includesExecutableImplementation ? "yes" : "no"}`);
-  console.log("Policy: topogram.template-policy.json");
-  console.log(`Generator policy: ${GENERATOR_POLICY_FILE}`);
-  console.log("Template files: .topogram-template-files.json");
-  if (template.includesExecutableImplementation) {
-    console.log("Trust: .topogram-template-trust.json");
-  }
-  for (const warning of result.warnings) {
-    console.warn(`Warning: ${warning}`);
-  }
-  console.log("");
-  console.log("Next steps:");
-  console.log(`  cd ${displayProjectRootForNewProject(result, cwd)}`);
-  console.log("  npm install");
-  console.log("  npm run agent:brief");
-  console.log("  npm run doctor");
-  console.log("  npm run source:status");
-  console.log("  npm run template:explain");
-  console.log("  npm run check");
-  console.log("  npm run generator:policy:status");
-  console.log("  npm run generator:policy:check");
-  if (template.includesExecutableImplementation) {
-    console.log("  npm run template:policy:explain");
-    console.log("  npm run trust:status");
-  }
-  console.log("  npm run generate");
-  console.log("  npm run verify");
-}
-
-/**
- * @param {string} inputPath
- * @param {{ templateName: string, catalogSource?: string|null, cwd?: string }} options
- * @returns {number}
- */
-export function runNewProjectCommand(inputPath, options) {
-  const cwd = options.cwd || process.cwd();
-  const projectRoot = path.resolve(inputPath);
-  const relativeToEngine = path.relative(ENGINE_ROOT, projectRoot);
-  if (relativeToEngine === "" || (!relativeToEngine.startsWith("..") && !path.isAbsolute(relativeToEngine))) {
-    throw new Error(
-      `Refusing to create a generated project inside the engine directory. Use a path outside engine, for example '../${path.basename(projectRoot)}'.`
-    );
-  }
-  const resolvedTemplate = resolveCatalogTemplateAlias(options.templateName, options.catalogSource || null);
-  const result = createNewProject({
-    targetPath: inputPath,
-    templateName: resolvedTemplate.templateName,
-    templateProvenance: resolvedTemplate.provenance,
-    engineRoot: ENGINE_ROOT,
-    templatesRoot: TEMPLATES_ROOT
-  });
-  printNewProjectResult(result, cwd);
-  return 0;
-}