@lssm/bundle.contractspec-workspace 0.0.0-canary-20251217080011 → 0.0.0-canary-20251219202229

package/dist/templates/integration.template.js

@@ -1,159 +0,0 @@
-//#region src/templates/integration.template.ts
-function generateIntegrationSpec(data) {
-	const specName = toPascalCase(data.name.split(".").pop() ?? "Integration");
-	const varName = `${specName}IntegrationSpec`;
-	const registerFn = `register${specName}Integration`;
-	const supportedModes = data.supportedModes.length ? data.supportedModes : ["managed"];
-	const supportedModesLine = supportedModes.map((mode) => `'${mode}'`).join(", ");
-	const provides = data.capabilitiesProvided.map((cap) => `      { key: '${cap.key}', version: ${cap.version} }`).join(",\n");
-	const requires = data.capabilitiesRequired.length > 0 ? `    requires: [
-${data.capabilitiesRequired.map((req) => {
-		const version = typeof req.version === "number" ? `, version: ${req.version}` : "";
-		const optional = req.optional ? ", optional: true" : "";
-		const reason = req.reason ? `, reason: '${escape(req.reason)}'` : "";
-		return `      { key: '${req.key}'${version}${optional}${reason} }`;
-	}).join(",\n")}
-    ],` : "";
-	const configSchema = renderConfigSchema(data.configFields);
-	const configExample = renderConfigExample(data.configFields);
-	const secretSchema = renderSecretSchema(data.secretFields);
-	const secretExample = renderSecretExample(data.secretFields);
-	const docsUrl = data.docsUrl ? `  docsUrl: '${escape(data.docsUrl)}',\n` : "";
-	const constraints = renderConstraints(data.rateLimitRpm, data.rateLimitRph);
-	const byokSetup = renderByokSetup(supportedModes, data.byokSetupInstructions, data.byokRequiredScopes);
-	return `import { StabilityEnum } from '@lssm/lib.contracts/ownership';
-import type { IntegrationSpec } from '@lssm/lib.contracts/integrations/spec';
-import type { IntegrationSpecRegistry } from '@lssm/lib.contracts/integrations/spec';
-
-export const ${varName}: IntegrationSpec = {
-  meta: {
-    key: '${data.name}',
-    version: ${data.version},
-    category: '${data.category}',
-    displayName: '${escape(data.displayName)}',
-    title: '${escape(data.title)}',
-    description: '${escape(data.description)}',
-    domain: '${escape(data.domain)}',
-    owners: [${data.owners.map((owner) => `'${escape(owner)}'`).join(", ")}],
-    tags: [${data.tags.map((tag) => `'${escape(tag)}'`).join(", ")}],
-    stability: StabilityEnum.${stabilityToEnum(data.stability)},
-  },
-  supportedModes: [${supportedModesLine}],
-  capabilities: {
-    provides: [
-${provides}
-    ],
-${requires.length > 0 ? `${requires}\n` : ""}  },
-  configSchema: {
-${configSchema}
-    example: ${configExample},
-  },
-  secretSchema: {
-${secretSchema}
-    example: ${secretExample},
-  },
-${docsUrl}${constraints}${byokSetup}  healthCheck: {
-    method: '${data.healthCheckMethod}',
-    timeoutMs: ${data.healthCheckTimeoutMs},
-  },
-};
-
-export function ${registerFn}(
-  registry: IntegrationSpecRegistry
-): IntegrationSpecRegistry {
-  return registry.register(${varName});
-}
-`;
-}
-function renderConfigSchema(fields) {
-	const requiredFields = fields.filter((field) => field.required);
-	return `    schema: {
-      type: 'object',
-${requiredFields.length > 0 ? `      required: [${requiredFields.map((field) => `'${field.key}'`).join(", ")}],
-` : ""}      properties: {
-${(fields.length ? fields.map((field) => {
-		const description = field.description ? `, description: '${escape(field.description)}'` : "";
-		return `        ${field.key}: { type: '${mapConfigType(field.type)}'${description} }`;
-	}).join(",\n") : "") || "      "}
-      },
-    },\n`;
-}
-function renderSecretSchema(fields) {
-	const requiredFields = fields.filter((field) => field.required);
-	return `    schema: {
-      type: 'object',
-${requiredFields.length > 0 ? `      required: [${requiredFields.map((field) => `'${field.key}'`).join(", ")}],
-` : ""}      properties: {
-${(fields.length ? fields.map((field) => {
-		const description = field.description ? `, description: '${escape(field.description)}'` : "";
-		return `        ${field.key}: { type: 'string'${description} }`;
-	}).join(",\n") : "") || "      "}
-      },
-    },\n`;
-}
-function renderConfigExample(fields) {
-	if (fields.length === 0) return `{}`;
-	return `{
-${fields.map((field) => {
-		switch (field.type) {
-			case "number": return `    ${field.key}: 0`;
-			case "boolean": return `    ${field.key}: true`;
-			case "string":
-			default: return `    ${field.key}: '${field.key.toUpperCase()}_VALUE'`;
-		}
-	}).join(",\n")}
-  }`;
-}
-function renderSecretExample(fields) {
-	if (fields.length === 0) return `{}`;
-	return `{
-${fields.map((field) => `    ${field.key}: '${field.key.toUpperCase()}_SECRET'`).join(",\n")}
-  }`;
-}
-function renderConstraints(rpm, rph) {
-	if (rpm == null && rph == null) return "";
-	const entries = [];
-	if (rpm != null) entries.push(`      rpm: ${rpm}`);
-	if (rph != null) entries.push(`      rph: ${rph}`);
-	return `  constraints: {
-    rateLimit: {
-${entries.join(",\n")}
-    },
-  },
-`;
-}
-function renderByokSetup(modes, instructions, scopes) {
-	if (!modes.includes("byok")) return "";
-	const instructionsLine = instructions ? `    setupInstructions: '${escape(instructions)}',\n` : "";
-	const scopesLine = scopes && scopes.length ? `    requiredScopes: [${scopes.map((scope) => `'${escape(scope)}'`).join(", ")}],\n` : "";
-	if (!instructionsLine && !scopesLine) return "";
-	return `  byokSetup: {
-${instructionsLine}${scopesLine}  },
-`;
-}
-function mapConfigType(type) {
-	switch (type) {
-		case "number": return "number";
-		case "boolean": return "boolean";
-		case "string":
-		default: return "string";
-	}
-}
-function stabilityToEnum(stability) {
-	switch (stability) {
-		case "beta": return "Beta";
-		case "stable": return "Stable";
-		case "deprecated": return "Deprecated";
-		case "experimental":
-		default: return "Experimental";
-	}
-}
-function toPascalCase(value) {
-	return value.split(/[-_.]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function escape(value) {
-	return value.replace(/`/g, "\\`").replace(/'/g, "\\'");
-}
-
-//#endregion
-export { generateIntegrationSpec };

package/dist/templates/knowledge.template.js

@@ -1,74 +0,0 @@
-//#region src/templates/knowledge.template.ts
-function generateKnowledgeSpaceSpec(data) {
-	const specName = toPascalCase(data.name.split(".").pop() ?? "KnowledgeSpace");
-	const varName = `${specName}KnowledgeSpace`;
-	const registerFn = `register${specName}KnowledgeSpace`;
-	const retention = renderRetention(data);
-	const access = renderAccess(data);
-	const indexing = renderIndexing(data);
-	const policyComment = data.policyName && !data.policyVersion ? ` // defaults to latest version` : "";
-	return `import { StabilityEnum } from '@lssm/lib.contracts/ownership';
-import type { KnowledgeSpaceSpec } from '@lssm/lib.contracts/knowledge/spec';
-import type { KnowledgeSpaceRegistry } from '@lssm/lib.contracts/knowledge/spec';
-
-export const ${varName}: KnowledgeSpaceSpec = {
-  meta: {
-    key: '${data.name}',
-    version: ${data.version},
-    category: '${data.category}',
-    displayName: '${escape(data.displayName)}',
-    title: '${escape(data.title)}',
-    description: '${escape(data.description)}',
-    domain: '${escape(data.domain)}',
-    owners: [${data.owners.map((owner) => `'${escape(owner)}'`).join(", ")}],
-    tags: [${data.tags.map((tag) => `'${escape(tag)}'`).join(", ")}],
-    stability: StabilityEnum.${stabilityToEnum(data.stability)},
-  },
-  retention: ${retention},
-  access: {
-${access}${data.policyName ? `    policy: { name: '${data.policyName}',${data.policyVersion ? ` version: ${data.policyVersion}` : ""} },${policyComment}\n` : ""}  },
-${indexing}  description: '${escape(data.description || data.displayName)}',
-};
-
-export function ${registerFn}(
-  registry: KnowledgeSpaceRegistry
-): KnowledgeSpaceRegistry {
-  return registry.register(${varName});
-}
-`;
-}
-function renderRetention(data) {
-	return `{ ttlDays: ${data.retention.ttlDays === null ? "null" : typeof data.retention.ttlDays === "number" ? String(data.retention.ttlDays) : "null"}${typeof data.retention.archiveAfterDays === "number" ? `, archiveAfterDays: ${data.retention.archiveAfterDays}` : ""} }`;
-}
-function renderAccess(data) {
-	return `${`    trustLevel: '${data.trustLevel}',\n`}${`    automationWritable: ${data.automationWritable},\n`}`;
-}
-function renderIndexing(data) {
-	const entries = [];
-	if (data.embeddingModel) entries.push(`    embeddingModel: '${escape(data.embeddingModel)}'`);
-	if (typeof data.chunkSize === "number") entries.push(`    chunkSize: ${data.chunkSize}`);
-	if (data.vectorDbIntegration) entries.push(`    vectorDbIntegration: '${escape(data.vectorDbIntegration)}'`);
-	if (entries.length === 0) return "";
-	return `  indexing: {
-${entries.join(",\n")}
-  },
-`;
-}
-function stabilityToEnum(stability) {
-	switch (stability) {
-		case "beta": return "Beta";
-		case "stable": return "Stable";
-		case "deprecated": return "Deprecated";
-		case "experimental":
-		default: return "Experimental";
-	}
-}
-function toPascalCase(value) {
-	return value.split(/[-_.]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function escape(value) {
-	return value.replace(/`/g, "\\`").replace(/'/g, "\\'");
-}
-
-//#endregion
-export { generateKnowledgeSpaceSpec };

package/dist/templates/migration.template.js

@@ -1,61 +0,0 @@
-//#region src/templates/migration.template.ts
-function generateMigrationSpec(data) {
-	const migrationVar = `${toPascalCase(data.name.split(".").pop() ?? "Migration")}Migration`;
-	const dependencies = data.dependencies.length > 0 ? `dependencies: [${data.dependencies.map((dep) => `'${dep}'`).join(", ")}],` : "";
-	return `import type { MigrationSpec } from '@lssm/lib.contracts/migrations';
-
-export const ${migrationVar}: MigrationSpec = {
-  meta: {
-    name: '${data.name}',
-    version: ${data.version},
-    title: '${escape(data.title)}',
-    description: '${escape(data.description ?? "")}',
-    domain: '${escape(data.domain)}',
-    owners: [${data.owners.map((owner) => `'${owner}'`).join(", ")}],
-    tags: [${data.tags.map((tag) => `'${tag}'`).join(", ")}],
-    stability: '${data.stability}',
-  },
-  plan: {
-    up: [
-${renderSteps(data.up)}
-    ],${data.down && data.down.length ? `
-    down: [
-${renderSteps(data.down)}
-    ],` : ""}
-  },
-  ${dependencies}
-};
-`;
-}
-function renderSteps(steps) {
-	return steps.map((step) => {
-		const description = step.description ? `description: '${escape(step.description)}',` : "";
-		switch (step.kind) {
-			case "schema": return `      {
-        kind: 'schema',
-        ${description}
-        sql: \`${escape(step.sql ?? "")}\`,
-      }`;
-			case "data": return `      {
-        kind: 'data',
-        ${description}
-        script: \`${escape(step.script ?? "")}\`,
-      }`;
-			case "validation":
-			default: return `      {
-        kind: 'validation',
-        ${description}
-        assertion: \`${escape(step.assertion ?? "")}\`,
-      }`;
-		}
-	}).join(",\n");
-}
-function toPascalCase(value) {
-	return value.split(/[-_.]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function escape(value) {
-	return value.replace(/`/g, "\\`").replace(/'/g, "\\'");
-}
-
-//#endregion
-export { generateMigrationSpec };

package/dist/templates/operation.template.js

@@ -1,104 +0,0 @@
-//#region src/templates/operation.template.ts
-/**
-* Generate operation spec TypeScript code
-*/
-function generateOperationSpec(data) {
-	const { name, version, kind, description, goal, context, stability, owners, tags, auth, flags } = data;
-	const specVarName = toPascalCase(name.split(".").pop() || "Unknown") + "Spec";
-	const inputSchemaName = specVarName.replace("Spec", "Input");
-	const outputSchemaName = specVarName.replace("Spec", "Output");
-	return `import { define${capitalize(kind)} } from '@lssm/lib.contracts';
-import { ScalarTypeEnum, SchemaModel } from '@lssm/lib.schema';
-
-// TODO: Define input schema
-export const ${inputSchemaName} = new SchemaModel({
-  name: '${inputSchemaName}',
-  description: 'Input for ${name}',
-  fields: {
-    // Add your fields here
-    // example: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-  },
-});
-
-// TODO: Define output schema
-export const ${outputSchemaName} = new SchemaModel({
-  name: '${outputSchemaName}',
-  description: 'Output for ${name}',
-  fields: {
-    // Add your fields here
-    ok: { type: ScalarTypeEnum.Boolean(), isOptional: false },
-  },
-});
-
-export const ${specVarName} = define${capitalize(kind)}({
-  meta: {
-    name: '${name}',
-    version: ${version},
-    stability: '${stability}',
-    owners: [${owners.map((o) => `'${o}'`).join(", ")}],
-    tags: [${tags.map((t) => `'${t}'`).join(", ")}],
-    description: '${description}',
-    goal: '${goal}',
-    context: '${context}',
-  },
-
-  io: {
-    input: ${inputSchemaName},
-    output: ${outputSchemaName},
-    errors: {
-      // Define possible errors
-      // EXAMPLE_ERROR: {
-      //   description: 'Example error description',
-      //   http: 400,
-      //   when: 'When this error occurs',
-      // },
-    },
-  },
-
-  policy: {
-    auth: '${auth}',
-    ${flags.length > 0 ? `flags: [${flags.map((f) => `'${f}'`).join(", ")}],` : "// flags: [],"}
-  },
-
-  sideEffects: {
-    ${data.emitsEvents ? "emits: [\n      // Define events to emit\n      // { ref: SomeEventSpec, when: 'always' }\n    ]," : "// emits: [],"}
-    analytics: [
-      // Define analytics events
-    ],
-  },
-
-  transport: {
-    rest: { method: '${kind === "command" ? "POST" : "GET"}' },
-    gql: { field: '${name.replace(/\./g, "_")}' },
-    mcp: { toolName: '${name}.v${version}' },
-  },
-
-  acceptance: {
-    scenarios: [
-      {
-        name: 'Happy path',
-        given: ['preconditions'],
-        when: ['action taken'],
-        then: ['expected outcome'],
-      },
-    ],
-    examples: [
-      {
-        name: 'Example usage',
-        input: { /* example input */ },
-        output: { ok: true },
-      },
-    ],
-  },
-});
-`;
-}
-function capitalize(str) {
-	return str.charAt(0).toUpperCase() + str.slice(1);
-}
-function toPascalCase(str) {
-	return str.split(/[-_.]/).map(capitalize).join("");
-}
-
-//#endregion
-export { generateOperationSpec };

package/dist/templates/presentation.template.js

@@ -1,79 +0,0 @@
-//#region src/templates/presentation.template.ts
-/**
-* Generate presentation spec TypeScript code
-*/
-function generatePresentationSpec(data) {
-	const { name, version, description, stability, owners, tags, presentationKind } = data;
-	const varName = toPascalCase(name.replace(/\./g, "_")) + "Presentation";
-	let contentBlock = "";
-	switch (presentationKind) {
-		case "web_component":
-			contentBlock = `  content: {
-    kind: 'web_component',
-    framework: 'react',
-    componentKey: '${name.replace(/\./g, "_")}',
-    props: new SchemaModel({
-      name: '${varName}Props',
-      description: 'Props for ${name}',
-      fields: {
-        // TODO: Define component props
-      },
-    }),
-    analytics: [
-      // TODO: Define analytics events
-    ],
-  },`;
-			break;
-		case "markdown":
-			contentBlock = `  content: {
-    kind: 'markdown',
-    content: \`
-# ${description}
-
-TODO: Add markdown content here
-    \`,
-    // Or use resourceUri: 'feature://${name}/guide.md'
-  },`;
-			break;
-		case "data":
-			contentBlock = `  content: {
-    kind: 'data',
-    mimeType: 'application/json',
-    model: new SchemaModel({
-      name: '${varName}Data',
-      description: 'Data structure for ${name}',
-      fields: {
-        // TODO: Define data structure
-      },
-    }),
-  },`;
-			break;
-	}
-	return `import type { PresentationSpec } from '@lssm/lib.contracts/presentations';
-import { SchemaModel, ScalarTypeEnum } from '@lssm/lib.schema';
-
-export const ${varName}: PresentationSpec = {
-  meta: {
-    name: '${name}',
-    version: ${version},
-    stability: '${stability}',
-    owners: [${owners.map((o) => `'${o}'`).join(", ")}],
-    tags: [${tags.map((t) => `'${t}'`).join(", ")}],
-    description: '${description}',
-  },
-  
-  policy: {
-    // flags: [],
-    // pii: [],
-  },
-  
-${contentBlock}
-};
-`;
-}
-function toPascalCase(str) {
-	return str.split(/[-_.]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
-}
-
-//#endregion
-export { generatePresentationSpec };

package/dist/templates/telemetry.template.js

@@ -1,90 +0,0 @@
-//#region src/templates/telemetry.template.ts
-function generateTelemetrySpec(data) {
-	const specVar = toPascalCase(data.name.split(".").pop() ?? "Telemetry") + "Telemetry";
-	const providers = data.providers?.length ? `providers: [
-${data.providers.map((provider) => `      {
-        type: '${provider.type}',
-        config: ${formatConfigValue(provider.config)},
-      }`).join(",\n")}
-    ],` : "";
-	const events = data.events.map((event) => {
-		const properties = event.properties.map((prop) => `      '${prop.name}': {
-        type: '${prop.type}',
-        ${prop.required ? "required: true," : ""}
-        ${prop.pii ? "pii: true," : ""}
-        ${prop.redact ? "redact: true," : ""}
-        ${prop.description ? `description: '${escapeString(prop.description)}',` : ""}
-      }`).join(",\n");
-		const anomalyRules = event.anomalyRules?.length ? `      anomalyDetection: {
-        enabled: true,
-        ${typeof event.anomalyMinimumSample === "number" ? `minimumSample: ${event.anomalyMinimumSample},` : ""}
-        thresholds: [
-${event.anomalyRules.map((rule) => `          {
-            metric: '${escapeString(rule.metric)}',
-            ${typeof rule.min === "number" ? `min: ${rule.min},` : ""}
-            ${typeof rule.max === "number" ? `max: ${rule.max},` : ""}
-          }`).join(",\n")}
-        ],
-        actions: [${(event.anomalyActions ?? []).map((action) => `'${action}'`).join(", ")}],
-      },` : event.anomalyEnabled ? `      anomalyDetection: {
-        enabled: true,
-        ${typeof event.anomalyMinimumSample === "number" ? `minimumSample: ${event.anomalyMinimumSample},` : ""}
-      },` : "";
-		return `    {
-      name: '${escapeString(event.name)}',
-      version: ${event.version},
-      semantics: {
-        what: '${escapeString(event.what)}',
-        ${event.who ? `who: '${escapeString(event.who)}',` : ""}
-        ${event.why ? `why: '${escapeString(event.why)}',` : ""}
-      },
-      privacy: '${event.privacy}',
-      properties: {
-${properties}
-      },
-      ${typeof event.retentionDays === "number" ? `retention: { days: ${event.retentionDays}, ${event.retentionPolicy ? `policy: '${event.retentionPolicy}'` : ""} },` : ""}
-      ${typeof event.samplingRate === "number" ? `sampling: { rate: ${event.samplingRate}${event.samplingConditions ? `, conditions: ['${escapeString(event.samplingConditions)}']` : ""} },` : ""}
-${anomalyRules}
-      ${event.tags?.length ? `tags: [${event.tags.map((tag) => `'${escapeString(tag)}'`).join(", ")}],` : ""}
-    }`;
-	}).join(",\n");
-	return `import type { TelemetrySpec } from '@lssm/lib.contracts/telemetry';
-
-export const ${specVar}: TelemetrySpec = {
-  meta: {
-    name: '${escapeString(data.name)}',
-    version: ${data.version},
-    title: '${escapeString(data.name)} telemetry',
-    description: '${escapeString(data.description || "Describe the purpose of this telemetry spec.")}',
-    domain: '${escapeString(data.domain)}',
-    owners: [${data.owners.map((owner) => `'${escapeString(owner)}'`).join(", ")}],
-    tags: [${data.tags.map((tag) => `'${escapeString(tag)}'`).join(", ")}],
-    stability: '${data.stability}',
-  },
-  config: {
-    ${typeof data.defaultRetentionDays === "number" ? `defaultRetentionDays: ${data.defaultRetentionDays},` : ""}
-    ${typeof data.defaultSamplingRate === "number" ? `defaultSamplingRate: ${data.defaultSamplingRate},` : ""}
-    ${data.anomalyEnabled ? `anomalyDetection: { enabled: true${typeof data.anomalyCheckIntervalMs === "number" ? `, checkIntervalMs: ${data.anomalyCheckIntervalMs}` : ""} },` : ""}
-${providers}
-  },
-  events: [
-${events}
-  ],
-};
-`;
-}
-function toPascalCase(value) {
-	return value.split(/[-_.]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function escapeString(value) {
-	return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-}
-function formatConfigValue(value) {
-	const trimmed = value.trim();
-	if (!trimmed) return "{}";
-	if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) return trimmed;
-	return `'${escapeString(trimmed)}'`;
-}
-
-//#endregion
-export { generateTelemetrySpec };

package/dist/templates/workflow-runner.template.js

@@ -1,49 +0,0 @@
-//#region src/templates/workflow-runner.template.ts
-function generateWorkflowRunnerTemplate({ exportName, specImportPath, runnerName, workflowName }) {
-	return `import {
-  InMemoryStateStore,
-  WorkflowRegistry,
-  WorkflowRunner,
-} from '@lssm/lib.contracts/workflow';
-import { ${exportName} } from '${specImportPath}';
-
-/**
- * Runner wiring for ${workflowName}.
- *
- * TODO:
- *  - Replace the in-memory state store with a persistent adapter if needed.
- *  - Implement opExecutor to invoke the correct contract handlers.
- *  - Wire eventEmitter to analytics/telemetry sinks.
- */
-const registry = new WorkflowRegistry();
-registry.register(${exportName});
-
-const stateStore = new InMemoryStateStore();
-
-export const ${runnerName} = new WorkflowRunner({
-  registry,
-  stateStore,
-  opExecutor: async (operation, input, ctx) => {
-    // TODO: route to the appropriate contract handler
-    // Example: return contractRegistry.execute(operation.name, operation.version, input, ctx);
-    throw new Error(
-      \`opExecutor for \${operation.name}.v\${operation.version} is not implemented\`
-    );
-  },
-  // appConfigProvider: async (state) => {
-  //   // TODO: return the ResolvedAppConfig for this workflow run (tenant/environment)
-  //   return undefined;
-  // },
-  // enforceCapabilities: async (operation, context) => {
-  //   // TODO: ensure required capabilities are satisfied using context.integrations/context.resolvedAppConfig
-  // },
-  eventEmitter: (event, payload) => {
-    // TODO: forward workflow events to telemetry or logging sinks
-    // console.log(event, payload);
-  },
-});
-`;
-}
-
-//#endregion
-export { generateWorkflowRunnerTemplate };

package/dist/templates/workflow.template.js

@@ -1,68 +0,0 @@
-//#region src/templates/workflow.template.ts
-function generateWorkflowSpec(data) {
-	const specVarName = toPascalCase(data.name.split(".").pop() ?? "Workflow") + "Workflow";
-	const stepsCode = data.steps.map((step) => formatStep(step)).join(",\n");
-	const transitionsCode = data.transitions.map((transition) => `    {
-      from: '${transition.from}',
-      to: '${transition.to}',
-${transition.condition ? `      condition: '${escapeString(transition.condition)}',` : ""}
-    }`).join(",\n");
-	return `import type { WorkflowSpec } from '@lssm/lib.contracts/workflow';
-
-/**
- * Workflow generated via contractspec CLI.
- * TODO:
- *  - Review step definitions and descriptions.
- *  - Wire automation steps to actual operations.
- *  - Provide form renderers for human steps.
- *  - Add guards/conditions as needed.
- */
-export const ${specVarName}: WorkflowSpec = {
-  meta: {
-    name: '${data.name}',
-    version: ${data.version},
-    title: '${escapeString(data.title)}',
-    description: '${escapeString(data.description)}',
-    domain: '${escapeString(data.domain)}',
-    stability: '${data.stability}',
-    owners: [${data.owners.map((owner) => `'${owner}'`).join(", ")}],
-    tags: [${data.tags.map((tag) => `'${tag}'`).join(", ")}],
-  },
-  definition: {
-${data.entryStepId ? `    entryStepId: '${data.entryStepId}',\n` : ""}    steps: [
-${stepsCode}
-    ],
-    transitions: [
-${transitionsCode}
-    ],
-  },
-  ${data.policyFlags.length > 0 ? `policy: {
-    flags: [${data.policyFlags.map((flag) => `'${flag}'`).join(", ")}],
-  },` : "// policy: { flags: [] },"}
-};
-`;
-}
-function formatStep(step) {
-	const lines = [
-		`    {`,
-		`      id: '${step.id}',`,
-		`      type: '${step.type}',`,
-		`      label: '${escapeString(step.label)}',`
-	];
-	if (step.description) lines.push(`      description: '${escapeString(step.description)}',`);
-	const actionLines = [];
-	if (step.operation) actionLines.push(`operation: { name: '${step.operation.name}', version: ${step.operation.version} }`);
-	if (step.form) actionLines.push(`form: { key: '${step.form.key}', version: ${step.form.version} }`);
-	if (actionLines.length) lines.push(`      action: { ${actionLines.join(", ")} },`);
-	lines.push(`    }`);
-	return lines.join("\n");
-}
-function toPascalCase(value) {
-	return value.split(/[-_.]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function escapeString(value) {
-	return value.replace(/'/g, "\\'");
-}
-
-//#endregion
-export { generateWorkflowSpec };