@intentius/chant 0.1.6 → 0.1.8

package/src/cli/main.test.ts

@@ -198,6 +198,7 @@ describe("resolveCommand", () => {
       watch: false,
       verbose: false,
       help: false,
+      live: false,
       ...overrides,
     };
   }
@@ -254,4 +255,68 @@ describe("resolveCommand", () => {
     expect(result!.def.name).toBe("dev generate");
     expect(result!.compound).toBe(true);
   });
+
+  test("resolves run status as compound command", () => {
+    const registry: CommandDef[] = [
+      { name: "run list", handler: noop },
+      { name: "run status", handler: noop },
+      { name: "run signal", handler: noop },
+      { name: "run cancel", handler: noop },
+      { name: "run log", handler: noop },
+      { name: "run", handler: noop },
+    ];
+    const result = resolveCommand(makeArgs({ command: "run", path: "status" }), registry);
+    expect(result!.def.name).toBe("run status");
+    expect(result!.compound).toBe(true);
+  });
+
+  test("resolves run <name> as simple command", () => {
+    const registry: CommandDef[] = [
+      { name: "run list", handler: noop },
+      { name: "run status", handler: noop },
+      { name: "run", handler: noop },
+    ];
+    const result = resolveCommand(makeArgs({ command: "run", path: "alb-deploy" }), registry);
+    expect(result!.def.name).toBe("run");
+    expect(result!.compound).toBe(false);
+  });
+});
+
+describe("parseArgs — run flags", () => {
+  test("parses --profile flag", () => {
+    const result = parseArgs(["run", "alb-deploy", "--profile", "local"]);
+    expect(result.command).toBe("run");
+    expect(result.path).toBe("alb-deploy");
+    expect(result.profile).toBe("local");
+  });
+
+  test("parses -p shorthand for --profile", () => {
+    const result = parseArgs(["run", "alb-deploy", "-p", "cloud"]);
+    expect(result.profile).toBe("cloud");
+  });
+
+  test("parses --report flag", () => {
+    const result = parseArgs(["run", "alb-deploy", "--report"]);
+    expect(result.command).toBe("run");
+    expect(result.path).toBe("alb-deploy");
+    expect(result.report).toBe(true);
+  });
+
+  test("report is undefined when not provided", () => {
+    const result = parseArgs(["run", "alb-deploy"]);
+    expect(result.report).toBe(undefined);
+  });
+
+  test("profile is undefined when not provided", () => {
+    const result = parseArgs(["run", "alb-deploy"]);
+    expect(result.profile).toBe(undefined);
+  });
+
+  test("run signal parses op name and signal into positionals", () => {
+    const result = parseArgs(["run", "signal", "alb-deploy", "gate-dns"]);
+    expect(result.command).toBe("run");
+    expect(result.path).toBe("signal");
+    expect(result.extraPositional).toBe("alb-deploy");
+    expect(result.extraPositional2).toBe("gate-dns");
+  });
 });

package/src/cli/main.ts

@@ -13,7 +13,8 @@ import { runServeLsp, runServeMcp, runServeUnknown } from "./handlers/serve";
 import { runInit, runInitLexicon } from "./handlers/init";
 import { runList, runImport, runUpdate, runDoctor } from "./handlers/misc";
 import { runStateSnapshot, runStateShow, runStateDiff, runStateLog, runStateUnknown } from "./handlers/state";
