@intentius/chant 0.0.16 → 0.0.22

package/src/cli/handlers/spell.ts

@@ -0,0 +1,396 @@
+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;
+}

package/src/cli/handlers/state.ts

@@ -0,0 +1,230 @@
+import { resolve } from "node:path";
+import { build } from "../../build";
+import { takeSnapshot } from "../../state/snapshot";
+import { readSnapshot, readEnvironmentSnapshots, listSnapshots, fetchState } from "../../state/git";
+import { computeBuildDigest, diffDigests } from "../../state/digest";
+import { loadChantConfig } from "../../config";
+import { formatError, formatWarning, formatSuccess, formatBold } from "../format";
+import type { CommandContext } from "../registry";
+import type { StateSnapshot } from "../../state/types";
+
+/**
+ * chant state snapshot <environment> [lexicon]
+ */
+export async function runStateSnapshot(ctx: CommandContext): Promise<number> {
+  const { args, plugins } = ctx;
+  const environment = args.extraPositional;
+  const lexiconFilter = args.extraPositional2;
+
+  if (!environment) {
+    console.error(formatError({ message: "Environment is required: chant state snapshot <environment> [lexicon]" }));
+    return 1;
+  }
+
+  // Validate environment against config
+  const projectPath = resolve(".");
+  const { config } = await loadChantConfig(projectPath);
+  if (config.environments && !config.environments.includes(environment)) {
+    console.error(formatError({
+      message: `Unknown environment "${environment}"`,
+      hint: `Defined environments: ${config.environments.join(", ")}`,
+    }));
+    return 1;
+  }
+
+  // Filter plugins if lexicon specified
+  const targetPlugins = lexiconFilter
+    ? plugins.filter((p) => p.name === lexiconFilter)
+    : plugins;
+  const targetSerializers = targetPlugins.map((p) => p.serializer);
+
+  // Build first to get entity names and build output
+  const buildResult = await build(projectPath, targetSerializers);
+  if (buildResult.errors.length > 0) {
+    console.error(formatError({ message: "Build failed — fix errors before taking a snapshot" }));
+    return 1;
+  }
+
+  const pluginsWithDescribe = targetPlugins.filter((p) => p.describeResources);
+  if (pluginsWithDescribe.length === 0) {
+    console.error(formatError({
+      message: "No plugins implement describeResources",
+      hint: lexiconFilter ? `Lexicon "${lexiconFilter}" does not support state snapshots` : undefined,
+    }));
+    return 1;
+  }
+
+  const result = await takeSnapshot(environment, pluginsWithDescribe, buildResult);
+
+  for (const w of result.warnings) {
+    console.error(formatWarning({ message: w }));
+  }
+  for (const e of result.errors) {
+    console.error(formatError({ message: e }));
+  }
+
+  if (result.snapshots.length > 0) {
+    const counts = result.snapshots
+      .map((s) => `${s.lexicon}(${Object.keys(s.resources).length})`)
+      .join(" ");
+    console.error(formatSuccess(`Snapshot saved to chant/state (${counts})`));
+  }
+
+  return result.errors.length > 0 && result.snapshots.length === 0 ? 1 : 0;
+}
+
+/**
+ * chant state show <environment> [lexicon]
+ */
+export async function runStateShow(ctx: CommandContext): Promise<number> {
+  const environment = ctx.args.extraPositional;
+  const lexiconFilter = ctx.args.extraPositional2;
+
+  if (!environment) {
+    console.error(formatError({ message: "Environment is required: chant state show <environment> [lexicon]" }));
+    return 1;
+  }
+
+  // Fetch from remote first
+  await fetchState();
+
+  if (lexiconFilter) {
+    const content = await readSnapshot(environment, lexiconFilter);
+    if (!content) {
+      console.error(formatError({ message: `No snapshot found for ${environment}/${lexiconFilter}` }));
+      return 1;
+    }
+
+    const snapshot: StateSnapshot = JSON.parse(content);
+    printSnapshotTable(snapshot);
+  } else {
+    const snapshots = await readEnvironmentSnapshots(environment);
+    if (snapshots.size === 0) {
+      console.error(formatError({ message: `No snapshots found for environment "${environment}"` }));
+      return 1;
+    }
+
+    for (const [lexicon, content] of snapshots) {
+      const snapshot: StateSnapshot = JSON.parse(content);
+      console.log(`\n${formatBold(`${environment}/${lexicon}`)} — ${Object.keys(snapshot.resources).length} resources — ${snapshot.timestamp}`);
+      printSnapshotTable(snapshot);
+    }
+  }
+
+  return 0;
+}
+
+/**
+ * chant state diff <environment> [lexicon]
+ */
+export async function runStateDiff(ctx: CommandContext): Promise<number> {
+  const { args, plugins, serializers } = ctx;
+  const environment = args.extraPositional;
+  const lexiconFilter = args.extraPositional2;
+
+  if (!environment) {
+    console.error(formatError({ message: "Environment is required: chant state diff <environment> [lexicon]" }));
+    return 1;
+  }
+
+  // Filter serializers to target lexicon before building
+  const targetSerializers = lexiconFilter
+    ? plugins.filter((p) => p.name === lexiconFilter).map((p) => p.serializer)
+    : serializers;
+
+  // Build to get current digest
+  const projectPath = resolve(".");
+  const buildResult = await build(projectPath, targetSerializers);
+  if (buildResult.errors.length > 0) {
+    console.error(formatError({ message: "Build failed — fix errors before diffing" }));
+    return 1;
+  }
+
+  const currentDigest = computeBuildDigest(buildResult);
+
+  // Fetch and read previous snapshot
+  await fetchState();
+
+  const lexicons = lexiconFilter
+    ? [lexiconFilter]
+    : Array.from(buildResult.manifest.lexicons);
+
+  for (const lexicon of lexicons) {
+    const content = await readSnapshot(environment, lexicon);
+    let previousDigest = undefined;
+    if (content) {
+      const snapshot: StateSnapshot = JSON.parse(content);
+      previousDigest = snapshot.digest;
+    }
+
+    const diff = diffDigests(currentDigest, previousDigest);
+
+    console.log(`\n${formatBold(lexicon)}`);
+    console.log("RESOURCE".padEnd(20) + "STATUS".padEnd(12) + "TYPE");
+    console.log("-".repeat(60));
+
+    for (const name of diff.added) {
+      console.log(name.padEnd(20) + "added".padEnd(12) + (currentDigest.resources[name]?.type ?? ""));
+    }
+    for (const name of diff.changed) {
+      console.log(name.padEnd(20) + "changed".padEnd(12) + (currentDigest.resources[name]?.type ?? ""));
+    }
+    for (const name of diff.removed) {
+      console.log(name.padEnd(20) + "removed".padEnd(12) + (previousDigest?.resources[name]?.type ?? ""));
+    }
+    for (const name of diff.unchanged) {
+      console.log(name.padEnd(20) + "unchanged".padEnd(12) + (currentDigest.resources[name]?.type ?? ""));
+    }
+  }
+
+  return 0;
+}
+
+/**
+ * chant state log [environment]
+ */
+export async function runStateLog(ctx: CommandContext): Promise<number> {
+  const environment = ctx.args.extraPositional;
+
+  await fetchState();
+
+  const entries = await listSnapshots({ environment });
+  if (entries.length === 0) {
+    console.error(formatError({ message: "No state snapshots found" }));
+    return 1;
+  }
+
+  for (const entry of entries) {
+    const date = entry.date.split("T")[0];
+    console.log(`${entry.commit.slice(0, 7)}  ${date}  ${entry.message}`);
+  }
+
+  return 0;
+}
+
+/**
+ * Fallback for unknown state subcommands.
+ */
+export async function runStateUnknown(ctx: CommandContext): Promise<number> {
+  console.error(formatError({
+    message: `Unknown state subcommand: ${ctx.args.extraPositional ?? ctx.args.path}`,
+    hint: "Available: chant state snapshot, chant state show, chant state diff, chant state log",
+  }));
+  return 1;
+}
+
+function printSnapshotTable(snapshot: StateSnapshot): void {
+  console.log("RESOURCE".padEnd(20) + "TYPE".padEnd(28) + "PHYSICAL ID".padEnd(44) + "STATUS");
+  console.log("-".repeat(100));
+
+  for (const [name, meta] of Object.entries(snapshot.resources)) {
+    const physicalId = meta.physicalId ?? "";
+    const truncId = physicalId.length > 40 ? physicalId.slice(0, 37) + "..." : physicalId;
+    console.log(
+      name.padEnd(20) +
+      meta.type.padEnd(28) +
+      truncId.padEnd(44) +
+      meta.status
+    );
+  }
+}

