@intentius/chant 0.1.6 → 0.1.7

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

@@ -6,8 +6,6 @@ import { build } from "../../build";
 import { computeBuildDigest, diffDigests } from "../../state/digest";
 import { takeSnapshot } from "../../state/snapshot";
 import type { StateSnapshot } from "../../state/types";
-import { discoverSpells } from "../../spell/discovery";
-
 export interface ToolRegistration {
   definition: ToolDefinition;
   handler: ToolHandler;
@@ -87,52 +85,3 @@ export function createDiffTool(plugins: LexiconPlugin[]): ToolRegistration {
   };
 }
 
-/**
- * Create spell-done tool definition and handler
- */
-export function createSpellDoneTool(): ToolRegistration {
-  return {
-    definition: {
-      name: "spell-done",
-      description: "Mark a spell task as done",
-      inputSchema: {
-        type: "object",
-        properties: {
-          name: { type: "string", description: "Spell name" },
-          taskNumber: { type: "number", description: "Task number (1-based)" },
-        },
-        required: ["name", "taskNumber"],
-      },
-    },
-    handler: async (params) => {
-      const { readFileSync, writeFileSync } = await import("node:fs");
-      const { spells } = await discoverSpells();
-      const name = params.name as string;
-      const taskNumber = params.taskNumber as number;
-      const spell = spells.get(name);
-      if (!spell) return `Spell "${name}" not found`;
-      if (taskNumber < 1 || taskNumber > spell.definition.tasks.length) {
-        return `Invalid task number ${taskNumber}`;
-      }
-      const task = spell.definition.tasks[taskNumber - 1];
-      if (task.done) return `Task ${taskNumber} is already done`;
-
-      const content = readFileSync(spell.filePath, "utf-8");
-      let count = 0;
-      const rewritten = content.replace(
-        /task\(("[^"]*"|'[^']*'|`[^`]*`)((?:\s*,\s*\{[^}]*\})?)\)/g,
-        (match, desc, opts) => {
-          count++;
-          if (count !== taskNumber) return match;
-          if (opts && opts.includes("done:")) {
-            return match.replace(/done:\s*false/, "done: true");
-          }
-          return `task(${desc}, { done: true })`;
-        },
-      );
-      if (rewritten === content) return `Could not rewrite task ${taskNumber}`;
-      writeFileSync(spell.filePath, rewritten);
-      return `Task ${taskNumber} marked done: "${task.description}"`;
-    },
-  };
-}

package/src/cli/registry.ts

@@ -18,6 +18,8 @@ export interface ParsedArgs {
   watch: boolean;
   verbose: boolean;
   help: boolean;
+  profile?: string;
+  report?: boolean;
 }
 
 /**

package/src/composite.ts

@@ -95,11 +95,16 @@ export function Composite<P, M extends CompositeMembers = CompositeMembers>(
       }
     }
 
-    const instance: CompositeInstance<M> = {
-      [COMPOSITE_MARKER]: true,
-      members,
-      _definition: definition,
-    };
+    // Define `members` and `_definition` as non-enumerable so spreading a
+    // composite instance (`...someComposite`) only exposes the actual member
+    // resources, not the framework's bookkeeping properties. Without this, a
+    // parent composite that does `...childResult` ends up with a `members` key
+    // pointing at the child's CompositeMembers record — not a Declarable —
+    // which then trips the parent's own member validation.
+    const instance = {} as CompositeInstance<M>;
+    Object.defineProperty(instance, COMPOSITE_MARKER, { value: true, enumerable: false });
+    Object.defineProperty(instance, "members", { value: members, enumerable: false });
+    Object.defineProperty(instance, "_definition", { value: definition, enumerable: false });
 
     return Object.assign(instance, members) as CompositeInstance<M> & M;
   }) as CompositeDefinition<P, M>;

package/src/index.ts

@@ -60,8 +60,7 @@ export * from "./lsp/types";
 export * from "./lsp/lexicon-providers";
 export * from "./mcp/types";
 export * from "./state/index";
-export * from "./spell/index";
 // Op builders — use explicit exports to avoid collision with the core `build` function
 export { Op, phase, activity, gate, kubectlApply, helmInstall, waitForStack,
          gitlabPipeline, stateSnapshot, shell, teardown, OpResource } from "./op/index";
-export type { OpConfig, PhaseDefinition, StepDefinition, ActivityStep, GateStep, RetryPolicy } from "./op/index";
+export type { OpConfig, PhaseDefinition, StepDefinition, ActivityStep, GateStep } from "./op/index";

package/src/op/discover.test.ts

@@ -0,0 +1,43 @@
+import { describe, test, expect, vi, beforeEach } from "vitest";
+import { discoverOps } from "./discover";
+
+// Mock getRuntime to return git root pointing at the repo root
+vi.mock("../runtime-adapter", () => ({
+  getRuntime: () => ({
+    spawn: async (cmd: string[]) => {
+      if (cmd[0] === "git" && cmd[1] === "rev-parse") {
+        // Return the actual repo root so the test can find the example op file
+        const { execFile } = await import("node:child_process");
+        const { promisify } = await import("node:util");
+        const execFileAsync = promisify(execFile);
+        const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"]);
+        return { stdout: stdout.trim(), stderr: "", exitCode: 0 };
+      }
+      return { stdout: "", stderr: "", exitCode: 0 };
+    },
+  }),
+}));
+
+describe("discoverOps", () => {
+  test("discovers alb-deploy.op.ts from examples/", async () => {
+    const { ops, errors } = await discoverOps();
+    expect(errors).toHaveLength(0);
+    expect(ops.has("alb-deploy")).toBe(true);
+  });
+
+  test("discovered Op has correct config shape", async () => {
+    const { ops } = await discoverOps();
+    const op = ops.get("alb-deploy");
+    expect(op).toBeDefined();
+    expect(op!.config.name).toBe("alb-deploy");
+    expect(Array.isArray(op!.config.phases)).toBe(true);
+    expect(op!.config.phases.length).toBeGreaterThan(0);
+    expect(typeof op!.config.overview).toBe("string");
+  });
+
+  test("filePath points to the .op.ts source file", async () => {
+    const { ops } = await discoverOps();
+    const op = ops.get("alb-deploy");
+    expect(op!.filePath).toMatch(/alb-deploy\.op\.ts$/);
+  });
+});

package/src/op/discover.ts

@@ -0,0 +1,89 @@
+import { getRuntime } from "../runtime-adapter";
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import type { OpConfig } from "./types";
+
+export interface DiscoveredOp {
+  config: OpConfig;
+  filePath: string;
+}
+
+export interface OpDiscoveryResult {
+  ops: Map<string, DiscoveredOp>;
+  errors: string[];
+}
+
+async function findGitRoot(cwd?: string): Promise<string> {
+  const rt = getRuntime();
+  const result = await rt.spawn(["git", "rev-parse", "--show-toplevel"], { cwd });
+  if (result.exitCode !== 0) throw new Error("Not in a git repository");
+  return result.stdout.trim();
+}
+
+async function collectOpFiles(dir: string): Promise<string[]> {
+  const files: string[] = [];
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return files;
+  }
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules" && entry.name !== "dist") {
+      files.push(...await collectOpFiles(fullPath));
+    } else if (
+      entry.isFile() &&
+      entry.name.endsWith(".op.ts") &&
+      !entry.name.endsWith(".test.ts") &&
+      !entry.name.endsWith(".spec.ts")
+    ) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+/**
+ * Discover all Op definitions from *.op.ts files under the git root.
+ */
+export async function discoverOps(opts?: { cwd?: string }): Promise<OpDiscoveryResult> {
+  const errors: string[] = [];
+  const ops = new Map<string, DiscoveredOp>();
+
+  const gitRoot = await findGitRoot(opts?.cwd);
+  const files = await collectOpFiles(gitRoot);
+
+  const nameToFile = new Map<string, string>();
+
+  for (const filePath of files) {
+    try {
+      const mod = await import(filePath);
+      const entity = mod.default;
+
+      if (!entity || typeof entity !== "object") {
+        errors.push(`${filePath}: default export is not an object`);
+        continue;
+      }
+
+      const config = entity.props as OpConfig | undefined;
+
+      if (!config || typeof config.name !== "string" || !Array.isArray(config.phases)) {
+        errors.push(`${filePath}: default export is not a valid Op (missing name or phases)`);
+        continue;
+      }
+
+      if (nameToFile.has(config.name)) {
+        errors.push(`Duplicate Op name "${config.name}" in ${filePath} and ${nameToFile.get(config.name)}`);
+        continue;
+      }
+
+      nameToFile.set(config.name, filePath);
+      ops.set(config.name, { config, filePath });
+    } catch (err) {
+      errors.push(`${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
+  return { ops, errors };
+}

package/src/op/index.ts

@@ -1,4 +1,6 @@
 export { Op, phase, activity, gate, build, kubectlApply, helmInstall, waitForStack,
          gitlabPipeline, stateSnapshot, shell, teardown } from "./builders";
 export { OpResource } from "./resource";
-export type { OpConfig, PhaseDefinition, StepDefinition, ActivityStep, GateStep, RetryPolicy } from "./types";
+export type { OpConfig, PhaseDefinition, StepDefinition, ActivityStep, GateStep } from "./types";
+export { discoverOps } from "./discover";
+export type { DiscoveredOp, OpDiscoveryResult } from "./discover";

package/src/op/types.ts

@@ -58,9 +58,3 @@ export interface GateStep {
   description?: string;
 }
 
-export interface RetryPolicy {
-  initialInterval?: string;
-  backoffCoefficient?: number;
-  maximumAttempts?: number;
-  maximumInterval?: string;
-}

package/src/cli/handlers/spell.ts

@@ -1,396 +0,0 @@
-import { resolve, join } from "node:path";
-import { writeFileSync, unlinkSync, readFileSync } from "node:fs";
-import { mkdirSync, existsSync } from "node:fs";
-import { getRuntime } from "../../runtime-adapter";
-import { discoverSpells } from "../../spell/discovery";
-import { generatePrompt } from "../../spell/prompt";
-import { formatError, formatWarning, formatSuccess, formatBold } from "../format";
-import { loadPlugin } from "../plugins";
-import type { CommandContext } from "../registry";
-
-/**
- * Find the git root directory.
- */
-async function findGitRoot(): Promise<string> {
-  const rt = getRuntime();
-  const result = await rt.spawn(["git", "rev-parse", "--show-toplevel"]);
-  if (result.exitCode !== 0) throw new Error("Not in a git repository");
-  return result.stdout.trim();
-}
-
-/**
- * chant spell add <name>
- */
-export async function runSpellAdd(ctx: CommandContext): Promise<number> {
-  const name = ctx.args.extraPositional;
-  if (!name) {
-    console.error(formatError({ message: "Name is required: chant spell add <name>" }));
-    return 1;
-  }
-
-  // Validate name format
-  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(name) || name.length > 64) {
-    console.error(formatError({ message: `Invalid spell name: "${name}" (must be kebab-case, max 64 chars)` }));
-    return 1;
-  }
-
-  const gitRoot = await findGitRoot();
-  const spellsDir = join(gitRoot, "spells");
-  const filePath = join(spellsDir, `${name}.spell.ts`);
-
-  if (existsSync(filePath)) {
-    console.error(formatError({ message: `Spell "${name}" already exists at ${filePath}` }));
-    return 1;
-  }
-
-  mkdirSync(spellsDir, { recursive: true });
-
-  const template = `import { spell, task } from "@intentius/chant";
-
-export default spell({
-  name: "${name}",
-  overview: "",
-  tasks: [
-    task(""),
-  ],
-});
-`;
-
-  writeFileSync(filePath, template);
-  console.error(formatSuccess(`Created ${filePath}`));
-  return 0;
-}
-
-/**
- * chant spell rm <name>
- */
-export async function runSpellRm(ctx: CommandContext): Promise<number> {
-  const name = ctx.args.extraPositional;
-  if (!name) {
-    console.error(formatError({ message: "Name is required: chant spell rm <name>" }));
-    return 1;
-  }
-
-  const gitRoot = await findGitRoot();
-  const filePath = join(gitRoot, "spells", `${name}.spell.ts`);
-
-  if (!existsSync(filePath)) {
-    console.error(formatError({ message: `Spell "${name}" not found at ${filePath}` }));
-    return 1;
-  }
-
-  // Check for dependents (unless --force)
-  if (!ctx.args.force) {
-    const { spells } = await discoverSpells();
-    const dependents = [];
-    for (const [depName, spell] of spells) {
-      if (spell.definition.depends?.includes(name)) {
-        dependents.push(depName);
-      }
-    }
-    if (dependents.length > 0) {
-      console.error(formatWarning({
-        message: `Spell "${name}" is depended on by: ${dependents.join(", ")}`,
-        hint: "Use --force to delete anyway",
-      }));
-      return 1;
-    }
-  }
-
-  unlinkSync(filePath);
-  console.error(formatSuccess(`Removed ${filePath}`));
-  return 0;
-}
-
-/**
- * chant spell list
- */
-export async function runSpellList(ctx: CommandContext): Promise<number> {
-  const { spells, errors } = await discoverSpells();
-
-  for (const err of errors) {
-    console.error(formatError({ message: err }));
-  }
-
-  if (spells.size === 0) {
-    console.error(formatWarning({ message: "No spells found" }));
-    return 0;
-  }
-
-  // Filter by --ready flag if present (using extraPositional as a hack)
-  const readyOnly = ctx.args.format === "ready";
-
-  console.log(
-    "NAME".padEnd(20) +
-    "STATUS".padEnd(10) +
-    "TASKS".padEnd(10) +
-    "LEXICON".padEnd(12) +
-    "OVERVIEW"
-  );
-
-  for (const [name, spell] of spells) {
-    if (readyOnly && spell.status !== "ready") continue;
-
-    const def = spell.definition;
-    const doneCount = def.tasks.filter((t) => t.done).length;
-    const tasksStr = `[${doneCount}/${def.tasks.length}]`;
-    const lexicon = def.lexicon ?? "";
-    const overview = def.overview.length > 40
-      ? def.overview.slice(0, 37) + "..."
-      : def.overview;
-
-    console.log(
-      name.padEnd(20) +
-      spell.status.padEnd(10) +
-      tasksStr.padEnd(10) +
-      lexicon.padEnd(12) +
-      overview
-    );
-  }
-
-  return 0;
-}
-
-/**
- * chant spell show <name>
- */
-export async function runSpellShow(ctx: CommandContext): Promise<number> {
-  const name = ctx.args.extraPositional;
-  if (!name) {
-    console.error(formatError({ message: "Name is required: chant spell show <name>" }));
-    return 1;
-  }
-
-  const { spells, errors } = await discoverSpells();
-  const spell = spells.get(name);
-
-  if (!spell) {
-    // Try to reconstruct from git history
-    const rt = getRuntime();
-    const result = await rt.spawn([
-      "git", "log", "--all", "--format=%H", "--diff-filter=D",
-      "--", `spells/${name}.spell.ts`,
-    ]);
-    if (result.exitCode === 0 && result.stdout.trim()) {
-      const commit = result.stdout.trim().split("\n")[0];
-      const showResult = await rt.spawn([
-        "git", "show", `${commit}^:spells/${name}.spell.ts`,
-      ]);
-      if (showResult.exitCode === 0) {
-        console.log(`(Reconstructed from git history, commit ${commit.slice(0, 7)})\n`);
-        console.log(showResult.stdout);
-        return 0;
-      }
-    }
-
-    console.error(formatError({ message: `Spell "${name}" not found` }));
-    return 1;
-  }
-
-  const def = spell.definition;
-  const doneCount = def.tasks.filter((t) => t.done).length;
-
-  console.log(formatBold(def.name));
-  console.log(`Status: ${spell.status} [${doneCount}/${def.tasks.length}]`);
-  if (def.lexicon) console.log(`Lexicon: ${def.lexicon}`);
-  console.log(`\n${def.overview}\n`);
-
-  console.log("Tasks:");
-  def.tasks.forEach((t, i) => {
-    const check = t.done ? "[x]" : "[ ]";
-    console.log(`  ${i + 1}. ${check} ${t.description}`);
-  });
-
-  if (def.depends && def.depends.length > 0) {
-    console.log(`\nDepends: ${def.depends.join(", ")}`);
-  }
-
-  if (def.afterAll && def.afterAll.length > 0) {
-    console.log(`\nAfter all: ${def.afterAll.join(", ")}`);
-  }
-
-  return 0;
-}
-
-/**
- * chant spell cast <name> — generate bootstrap prompt
- */
-export async function runSpellCast(ctx: CommandContext): Promise<number> {
-  const name = ctx.args.extraPositional;
-  if (!name) {
-    console.error(formatError({ message: "Name is required: chant spell cast <name>" }));
-    return 1;
-  }
-
-  const { spells, errors } = await discoverSpells();
-
-  for (const err of errors) {
-    console.error(formatError({ message: err }));
-  }
-
-  const spell = spells.get(name);
-  if (!spell) {
-    console.error(formatError({ message: `Spell "${name}" not found` }));
-    return 1;
-  }
-
-  // Warn if blocked or done (unless --force)
-  if (spell.status === "blocked" && !ctx.args.force) {
-    console.error(formatWarning({
-      message: `Spell "${name}" is blocked by incomplete dependencies`,
-      hint: "Use --force to proceed anyway",
-    }));
-    return 1;
-  }
-  if (spell.status === "done" && !ctx.args.force) {
-    console.error(formatWarning({
-      message: `Spell "${name}" is already done`,
-      hint: "Use --force to proceed anyway",
-    }));
-    return 1;
-  }
-
-  const gitRoot = await findGitRoot();
-
-  // Load the spell's lexicon plugin directly (not all project lexicons)
-  const plugins: import("../../lexicon").LexiconPlugin[] = [];
-  if (spell.definition.lexicon) {
-    try {
-      const plugin = await loadPlugin(spell.definition.lexicon);
-      if (plugin.init) await plugin.init();
-      plugins.push(plugin);
-    } catch {
-      console.error(formatWarning({
-        message: `Lexicon "${spell.definition.lexicon}" could not be loaded — skills will not be inlined`,
-        hint: `Install @intentius/chant-lexicon-${spell.definition.lexicon}`,
-      }));
-    }
-  }
-
-  const prompt = await generatePrompt(spell.definition, {
-    gitRoot,
-    plugins: plugins.length > 0 ? plugins : undefined,
-  });
-
-  console.log(prompt);
-  return 0;
-}
-
-/**
- * chant spell done <name> <task-number>
- *
- * Rewrites task() call in the source file to mark it as done.
- */
-export async function runSpellDone(ctx: CommandContext): Promise<number> {
-  const name = ctx.args.extraPositional;
-  const taskNumStr = ctx.args.extraPositional2;
-
-  if (!name || !taskNumStr) {
-    console.error(formatError({ message: "Usage: chant spell done <name> <task-number>" }));
-    return 1;
-  }
-
-  const taskNum = parseInt(taskNumStr, 10);
-  if (isNaN(taskNum) || taskNum < 1) {
-    console.error(formatError({ message: `Invalid task number: ${taskNumStr}` }));
-    return 1;
-  }
-
-  const { spells } = await discoverSpells();
-  const spell = spells.get(name);
-  if (!spell) {
-    console.error(formatError({ message: `Spell "${name}" not found` }));
-    return 1;
-  }
-
-  if (taskNum > spell.definition.tasks.length) {
-    console.error(formatError({
-      message: `Task ${taskNum} does not exist (spell has ${spell.definition.tasks.length} tasks)`,
-    }));
-    return 1;
-  }
-
-  const task = spell.definition.tasks[taskNum - 1];
-  if (task.done) {
-    console.error(formatWarning({ message: `Task ${taskNum} is already done` }));
-    return 0;
-  }
-
-  // Rewrite the source file
-  const content = readFileSync(spell.filePath, "utf-8");
-  const rewritten = markTaskDone(content, taskNum);
-
-  if (rewritten === content) {
-    console.error(formatError({ message: `Could not find task ${taskNum} in source file` }));
-    return 1;
-  }
-
-  writeFileSync(spell.filePath, rewritten);
-  console.error(formatSuccess(`Task ${taskNum} marked done: "${task.description}"`));
-  return 0;
-}
-
-/**
- * Regex-based rewrite: find the Nth task() call and add { done: true }.
- */
-function markTaskDone(source: string, taskNum: number): string {
-  let count = 0;
-  // Match task("...") or task("...", { done: false })
-  return source.replace(
-    /task\(("[^"]*"|'[^']*'|`[^`]*`)((?:\s*,\s*\{[^}]*\})?)\)/g,
-    (match, desc, opts) => {
-      count++;
-      if (count !== taskNum) return match;
-
-      // Already has opts — replace done: false with done: true or add done: true
-      if (opts && opts.includes("done:")) {
-        return match.replace(/done:\s*false/, "done: true");
-      }
-      return `task(${desc}, { done: true })`;
-    },
-  );
-}
-
-/**
- * chant graph — show dependency graph
- */
-export async function runGraph(ctx: CommandContext): Promise<number> {
-  const { spells, errors } = await discoverSpells();
-
-  for (const err of errors) {
-    console.error(formatError({ message: err }));
-  }
-
-  if (spells.size === 0) {
-    console.error(formatWarning({ message: "No spells found" }));
-    return 0;
-  }
-
-  let hasEdges = false;
-  for (const [name, spell] of spells) {
-    const deps = spell.definition.depends;
-    if (deps && deps.length > 0) {
-      for (const dep of deps) {
-        console.log(`${dep} → ${name}`);
-        hasEdges = true;
-      }
-    }
-  }
-
-  if (!hasEdges) {
-    console.log("No dependencies");
-  }
-
-  return 0;
-}
-
-/**
- * Fallback for unknown spell subcommands.
- */
-export async function runSpellUnknown(ctx: CommandContext): Promise<number> {
-  console.error(formatError({
-    message: `Unknown spell subcommand: ${ctx.args.extraPositional ?? ctx.args.path}`,
-    hint: "Available: chant spell add, chant spell rm, chant spell list, chant spell show, chant spell cast, chant spell done",
-  }));
-  return 1;
-}