-import { runSpellAdd, runSpellRm, runSpellList, runSpellShow, runSpellCast, runSpellDone, runGraph, runSpellUnknown } from "./handlers/spell";
+import { runGraph } from "./handlers/graph";
+import { runOp, runOpList, runOpStatus, runOpSignal, runOpCancel, runOpLog } from "./handlers/run";
 
 /**
  * Parse command line arguments
@@ -33,6 +34,9 @@ export function parseArgs(args: string[]): ParsedArgs {
     watch: false,
     verbose: false,
     help: false,
+    profile: undefined,
+    report: undefined,
+    live: false,
   };
 
   let i = 0;
@@ -57,6 +61,12 @@ export function parseArgs(args: string[]): ParsedArgs {
       result.watch = true;
     } else if (arg === "--verbose" || arg === "-v") {
       result.verbose = true;
+    } else if (arg === "--profile" || arg === "-p") {
+      result.profile = args[++i];
+    } else if (arg === "--report") {
+      result.report = true;
+    } else if (arg === "--live") {
+      result.live = true;
     } else if (!arg.startsWith("-")) {
       if (!result.command) {
         result.command = arg;
@@ -93,19 +103,21 @@ Commands:
   list                  List discovered entities
   import                Import external template into TypeScript
 
-Spells:
-  spell add <name>      Create a new spell
-  spell rm <name>       Remove a spell
-  spell list            List all spells with status
-  spell show <name>     Show spell details
-  spell cast <name>     Generate bootstrap prompt for agent
-  spell done <name> <N> Mark task N as done
-  graph                 Show spell dependency graph
+Ops:
+  run <name>            Start an Op workflow (spawns worker + submits to Temporal)
+  run list              List all Ops with current run status
+  run status <name>     Show current workflow run state
+  run signal <name> <signal>  Send a named signal to unblock a gate
+  run cancel <name>     Cancel the active workflow run (requires --force)
+  run log <name>        Show run history for an Op
+
+  graph                 Show Op dependency graph
 
 State:
   state snapshot <env>  Query API, save metadata to orphan branch
   state show <env>      Show latest state snapshot
   state diff <env>      Compare current build against last snapshot
+                        --live: query cloud now and detect drift
   state log [env]       History of state snapshots
 
 Lexicon development:
@@ -135,6 +147,8 @@ Options:
   -w, --watch           Watch for changes and rebuild/re-lint (build, lint)
   -v, --verbose         Show stack traces on errors
   -h, --help            Show this help message
+  -p, --profile <name>  Temporal worker profile to use (run command)
+  --report              Print deployment report instead of running (run command)
 
 Examples:
   chant build ./infra/
@@ -194,13 +208,14 @@ const registry: CommandDef[] = [
   { name: "dev onboard", handler: runDevOnboard },
   { name: "dev check-lexicon", handler: runDevCheckLexicon },
 
-  // Spell subcommands
-  { name: "spell add", handler: runSpellAdd },
-  { name: "spell rm", handler: runSpellRm },
-  { name: "spell list", handler: runSpellList },
-  { name: "spell show", handler: runSpellShow },
-  { name: "spell cast", handler: runSpellCast },
-  { name: "spell done", handler: runSpellDone },
+  // Op / run subcommands
+  { name: "run list", handler: runOpList },
+  { name: "run status", handler: runOpStatus },
+  { name: "run signal", handler: runOpSignal },
+  { name: "run cancel", handler: runOpCancel },
+  { name: "run log", handler: runOpLog },
+  { name: "run", handler: runOp },
+
   { name: "graph", handler: runGraph },
 
   // State subcommands
@@ -214,7 +229,6 @@ const registry: CommandDef[] = [
   { name: "serve mcp", requiresPlugins: true, handler: runServeMcp },
 
   // Fallback for unknown subcommands (must come after compound entries)
-  { name: "spell", handler: runSpellUnknown },
   { name: "state", handler: runStateUnknown },
   { name: "dev", handler: runDevUnknown },
   { name: "serve", handler: runServeUnknown },
@@ -250,7 +264,7 @@ async function main(): Promise<void> {
     process.exit(1);
   }
 
-  // For compound commands (e.g. "spell cast"), args.path is the subcommand,
+  // For compound commands (e.g. "run list"), args.path is the subcommand,
   // so always use "." as the project path. For simple commands, use args.path.
   const projectPath = match.compound ? (args.extraPositional || ".") : args.path;
   const plugins = match.def.requiresPlugins

package/src/cli/mcp/op-tools.ts

@@ -0,0 +1,204 @@
+import { resolve } from "node:path";
+import { discoverOps } from "../../op/discover";
+import { makeTemporalClient } from "../handlers/run";
+import { resolveWorkflowId } from "../handlers/run-client";
+import { generateReport } from "../handlers/run-report";
+import type { ToolRegistration } from "./state-tools";
+
+function workflowFnName(opName: string): string {
+  return opName.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase()) + "Workflow";
+}
+
+export function createOpListTool(): ToolRegistration {
+  return {
+    definition: {
+      name: "op-list",
+      description: "List all Op definitions discovered from *.op.ts files with their current run status",
+      inputSchema: {
+        type: "object",
+        properties: {
+          profile: { type: "string", description: "Temporal profile name from chant.config.ts (optional)" },
+        },
+      },
+    },
+    handler: async (params) => {
+      const { ops, errors } = await discoverOps();
+      const profile = params.profile as string | undefined;
+
+      let client: Awaited<ReturnType<typeof makeTemporalClient>>["client"] | undefined;
+      try {
+        ({ client } = await makeTemporalClient(profile, resolve(".")));
+      } catch {
+        // Temporal not available — degrade gracefully
+      }
+
+      const result = [];
+      for (const [name, { config }] of ops) {
+        let runStatus = "—";
+        if (client) {
+          try {
+            const desc = await client.workflow.getHandle(resolveWorkflowId(name)).describe();
+            runStatus = desc.status.name;
+          } catch {
+            // workflow not found or Temporal error
+          }
+        }
+        result.push({
+          name,
+          overview: config.overview,
+          phases: config.phases.length,
+          taskQueue: config.taskQueue ?? config.name,
+          depends: config.depends ?? [],
+          runStatus,
+        });
+      }
+
+      return { ops: result, errors };
+    },
+  };
+}
+
+export function createOpRunTool(): ToolRegistration {
+  return {
+    definition: {
+      name: "op-run",
+      description:
+        "Submit an Op workflow to Temporal. The worker must already be running — start it first with `chant run <name>`.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Op name (e.g. alb-deploy)" },
+          profile: { type: "string", description: "Temporal profile name from chant.config.ts (optional)" },
+        },
+        required: ["name"],
+      },
+    },
+    handler: async (params) => {
+      const name = params.name as string;
+      const profile = params.profile as string | undefined;
+
+      const { ops } = await discoverOps();
+      if (!ops.has(name)) {
+        const available = [...ops.keys()];
+        return `Op "${name}" not found. Available: ${available.join(", ") || "none"}`;
+      }
+
+      const { config } = ops.get(name)!;
+      const { client, profile: resolvedProfile } = await makeTemporalClient(profile, resolve("."));
+      const workflowId = resolveWorkflowId(name);
+      const taskQueue = resolvedProfile.taskQueue ?? config.taskQueue ?? name;
+
+      await client.workflow.start(workflowFnName(name), {
+        taskQueue,
+        workflowId,
+        workflowIdConflictPolicy: "FAIL",
+      });
+
+      return { workflowId, message: `Workflow "${workflowId}" submitted to task queue "${taskQueue}"` };
+    },
+  };
+}
+
+export function createOpStatusTool(): ToolRegistration {
+  return {
+    definition: {
+      name: "op-status",
+      description: "Return the current run state of an Op workflow",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Op name (e.g. alb-deploy)" },
+          profile: { type: "string", description: "Temporal profile name from chant.config.ts (optional)" },
+        },
+        required: ["name"],
+      },
+    },
+    handler: async (params) => {
+      const name = params.name as string;
+      const profile = params.profile as string | undefined;
+
+      const { client } = await makeTemporalClient(profile, resolve("."));
+      const handle = client.workflow.getHandle(resolveWorkflowId(name));
+      const desc = await handle.describe();
+      const history = await handle.fetchHistory();
+
+      const events = history.events ?? [];
+      const activitiesCompleted = events.filter((e) => e.eventType === "ActivityTaskCompleted").length;
+      const activitiesScheduled = events.filter((e) => e.eventType === "ActivityTaskScheduled").length;
+
+      return {
+        workflowId: desc.workflowId,
+        runId: desc.runId,
+        status: desc.status.name,
+        startTime: desc.startTime,
+        closeTime: desc.closeTime ?? null,
+        taskQueue: desc.taskQueue,
+        activitiesCompleted,
+        activitiesScheduled,
+      };
+    },
+  };
+}
+
+export function createOpSignalTool(): ToolRegistration {
+  return {
+    definition: {
+      name: "op-signal",
+      description: "Send a named signal to an Op workflow (e.g. to unblock a gate step)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Op name (e.g. alb-deploy)" },
+          signal: { type: "string", description: "Signal name (e.g. gate-dns-delegation)" },
+          profile: { type: "string", description: "Temporal profile name from chant.config.ts (optional)" },
+        },
+        required: ["name", "signal"],
+      },
+    },
+    handler: async (params) => {
+      const name = params.name as string;
+      const signal = params.signal as string;
+      const profile = params.profile as string | undefined;
+
+      const { client } = await makeTemporalClient(profile, resolve("."));
+      const handle = client.workflow.getHandle(resolveWorkflowId(name));
+      await handle.signal(signal);
+
+      return `Signal "${signal}" sent to Op "${name}"`;
+    },
+  };
+}
+
+export function createOpReportTool(): ToolRegistration {
+  return {
+    definition: {
+      name: "op-report",
+      description: "Return a markdown deployment report for the latest run of an Op",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Op name (e.g. alb-deploy)" },
+          profile: { type: "string", description: "Temporal profile name from chant.config.ts (optional)" },
+        },
+        required: ["name"],
+      },
+    },
+    handler: async (params) => {
+      const name = params.name as string;
+      const profile = params.profile as string | undefined;
+
+      const { ops } = await discoverOps();
+      if (!ops.has(name)) {
+        return `Op "${name}" not found`;
+      }
+      const { config } = ops.get(name)!;
+
+      const { client } = await makeTemporalClient(profile, resolve("."));
+      const handle = client.workflow.getHandle(resolveWorkflowId(name));
+      const desc = await handle.describe();
+      const history = await handle.fetchHistory();
+
+      return generateReport(name, config, desc, history);
+    },
+  };
+}

package/src/cli/mcp/resource-handlers.ts

@@ -1,9 +1,10 @@
+import { resolve } from "node:path";
 import type { ResourceDefinition } from "./types";
 import { getContext } from "./resources/context";
 import { readSnapshot, readEnvironmentSnapshots } from "../../state/git";
-import { discoverSpells } from "../../spell/discovery";
-import { generatePrompt } from "../../spell/prompt";
-import { getRuntime } from "../../runtime-adapter";
+import { discoverOps } from "../../op/discover";
+import { makeTemporalClient } from "../handlers/run";
+import { resolveWorkflowId } from "../handlers/run-client";
 
 type PluginResourceEntry = { definition: ResourceDefinition; handler: () => Promise<string> };
 
@@ -24,22 +25,22 @@ export const coreResourceDefinitions: ResourceDefinition[] = [
     mimeType: "application/json",
   },
   {
-    uri: "chant://spells",
-    name: "Spells",
-    description: "List all spells with status, tasks, and lexicon",
+    uri: "chant://ops",
+    name: "Ops",
+    description: "All Op definitions discovered from *.op.ts files",
     mimeType: "application/json",
   },
   {
-    uri: "chant://spell/{name}",
-    name: "Spell details",
-    description: "Show spell definition and status",
+    uri: "chant://ops/{name}/runs",
+    name: "Op run history",
+    description: "Workflow run history for a named Op",
     mimeType: "application/json",
   },
   {
-    uri: "chant://spell/{name}/prompt",
-    name: "Spell bootstrap prompt",
-    description: "Bootstrap prompt for agent consumption",
-    mimeType: "text/markdown",
+    uri: "chant://ops/{name}/runs/latest",
+    name: "Op latest run",
+    description: "Latest run state for a named Op",
+    mimeType: "application/json",
   },
   {
     uri: "chant://state/{environment}",
@@ -84,6 +85,10 @@ export function collectExamples(
   return examples;
 }
 
+function opWorkflowFnName(opName: string): string {
+  return opName.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase()) + "Workflow";
+}
+
 /**
  * Handle resources/read request — checks plugin resources after core
  */
