@intentius/chant 0.1.6 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Declarative infrastructure-as-code toolkit — TypeScript on Node.js",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",

package/src/cli/commands/build.test.ts

@@ -132,18 +132,71 @@ export const testEntity = {
     expect(result.fileCount).toBeDefined();
   });
 
-  test("handles invalid output path", async () => {
+  test("creates parent directories for the primary output path (#38)", async () => {
+    // Write into a nested temp path whose parent dirs don't yet exist —
+    // chant build should mkdir -p the parents rather than fail with ENOENT.
+    const nestedOutput = join(testDir, "deep", "nested", "out", "file.json");
+
     const options: BuildOptions = {
       path: testDir,
-      output: "/nonexistent/directory/file.json",
+      output: nestedOutput,
       format: "json",
       serializers: [mockSerializer],
     };
 
     const result = await buildCommand(options);
 
-    // Should report error about output file
-    expect(result.errors.length).toBeGreaterThan(0);
-    expect(result.errors.some((e) => e.includes("output"))).toBe(true);
+    expect(result.errors).toEqual([]);
+    expect(existsSync(nestedOutput)).toBe(true);
+  });
+
+  test("creates parent directories for nested additional-files (#38)", async () => {
+    // Simulate a multi-file serializer (like the Op codegen) that emits
+    // additional files under nested subpaths.
+    const multiFileSerializer: Serializer = {
+      name: "multi",
+      rulePrefix: "MULTI",
+      serialize: () => ({
+        primary: "{}",
+        files: {
+          "ops/alb-deploy/workflow.ts": "// workflow\n",
+          "ops/alb-deploy/activities.ts": "// activities\n",
+          "ops/alb-deploy/worker.ts": "// worker\n",
+        },
+      }),
+    };
+
+    // Need at least one entity in the "multi" lexicon so the build pipeline
+    // invokes the serializer and the additional files surface.
+    await writeFile(
+      join(testDir, "infra.ts"),
+      [
+        `export const x = {`,
+        `  [Symbol.for("chant.declarable")]: true,`,
+        `  entityType: "X",`,
+        `  lexicon: "multi",`,
+        `  kind: "resource",`,
+        `  props: {},`,
+        `  attributes: {},`,
+        `};`,
+      ].join("\n"),
+    );
+
+    const outputPath = join(testDir, "dist", "manifest.json");
+
+    const options: BuildOptions = {
+      path: testDir,
+      output: outputPath,
+      format: "json",
+      serializers: [multiFileSerializer],
+    };
+
+    const result = await buildCommand(options);
+
+    expect(result.errors).toEqual([]);
+    expect(existsSync(outputPath)).toBe(true);
+    expect(existsSync(join(testDir, "dist", "ops", "alb-deploy", "workflow.ts"))).toBe(true);
+    expect(existsSync(join(testDir, "dist", "ops", "alb-deploy", "activities.ts"))).toBe(true);
+    expect(existsSync(join(testDir, "dist", "ops", "alb-deploy", "worker.ts"))).toBe(true);
   });
 });

package/src/cli/commands/build.ts

@@ -5,7 +5,7 @@ import { runPostSynthChecks } from "../../lint/post-synth";
 import type { PostSynthCheck } from "../../lint/post-synth";
 import { sortedJsonReplacer } from "../../utils";
 import { formatError, formatWarning, formatSuccess, formatBold, formatInfo } from "../format";
-import { writeFileSync } from "fs";
+import { writeFileSync, mkdirSync } from "fs";
 import { resolve, dirname, join } from "path";
 import { watchDirectory, formatTimestamp, formatChangedFiles } from "../watch";
 
@@ -101,6 +101,23 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
     }
   }
 
