@intentius/chant 0.1.6 → 0.1.7

package/package.json

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

package/src/cli/commands/build.ts

@@ -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

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;
+}