@@ -117,51 +122,65 @@ export async function handleResourcesRead(
     };
   }
 
-  // Spell resources
-  if (uri === "chant://spells") {
-    const { spells } = await discoverSpells();
-    const list = Array.from(spells.entries()).map(([name, s]) => ({
-      name,
-      status: s.status,
-      tasks: `${s.definition.tasks.filter((t) => t.done).length}/${s.definition.tasks.length}`,
-      lexicon: s.definition.lexicon ?? null,
-      overview: s.definition.overview,
+  // Op resources
+  if (uri === "chant://ops") {
+    const { ops } = await discoverOps();
+    const list = Array.from(ops.values()).map(({ config }) => ({
+      name: config.name,
+      overview: config.overview,
+      phases: config.phases.length,
+      taskQueue: config.taskQueue ?? config.name,
+      depends: config.depends ?? [],
     }));
     return {
       contents: [{ uri, mimeType: "application/json", text: JSON.stringify(list, null, 2) }],
     };
   }
 
-  if (uri.startsWith("chant://spell/") && uri.endsWith("/prompt")) {
-    const name = uri.replace("chant://spell/", "").replace("/prompt", "");
-    const { spells } = await discoverSpells();
-    const spell = spells.get(name);
-    if (!spell) throw new Error(`Spell "${name}" not found`);
-    const rt = getRuntime();
-    const gitRootResult = await rt.spawn(["git", "rev-parse", "--show-toplevel"]);
-    const gitRoot = gitRootResult.stdout.trim();
-    const prompt = await generatePrompt(spell.definition, { gitRoot });
-    return {
-      contents: [{ uri, mimeType: "text/markdown", text: prompt }],
-    };
+  if (uri.startsWith("chant://ops/") && uri.endsWith("/runs/latest")) {
+    const name = uri.replace("chant://ops/", "").replace("/runs/latest", "");
+    try {
+      const { client } = await makeTemporalClient(undefined, resolve("."));
+      const handle = client.workflow.getHandle(resolveWorkflowId(name));
+      const desc = await handle.describe();
+      const history = await handle.fetchHistory();
+      const events = history.events ?? [];
+      const result = {
+        workflowId: desc.workflowId,
+        runId: desc.runId,
+        status: desc.status.name,
+        startTime: desc.startTime,
+        closeTime: desc.closeTime ?? null,
+        taskQueue: desc.taskQueue,
+        activitiesCompleted: events.filter((e) => e.eventType === "ActivityTaskCompleted").length,
+        activitiesScheduled: events.filter((e) => e.eventType === "ActivityTaskScheduled").length,
+      };
+      return {
+        contents: [{ uri, mimeType: "application/json", text: JSON.stringify(result, null, 2) }],
+      };
+    } catch (err) {
+      return {
+        contents: [{ uri, mimeType: "application/json", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }) }],
+      };
+    }
   }
 
-  if (uri.startsWith("chant://spell/")) {
-    const name = uri.replace("chant://spell/", "");
-    const { spells } = await discoverSpells();
-    const spell = spells.get(name);
-    if (!spell) throw new Error(`Spell "${name}" not found`);
-    return {
-      contents: [{
-        uri,
-        mimeType: "application/json",
-        text: JSON.stringify({
-          ...spell.definition,
-          status: spell.status,
-          filePath: spell.filePath,
-        }, null, 2),
-      }],
-    };
+  if (uri.startsWith("chant://ops/") && uri.endsWith("/runs")) {
+    const name = uri.replace("chant://ops/", "").replace("/runs", "");
+    try {
+      const { client } = await makeTemporalClient(undefined, resolve("."));
+      const runs: unknown[] = [];
+      for await (const run of client.workflow.list({ query: `WorkflowType = "${opWorkflowFnName(name)}"` })) {
+        runs.push({ runId: run.runId, status: run.status.name, startTime: run.startTime, closeTime: run.closeTime ?? null });
+      }
+      return {
+        contents: [{ uri, mimeType: "application/json", text: JSON.stringify(runs, null, 2) }],
+      };
+    } catch (err) {
+      return {
+        contents: [{ uri, mimeType: "application/json", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }) }],
+      };
+    }
   }
 
   // State resources: chant://state/{environment} and chant://state/{environment}/{lexicon}

package/src/cli/mcp/resources/context.ts

@@ -49,6 +49,33 @@ chant import template.json    # Convert external template
 chant import template.json -o ./src/  # Custom output dir
 \`\`\`
 
+## Ops (Temporal Workflows)
+
+Ops are durable workflow definitions backed by Temporal. Each \`*.op.ts\` file declares an Op with named phases and activity steps.
+
+### Op MCP Tools
+
+| Tool | Description |
+|---|---|
+| \`op-list\` | List all discovered Ops with current run status. Optional \`profile\` param. |
+| \`op-run\` | Submit an Op workflow. Requires \`name\`. Worker must already be running via \`chant run <name>\`. |
+| \`op-status\` | Get current run state (status, activity counts, times). Requires \`name\`. |
+| \`op-signal\` | Send a signal to unblock a gate step. Requires \`name\` and \`signal\`. |
+| \`op-report\` | Return a markdown deployment report for the latest run. Requires \`name\`. |
+
+All Op tools accept an optional \`profile\` parameter matching a profile name in \`chant.config.ts\` \`temporal.profiles\`.
+
+### Op MCP Resources
+
+| URI | Description |
+|---|---|
+| \`chant://ops\` | JSON array of all Op definitions (name, overview, phases, taskQueue, depends) |
+| \`chant://ops/{name}/runs\` | Workflow run history for a named Op |
+| \`chant://ops/{name}/runs/latest\` | Latest run state for a named Op |
+
+### Workflow IDs
+Ops use deterministic workflow IDs: \`chant-op-<opName>\` (e.g. \`chant-op-alb-deploy\`).
+
 ## Best Practices
 
 1. **Flat Declarations**: Keep declarations at module level, avoid deep nesting