package/src/cli/lsp/server.test.ts

@@ -10,6 +10,10 @@ function createMockPlugin(overrides?: Partial<LexiconPlugin>): LexiconPlugin {
   return {
     name: "mock",
     serializer: { name: "mock", serialize: () => "" } as unknown as Serializer,
+    generate: async () => {},
+    validate: async () => {},
+    coverage: async () => {},
+    package: async () => {},
     ...overrides,
   };
 }

package/src/cli/main.ts

@@ -12,6 +12,8 @@ import { runDevGenerate, runDevPublish, runDevOnboard, runDevCheckLexicon, runDe
 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";
 
 /**
  * Parse command line arguments
@@ -91,6 +93,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
+
+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
+  state log [env]       History of state snapshots
+
 Lexicon development:
   dev generate          Generate lexicon artifacts (+ validate + coverage)
   dev publish           Package lexicon for distribution
@@ -177,11 +194,28 @@ 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 },
+  { name: "graph", handler: runGraph },
+
+  // State subcommands
+  { name: "state snapshot", requiresPlugins: true, handler: runStateSnapshot },
+  { name: "state show", handler: runStateShow },
+  { name: "state diff", requiresPlugins: true, handler: runStateDiff },
+  { name: "state log", handler: runStateLog },
+
   // Serve subcommands
   { name: "serve lsp", requiresPlugins: true, handler: runServeLsp },
   { 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 },
 ];
@@ -216,9 +250,9 @@ async function main(): Promise<void> {
     process.exit(1);
   }
 
-  // For compound commands (e.g. "dev generate"), args.path is the subcommand,
-  // so the project path shifts to extraPositional. For simple commands, use args.path.
-  const projectPath = match.compound ? (args.extraPositional ?? ".") : args.path;
+  // For compound commands (e.g. "spell cast"), args.path is the subcommand,
+  // so always use "." as the project path. For simple commands, use args.path.
+  const projectPath = match.compound ? "." : args.path;
   const plugins = match.def.requiresPlugins
     ? await loadPluginsOrExit(projectPath)
     : [];