+  // Empty-output guard: source files were discovered but no lexicon produced
+  // any output. Almost always indicates broken imports resolving to undefined
+  // (e.g. missing root re-exports from a lexicon) or modules that exported no
+  // Declarables. Without this guard, chant writes "{}" and exits 0.
+  if (
+    result.sourceFileCount > 0 &&
+    result.outputs.size === 0 &&
+    result.errors.length === 0 &&
+    errors.length === 0
+  ) {
+    errors.push(
+      formatError({
+        message: `Discovered ${result.sourceFileCount} source file(s) but produced no output. Likely causes: imports resolving to undefined (missing exports from a lexicon root), or no Declarables/Composites exported. Check that imported names exist in the target package.`,
+      }),
+    );
+  }
+
   // Handle output
   if (result.errors.length === 0 && errors.length === 0) {
     // Extract primary content and collect additional files from SerializerResult
@@ -171,9 +188,11 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
     }
 
     if (options.output) {
-      // Write to file
+      // Write to file — ensure parent directories exist for both the primary
+      // output path and any nested additional-file paths (e.g. ops/<name>/...).
       try {
         const outputPath = resolve(options.output);
+        mkdirSync(dirname(outputPath), { recursive: true });
         writeFileSync(outputPath, output);
 
         // Write additional files (e.g. nested stack templates) alongside the primary output
@@ -191,7 +210,9 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
             } catch {
               // If not JSON, write as-is
             }
-            writeFileSync(join(outputDir, filename), fileContent);
+            const targetPath = join(outputDir, filename);
+            mkdirSync(dirname(targetPath), { recursive: true });
+            writeFileSync(targetPath, fileContent);
           }
         }
       } catch (err) {

package/src/cli/handlers/graph.test.ts

@@ -0,0 +1,91 @@
+import { describe, test, expect, vi, beforeEach } from "vitest";
+import type { ParsedArgs } from "../registry";
+
+const discoverOpsMock = vi.fn();
+vi.mock("../../op/discover", () => ({
+  discoverOps: () => discoverOpsMock(),
+}));
+
+const { runGraph } = await import("./graph");
+
+function makeArgs(overrides: Partial<ParsedArgs> = {}): ParsedArgs {
+  return {
+    command: "graph", path: ".",
+    format: "", fix: false, watch: false, verbose: false, help: false, live: false,
+    ...overrides,
+  };
+}
+
+function makeOp(name: string, depends: string[] = []): [string, { config: { name: string; depends?: string[] } }] {
+  return [name, { config: { name, depends } }];
+}
+
+describe("runGraph", () => {
+  let stdoutBuf: string[];
+  let stderrBuf: string[];
+
+  beforeEach(() => {
+    stdoutBuf = [];
+    stderrBuf = [];
+    vi.spyOn(console, "log").mockImplementation((s: string) => { stdoutBuf.push(s); });
+    vi.spyOn(console, "error").mockImplementation((s: string) => { stderrBuf.push(s); });
+    discoverOpsMock.mockReset();
+  });
+
+  test("prints 'No Ops found' when discovery is empty", async () => {
+    discoverOpsMock.mockResolvedValue({ ops: new Map(), errors: [] });
+    const exit = await runGraph({ args: makeArgs(), plugins: [], serializers: [] });
+    expect(exit).toBe(0);
+    expect(stdoutBuf.join("\n")).toContain("No Ops found");
+  });
+
+  test("prints 'No Op dependencies' when ops have no depends", async () => {
+    discoverOpsMock.mockResolvedValue({
+      ops: new Map([makeOp("solo")]),
+      errors: [],
+    });
+    const exit = await runGraph({ args: makeArgs(), plugins: [], serializers: [] });
+    expect(exit).toBe(0);
+    expect(stdoutBuf.join("\n")).toContain("No Op dependencies");
+  });
+
+  test("prints `dep -> name` edge per dependency", async () => {
+    discoverOpsMock.mockResolvedValue({
+      ops: new Map([
+        makeOp("infra"),
+        makeOp("app", ["infra"]),
+      ]),
+      errors: [],
+    });
+    const exit = await runGraph({ args: makeArgs(), plugins: [], serializers: [] });
+    expect(exit).toBe(0);
+    const out = stdoutBuf.join("\n");
+    expect(out).toContain("infra → app");
+  });
+
+  test("handles multi-edge graphs", async () => {
+    discoverOpsMock.mockResolvedValue({
+      ops: new Map([
+        makeOp("a"),
+        makeOp("b", ["a"]),
+        makeOp("c", ["a", "b"]),
+      ]),
+      errors: [],
+    });
+    await runGraph({ args: makeArgs(), plugins: [], serializers: [] });
+    const out = stdoutBuf.join("\n");
+    expect(out).toContain("a → b");
+    expect(out).toContain("a → c");
+    expect(out).toContain("b → c");
+  });
+
+  test("forwards discovery errors to stderr", async () => {
+    discoverOpsMock.mockResolvedValue({
+      ops: new Map(),
+      errors: ["failed to parse ops/bad.op.ts"],
+    });
+    const exit = await runGraph({ args: makeArgs(), plugins: [], serializers: [] });
+    expect(exit).toBe(0);
+    expect(stderrBuf.join("\n")).toContain("failed to parse ops/bad.op.ts");
+  });
+});

package/src/cli/handlers/graph.ts

@@ -0,0 +1,23 @@
+import { discoverOps } from "../../op/discover";
+import { formatError } from "../format";
+import type { CommandContext } from "../registry";
+
+export async function runGraph(_ctx: CommandContext): Promise<number> {
+  const { ops, errors } = await discoverOps();
+  for (const err of errors) console.error(formatError({ message: err }));
+
+  if (ops.size === 0) {
+    console.log("No Ops found");
+    return 0;
+  }
+
+  let hasEdges = false;
+  for (const [name, { config }] of ops) {
+    for (const dep of config.depends ?? []) {
+      console.log(`${dep} → ${name}`);
+      hasEdges = true;
+    }
+  }
+  if (!hasEdges) console.log("No Op dependencies");
+  return 0;
+}

package/src/cli/handlers/run-client.ts

@@ -0,0 +1,134 @@
+/** Subset of WorkerProfile fields used by `chant run`. */
+export interface WorkerProfile {
+  address: string;
+  namespace: string;
+  taskQueue: string;
+  tls?: boolean | { serverNameOverride?: string };
+  apiKey?: string | { env: string };
+  autoStart?: boolean;
+}
+
+export interface TemporalClientModule {
+  Connection: {
+    connect(opts: Record<string, unknown>): Promise<unknown>;
+  };
+  Client: new (opts: Record<string, unknown>) => TemporalClientHandle;
+}
+
+export interface TemporalClientHandle {
+  workflow: {
+    start(workflowFn: unknown, opts: Record<string, unknown>): Promise<WorkflowHandleRaw>;
+    getHandle(workflowId: string): WorkflowHandleRaw;
+    list(opts?: Record<string, unknown>): AsyncIterable<WorkflowExecutionInfo>;
+  };
+}
+
+export interface WorkflowHandleRaw {
+  workflowId: string;
+  firstExecutionRunId?: string;
+  result(): Promise<unknown>;
+  describe(): Promise<WorkflowExecutionDescription>;
+  fetchHistory(): Promise<WorkflowHistoryRaw>;
+  signal(signalName: string): Promise<void>;
+  cancel(): Promise<void>;
+}
+
+export interface WorkflowExecutionDescription {
+  workflowId: string;
+  runId: string;
+  status: { name: string };
+  startTime: Date;
+  closeTime?: Date;
+  taskQueue: string;
+  type: { name: string };
+}
+
+export interface WorkflowExecutionInfo {
+  workflowId: string;
+  runId: string;
+  type: { name: string };
+  status: { name: string };
+  startTime: Date;
+  closeTime?: Date;
+}
+
+export interface WorkflowHistoryRaw {
+  events?: HistoryEvent[];
+}
+
+export interface HistoryEvent {
+  eventType?: string;
+  eventTime?: Date;
+  activityTaskCompletedEventAttributes?: { scheduledEventId?: string | number };
+  activityTaskScheduledEventAttributes?: { activityId?: string; activityType?: { name?: string } };
+  activityTaskFailedEventAttributes?: { failure?: { message?: string } };
+  workflowExecutionCompletedEventAttributes?: unknown;
+  workflowExecutionFailedEventAttributes?: { failure?: { message?: string } };
+}
+
+/**
+ * Dynamically import @temporalio/client from the user's project node_modules.
+ * Fails with a helpful message if not installed.
+ */
+export async function loadTemporalClient(): Promise<TemporalClientModule> {
+  try {
+    // Use variable to prevent tsc from statically resolving the optional dep
+    const mod = "@temporalio/client";
+    return await import(mod) as unknown as TemporalClientModule;
+  } catch {
+    throw new Error(
+      '@temporalio/client is not installed. Run: npm install @temporalio/client',
+    );
+  }
+}
+
+/**
+ * Build a Temporal Connection.connect() options object from a worker profile.
+ */
+export function connectionOptions(profile: WorkerProfile): Record<string, unknown> {
+  const apiKey =
+    typeof profile.apiKey === "object" && profile.apiKey !== null
+      ? process.env[(profile.apiKey as { env: string }).env]
+      : (profile.apiKey as string | undefined);
+
+  return {
+    address: profile.address,
+    ...(profile.tls && {
+      tls: typeof profile.tls === "object" ? profile.tls : {},
+      metadata: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+    }),
+  };
+}
+
+/**
+ * Deterministic workflow ID for an Op — allows status/signal/cancel/log
+ * without storing run IDs locally.
+ */
+export function resolveWorkflowId(opName: string): string {
+  return `chant-op-${opName}`;
+}
+
+/**
+ * Resolve a named profile from the chant config.
+ * Falls back to defaultProfile then "local".
+ */
+export function resolveProfile(
+  config: Record<string, unknown>,
+  profileName?: string,
+): WorkerProfile {
+  const temporal = config.temporal as Record<string, unknown> | undefined;
+  if (!temporal?.profiles) {
+    throw new Error(
+      'No temporal.profiles found in chant.config.ts. Add a profile to use `chant run`.',
+    );
+  }
+  const profiles = temporal.profiles as Record<string, WorkerProfile>;
+  const name = profileName ?? (temporal.defaultProfile as string | undefined) ?? "local";
+  const profile = profiles[name];
+  if (!profile) {
+    throw new Error(
+      `Temporal profile "${name}" not found. Available: ${Object.keys(profiles).join(", ")}`,
+    );
+  }
+  return profile;
+}

package/src/cli/handlers/run-report.ts

@@ -0,0 +1,160 @@
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import type { OpConfig } from "../../op/types";
+import type { WorkflowExecutionDescription, WorkflowHistoryRaw, HistoryEvent } from "./run-client";
+
+interface ActivityRecord {
+  name: string;
+  startTime?: Date;
+  endTime?: Date;
+  durationMs?: number;
+  status: "completed" | "failed" | "running";
+  error?: string;
+}
+
+interface PhaseRecord {
+  name: string;
+  activities: ActivityRecord[];
+}
+
+function formatDuration(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`;
+  const mins = Math.floor(ms / 60_000);
+  const secs = Math.round((ms % 60_000) / 1000);
+  return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
+}
+
+function extractPhaseRecords(config: OpConfig, history: WorkflowHistoryRaw): PhaseRecord[] {
+  const events = history.events ?? [];
+
+  // Build map: scheduled event ID → activity name
+  const scheduledActivities = new Map<string, string>();
+  const scheduledTimes = new Map<string, Date>();
+  const completedTimes = new Map<string, Date>();
+  const failedActivities = new Map<string, string>();
+
+  for (const event of events) {
+    if (event.eventType === "ActivityTaskScheduled" && event.activityTaskScheduledEventAttributes) {
+      const attrs = event.activityTaskScheduledEventAttributes;
+      const id = String(attrs.activityId ?? "");
+      const name = attrs.activityType?.name ?? "unknown";
+      scheduledActivities.set(id, name);
+      if (event.eventTime) scheduledTimes.set(id, new Date(event.eventTime));
+    }
+    if (event.eventType === "ActivityTaskCompleted" && event.activityTaskCompletedEventAttributes) {
+      const scheduledId = String(event.activityTaskCompletedEventAttributes.scheduledEventId ?? "");
+      if (event.eventTime) completedTimes.set(scheduledId, new Date(event.eventTime));
+    }
+    if (event.eventType === "ActivityTaskFailed" && event.activityTaskFailedEventAttributes) {
+      const msg = event.activityTaskFailedEventAttributes.failure?.message ?? "unknown error";
+      failedActivities.set(String(events.indexOf(event)), msg);
+    }
+  }
+
+  return config.phases.map((phase) => {
+    const activities: ActivityRecord[] = phase.steps
+      .filter((s) => s.kind === "activity")
+      .map((step) => {
+        if (step.kind !== "activity") return null;
+        const fn = step.fn;
+        // Find this activity by name in the history
+        let record: ActivityRecord | null = null;
+        for (const [id, name] of scheduledActivities) {
+          if (name === fn) {
+            const start = scheduledTimes.get(id);
+            const end = completedTimes.get(id);
+            const durationMs = start && end ? end.getTime() - start.getTime() : undefined;
+            record = {
+              name: fn,
+              startTime: start,
+              endTime: end,
+              durationMs,
+              status: end ? "completed" : "running",
+            };
+          }
+        }
+        return record ?? { name: fn, status: "running" };
+      })
+      .filter((r): r is ActivityRecord => r !== null);
+
+    return { name: phase.name, activities };
+  });
+}
+
+export function generateReport(
+  opName: string,
+  config: OpConfig,
+  description: WorkflowExecutionDescription,
+  history: WorkflowHistoryRaw,
+): string {
+  const lines: string[] = [];
+
+  const status = description.status.name;
+  const startTime = description.startTime;
+  const closeTime = description.closeTime;
+  const durationMs = closeTime ? closeTime.getTime() - startTime.getTime() : undefined;
+
+  lines.push(`# Deployment Report: ${opName}`);
+  lines.push("");
+  lines.push("## Overview");
+  lines.push("");
+  lines.push(`| Field | Value |`);
+  lines.push(`|---|---|`);
+  lines.push(`| Op | ${opName} |`);
+  lines.push(`| Overview | ${config.overview} |`);
+  lines.push(`| Status | **${status}** |`);
+  lines.push(`| Workflow ID | ${description.workflowId} |`);
+  lines.push(`| Run ID | ${description.runId} |`);
+  lines.push(`| Start | ${startTime.toISOString()} |`);
+  if (closeTime) lines.push(`| End | ${closeTime.toISOString()} |`);
+  if (durationMs !== undefined) lines.push(`| Duration | ${formatDuration(durationMs)} |`);
+  lines.push("");
+
+  lines.push("## Timeline");
+  lines.push("");
+  lines.push("| Phase | Activity | Duration | Status |");
+  lines.push("|---|---|---|---|");
+
+  const phases = extractPhaseRecords(config, history);
+  for (const phase of phases) {
+    if (phase.activities.length === 0) {
+      lines.push(`| ${phase.name} | — | — | — |`);
+    }
+    for (const act of phase.activities) {
+      const dur = act.durationMs !== undefined ? formatDuration(act.durationMs) : "—";
+      const statusEmoji = act.status === "completed" ? "✓" : act.status === "failed" ? "✗" : "…";
+      lines.push(`| ${phase.name} | ${act.name} | ${dur} | ${statusEmoji} ${act.status} |`);
+    }
+  }
+  lines.push("");
+
+  // Errors section
+  const failedEvents = (history.events ?? []).filter(
+    (e): e is HistoryEvent & Required<Pick<HistoryEvent, "activityTaskFailedEventAttributes">> =>
+      e.eventType === "ActivityTaskFailed" && !!e.activityTaskFailedEventAttributes,
+  );
+
+  if (failedEvents.length > 0) {
+    lines.push("## Errors");
+    lines.push("");
+    for (const event of failedEvents) {
+      const msg = event.activityTaskFailedEventAttributes?.failure?.message ?? "unknown";
+      lines.push(`- ${msg}`);
+    }
+    lines.push("");
+  }
+
+  lines.push(`---`);
+  lines.push(`*Generated by chant at ${new Date().toISOString()}*`);
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+export function writeReport(opName: string, markdown: string): string {
+  const outPath = join("dist", `${opName}-report.md`);
+  mkdirSync(dirname(outPath), { recursive: true });
+  writeFileSync(outPath, markdown, "utf-8");
+  return outPath;
+}