agentplane 0.3.12 → 0.3.14

package/dist/testing/cli-harness.js

@@ -0,0 +1,313 @@
+import { execFile } from "node:child_process";
+import { access, cp, mkdir, mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { afterAll, afterEach, beforeAll, beforeEach, vi } from "vitest";
+import { defaultConfig } from "@agentplaneorg/core";
+import { runCliSilent, silenceStdIO } from "./cli-harness/stdio.js";
+export * from "./cli-harness/recipe-archives.js";
+export * from "./cli-harness/stdio.js";
+const execFileAsync = promisify(execFile);
+let agentplaneHome = null;
+const testRoots = new Set();
+const originalAgentplaneHome = process.env.AGENTPLANE_HOME;
+const originalNoUpdateCheck = process.env.AGENTPLANE_NO_UPDATE_CHECK;
+const originalGitAuthorName = process.env.GIT_AUTHOR_NAME;
+const originalGitAuthorEmail = process.env.GIT_AUTHOR_EMAIL;
+const originalGitCommitterName = process.env.GIT_COMMITTER_NAME;
+const originalGitCommitterEmail = process.env.GIT_COMMITTER_EMAIL;
+const originalHookRunner = process.env.AGENTPLANE_HOOK_RUNNER;
+let gitTemplateRoot = null;
+let gitTemplatePromise = null;
+async function ensureGitTemplateRoot() {
+    if (gitTemplateRoot)
+        return gitTemplateRoot;
+    gitTemplatePromise ??= (async () => {
+        const root = await mkdtemp(path.join(os.tmpdir(), "agentplane-git-template-"));
+        await execFileAsync("git", ["init", "-q"], { cwd: root, env: cleanGitEnv() });
+        // Tests must not rely on global git config. Configure author identity locally
+        // so any helper that creates commits works in CI.
+        await execFileAsync("git", ["config", "user.email", "agentplane-test@example.com"], {
+            cwd: root,
+            env: cleanGitEnv(),
+        });
+        await execFileAsync("git", ["config", "user.name", "agentplane-test"], {
+            cwd: root,
+            env: cleanGitEnv(),
+        });
+        return root;
+    })();
+    gitTemplateRoot = await gitTemplatePromise;
+    return gitTemplateRoot;
+}
+async function copyDirContents(src, dest) {
+    const entries = await readdir(src, { withFileTypes: true });
+    await Promise.all(entries.map((entry) => cp(path.join(src, entry.name), path.join(dest, entry.name), { recursive: true })));
+}
+export function registerAgentplaneHome() {
+    beforeAll(async () => {
+        agentplaneHome = await mkdtemp(path.join(os.tmpdir(), "agentplane-home-"));
+        process.env.AGENTPLANE_HOME = agentplaneHome;
+        process.env.AGENTPLANE_NO_UPDATE_CHECK = "1";
+        process.env.AGENTPLANE_HOOK_RUNNER ??= path.join(process.cwd(), "packages", "agentplane", "bin", "agentplane.js");
+        // Keep tests hermetic: never rely on global git config for commit authorship.
+        process.env.GIT_AUTHOR_NAME ??= "agentplane-test";
+        process.env.GIT_AUTHOR_EMAIL ??= "agentplane-test@example.com";
+        process.env.GIT_COMMITTER_NAME ??= "agentplane-test";
+        process.env.GIT_COMMITTER_EMAIL ??= "agentplane-test@example.com";
+    });
+    afterAll(async () => {
+        if (agentplaneHome) {
+            await rm(agentplaneHome, { recursive: true, force: true });
+        }
+        if (originalAgentplaneHome === undefined) {
+            delete process.env.AGENTPLANE_HOME;
+        }
+        else {
+            process.env.AGENTPLANE_HOME = originalAgentplaneHome;
+        }
+        if (originalNoUpdateCheck === undefined) {
+            delete process.env.AGENTPLANE_NO_UPDATE_CHECK;
+        }
+        else {
+            process.env.AGENTPLANE_NO_UPDATE_CHECK = originalNoUpdateCheck;
+        }
+        if (originalGitAuthorName === undefined)
+            delete process.env.GIT_AUTHOR_NAME;
+        else
+            process.env.GIT_AUTHOR_NAME = originalGitAuthorName;
+        if (originalGitAuthorEmail === undefined)
+            delete process.env.GIT_AUTHOR_EMAIL;
+        else
+            process.env.GIT_AUTHOR_EMAIL = originalGitAuthorEmail;
+        if (originalGitCommitterName === undefined)
+            delete process.env.GIT_COMMITTER_NAME;
+        else
+            process.env.GIT_COMMITTER_NAME = originalGitCommitterName;
+        if (originalGitCommitterEmail === undefined)
+            delete process.env.GIT_COMMITTER_EMAIL;
+        else
+            process.env.GIT_COMMITTER_EMAIL = originalGitCommitterEmail;
+        if (originalHookRunner === undefined)
+            delete process.env.AGENTPLANE_HOOK_RUNNER;
+        else
+            process.env.AGENTPLANE_HOOK_RUNNER = originalHookRunner;
+    });
+    afterEach(async () => {
+        const roots = [...testRoots];
+        testRoots.clear();
+        await Promise.all(roots.map(async (root) => {
+            await rm(path.join(root, ".agentplane", ".upgrade"), { recursive: true, force: true });
+            await rm(path.join(root, ".agentplane", ".release"), { recursive: true, force: true });
+        }));
+    });
+}
+export function installRunCliIntegrationHarness() {
+    registerAgentplaneHome();
+    let restoreStdIO = null;
+    beforeEach(() => {
+        restoreStdIO = silenceStdIO();
+    });
+    afterEach(() => {
+        restoreStdIO?.();
+        restoreStdIO = null;
+    });
+}
+export function getAgentplaneHome() {
+    return agentplaneHome;
+}
+export function stubTaskBackend(overrides = {}) {
+    return {
+        id: "local",
+        capabilities: {
+            canonical_source: "local",
+            projection: "canonical",
+            projection_read_mode: "fallback",
+            reads_from_projection_by_default: false,
+            writes_task_readmes: true,
+            supports_task_revisions: true,
+            supports_revision_guarded_writes: true,
+            may_access_network_on_read: false,
+            may_access_network_on_write: false,
+            supports_projection_refresh: false,
+            supports_push_sync: false,
+            supports_snapshot_export: false,
+        },
+        listTasks: vi.fn().mockResolvedValue([]),
+        getTask: vi.fn().mockResolvedValue(null),
+        writeTask: vi.fn().mockImplementation(() => Promise.resolve()),
+        ...overrides,
+    };
+}
+export async function mkGitRepoRoot() {
+    const template = await ensureGitTemplateRoot();
+    const root = await mkdtemp(path.join(os.tmpdir(), "agentplane-cli-test-"));
+    await copyDirContents(template, root);
+    testRoots.add(root);
+    return root;
+}
+export async function mkTempDir() {
+    const root = await mkdtemp(path.join(os.tmpdir(), "agentplane-cli-test-"));
+    testRoots.add(root);
+    return root;
+}
+export async function writeDefaultConfig(root) {
+    const agentplaneDir = path.join(root, ".agentplane");
+    await mkdir(agentplaneDir, { recursive: true });
+    const configPath = path.join(agentplaneDir, "config.json");
+    await writeFile(configPath, JSON.stringify(defaultConfig(), null, 2), "utf8");
+}
+export async function writeAndConfigureRoot() {
+    const root = await mkGitRepoRoot();
+    await writeDefaultConfig(root);
+    return root;
+}
+export async function approveTaskPlan(root, taskId) {
+    await runCliSilent([
+        "task",
+        "plan",
+        "set",
+        taskId,
+        "--text",
+        "1) Do the work\n2) Verify the work",
+        "--updated-by",
+        "ORCHESTRATOR",
+        "--root",
+        root,
+    ]);
+    await runCliSilent([
+        "task",
+        "plan",
+        "approve",
+        taskId,
+        "--by",
+        "USER",
+        "--note",
+        "OK",
+        "--root",
+        root,
+    ]);
+}
+export async function recordVerificationOk(root, taskId) {
+    await runCliSilent([
+        "task",
+        "doc",
+        "set",
+        taskId,
+        "--section",
+        "Verify Steps",
+        "--text",
+        "Run verify for this task. Expected: verification records successfully.",
+        "--root",
+        root,
+    ]);
+    await runCliSilent([
+        "verify",
+        taskId,
+        "--ok",
+        "--by",
+        "REVIEWER",
+        "--note",
+        "Ok to integrate",
+        "--quiet",
+        "--root",
+        root,
+    ]);
+}
+export async function writeConfig(root, config) {
+    const agentplaneDir = path.join(root, ".agentplane");
+    await mkdir(agentplaneDir, { recursive: true });
+    const configPath = path.join(agentplaneDir, "config.json");
+    await writeFile(configPath, JSON.stringify(config, null, 2), "utf8");
+}
+export async function resetAgentplaneHomeRecipes() {
+    if (!agentplaneHome)
+        return;
+    await rm(path.join(agentplaneHome, "recipes-store"), { recursive: true, force: true });
+    await rm(path.join(agentplaneHome, "recipes.json"), { force: true });
+    await rm(path.join(agentplaneHome, "recipes-index.json"), { force: true });
+}
+export async function mkGitRepoRootWithBranch(branch) {
+    const root = await mkGitRepoRoot();
+    await execFileAsync("git", ["checkout", "-b", branch], { cwd: root, env: cleanGitEnv() });
+    return root;
+}
+export async function configureGitUser(root) {
+    await execFileAsync("git", ["config", "user.email", "test@example.com"], {
+        cwd: root,
+        env: cleanGitEnv(),
+    });
+    await execFileAsync("git", ["config", "user.name", "Test User"], {
+        cwd: root,
+        env: cleanGitEnv(),
+    });
+}
+export function cleanGitEnv() {
+    const env = { ...process.env };
+    delete env.GIT_DIR;
+    delete env.GIT_WORK_TREE;
+    delete env.GIT_COMMON_DIR;
+    delete env.GIT_INDEX_FILE;
+    delete env.GIT_OBJECT_DIRECTORY;
+    delete env.GIT_ALTERNATE_OBJECT_DIRECTORIES;
+    env.GIT_CONFIG_GLOBAL = "/dev/null";
+    env.GIT_CONFIG_SYSTEM = "/dev/null";
+    env.GIT_TERMINAL_PROMPT = "0";
+    env.GIT_AUTHOR_NAME = env.GIT_AUTHOR_NAME ?? "Agentplane Test";
+    env.GIT_AUTHOR_EMAIL = env.GIT_AUTHOR_EMAIL ?? "agentplane-test@example.com";
+    env.GIT_COMMITTER_NAME = env.GIT_COMMITTER_NAME ?? "Agentplane Test";
+    env.GIT_COMMITTER_EMAIL = env.GIT_COMMITTER_EMAIL ?? "agentplane-test@example.com";
+    return env;
+}
+export async function pathExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function gitBranchExists(root, branch) {
+    try {
+        await execFileAsync("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], {
+            cwd: root,
+            env: cleanGitEnv(),
+        });
+        return true;
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === 1)
+            return false;
+        throw err;
+    }
+}
+export async function commitAll(root, message) {
+    await execFileAsync("git", ["add", "."], { cwd: root, env: cleanGitEnv() });
+    await execFileAsync("git", ["commit", "--no-verify", "-m", message], {
+        cwd: root,
+        env: cleanGitEnv(),
+    });
+}
+export async function commitPathsIfChanged(root, paths, message) {
+    await execFileAsync("git", ["add", "--", ...paths], { cwd: root, env: cleanGitEnv() });
+    const { stdout } = await execFileAsync("git", ["diff", "--cached", "--name-only", "--", ...paths], {
+        cwd: root,
+        env: cleanGitEnv(),
+    });
+    if (!stdout.trim())
+        return false;
+    await execFileAsync("git", ["commit", "--no-verify", "-m", message], {
+        cwd: root,
+        env: cleanGitEnv(),
+    });
+    return true;
+}
+export async function stageGitignoreIfPresent(root) {
+    const gitignorePath = path.join(root, ".gitignore");
+    if (!(await pathExists(gitignorePath)))
+        return;
+    await execFileAsync("git", ["add", ".gitignore"], { cwd: root, env: cleanGitEnv() });
+}

package/dist/testing/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./cli-harness.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}

package/dist/testing/index.js

@@ -0,0 +1 @@
+export * from "./cli-harness.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentplane",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "Agent Plane CLI for task workflows, recipes, and project automation.",
   "keywords": [
     "agentplane",
@@ -35,6 +35,9 @@
   "bin": {
     "agentplane": "bin/agentplane.js"
   },
+  "exports": {
+    "./internal/testing": "./dist/testing/index.js"
+  },
   "files": [
     "bin",
     "dist",
@@ -48,14 +51,15 @@
   },
   "scripts": {
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true}); require('node:fs').rmSync('tsconfig.tsbuildinfo',{force:true});\"",
-    "build": "tsc -b && node ../../scripts/write-build-manifest.mjs .",
+    "build": "tsc -b && node ../../scripts/manifest.mjs build .",
     "typecheck": "tsc -b",
     "prepare": "npm run build",
     "prepack": "npm run clean && npm run build",
     "prepublishOnly": "node ../../scripts/enforce-github-publish.mjs && npm run prepack"
   },
   "dependencies": {
-    "@agentplaneorg/core": "0.3.12",
+    "@agentplaneorg/core": "0.3.14",
+    "@agentplaneorg/recipes": "0.3.14",
     "yauzl": "^2.10.0"
   },
   "devDependencies": {

package/dist/cli/recipes-bundled.d.ts

@@ -1,10 +0,0 @@
-export type BundledRecipeInfo = {
-    id: string;
-    summary: string;
-    version: string;
-};
-export declare function listBundledRecipes(): BundledRecipeInfo[];
-export declare function renderBundledRecipesHint(): string;
-export declare function validateBundledRecipesSelection(recipes: string[]): void;
-export declare function getBundledRecipeSourcePath(recipeId: string): string | null;
-//# sourceMappingURL=recipes-bundled.d.ts.map

package/dist/cli/recipes-bundled.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"recipes-bundled.d.ts","sourceRoot":"","sources":["../../src/cli/recipes-bundled.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,iBAAiB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjF,wBAAgB,kBAAkB,IAAI,iBAAiB,EAAE,CAMxD;AAED,wBAAgB,wBAAwB,IAAI,MAAM,CAMjD;AAED,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,CAevE;AAED,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAE1E"}

package/dist/cli/recipes-bundled.js

@@ -1,36 +0,0 @@
-import { BUNDLED_RECIPES_CATALOG, resolveBundledRecipeSourcePath, } from "../recipes/bundled-recipes.js";
-import { CliError } from "../shared/errors.js";
-export function listBundledRecipes() {
-    return BUNDLED_RECIPES_CATALOG.recipes.map((recipe) => ({
-        id: recipe.id,
-        summary: recipe.summary,
-        version: recipe.versions.at(-1)?.version ?? "unknown",
-    }));
-}
-export function renderBundledRecipesHint() {
-    const entries = listBundledRecipes();
-    if (entries.length === 0) {
-        return "Bundled recipes: none";
-    }
-    return `Bundled recipes: ${entries.map((entry) => entry.id).join(", ")}`;
-}
-export function validateBundledRecipesSelection(recipes) {
-    if (recipes.length === 0)
-        return;
-    const available = listBundledRecipes().map((entry) => entry.id);
-    if (available.length === 0) {
-        process.stdout.write(`${renderBundledRecipesHint()}\n`);
-        return;
-    }
-    const missing = recipes.filter((recipe) => !available.includes(recipe));
-    if (missing.length > 0) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: `Unknown recipe id(s): ${missing.join(", ")}. ${renderBundledRecipesHint()}`,
-        });
-    }
-}
-export function getBundledRecipeSourcePath(recipeId) {
-    return resolveBundledRecipeSourcePath(recipeId);
-}

package/dist/commands/recipes/impl/manifest.d.ts

@@ -1,4 +0,0 @@
-import type { RecipeManifest } from "./types.js";
-export declare function validateRecipeManifest(raw: unknown): RecipeManifest;
-export declare function readRecipeManifest(manifestPath: string): Promise<RecipeManifest>;
-//# sourceMappingURL=manifest.d.ts.map

package/dist/commands/recipes/impl/manifest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../../src/commands/recipes/impl/manifest.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAGV,cAAc,EAKf,MAAM,YAAY,CAAC;AA0OpB,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,OAAO,GAAG,cAAc,CAsDnE;AAED,wBAAsB,kBAAkB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAGtF"}

package/dist/commands/recipes/impl/manifest.js

@@ -1,229 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { invalidFieldMessage, requiredFieldMessage } from "../../../cli/output.js";
-import { isRecord } from "../../../shared/guards.js";
-import { dedupeStrings } from "../../../shared/strings.js";
-import { normalizeAgentId, normalizeRecipeId, normalizeRecipeRelativePath, normalizeRecipeTags, normalizeScenarioId, normalizeSkillId, normalizeToolId, } from "./normalize.js";
-function normalizeRequiredString(raw, field) {
-    if (typeof raw !== "string")
-        throw new Error(invalidFieldMessage(field, "string"));
-    const value = raw.trim();
-    if (!value)
-        throw new Error(requiredFieldMessage(field));
-    return value;
-}
-function normalizeOptionalString(raw, field) {
-    if (raw === undefined)
-        return undefined;
-    if (typeof raw !== "string")
-        throw new Error(invalidFieldMessage(field, "string"));
-    const value = raw.trim();
-    return value || undefined;
-}
-function normalizeStringList(raw, field, opts) {
-    if (!Array.isArray(raw))
-        throw new Error(invalidFieldMessage(field, "string[]"));
-    const values = raw.map((value) => {
-        if (typeof value !== "string")
-            throw new Error(invalidFieldMessage(field, "string[]"));
-        const trimmed = value.trim();
-        if (!trimmed)
-            throw new Error(invalidFieldMessage(field, "string[]"));
-        return trimmed;
-    });
-    const deduped = dedupeStrings(values);
-    if ((opts?.minLength ?? 0) > 0 && deduped.length < (opts?.minLength ?? 0)) {
-        throw new Error(invalidFieldMessage(field, `string[${opts?.minLength ?? 0}+]`));
-    }
-    return deduped;
-}
-function normalizeOptionalStringList(raw, field) {
-    if (raw === undefined)
-        return undefined;
-    return normalizeStringList(raw, field);
-}
-function normalizeNumber(raw, field) {
-    if (raw === undefined)
-        return undefined;
-    if (typeof raw !== "number" || Number.isNaN(raw)) {
-        throw new Error(invalidFieldMessage(field, "number"));
-    }
-    return raw;
-}
-function normalizeCompatibility(raw) {
-    if (raw === undefined)
-        return undefined;
-    if (!isRecord(raw))
-        throw new Error(invalidFieldMessage("manifest.compatibility", "object"));
-    return {
-        min_agentplane_version: normalizeOptionalString(raw.min_agentplane_version, "manifest.compatibility.min_agentplane_version"),
-        manifest_api_version: normalizeOptionalString(raw.manifest_api_version, "manifest.compatibility.manifest_api_version"),
-        scenario_api_version: normalizeOptionalString(raw.scenario_api_version, "manifest.compatibility.scenario_api_version"),
-        runtime_api_version: normalizeOptionalString(raw.runtime_api_version, "manifest.compatibility.runtime_api_version"),
-        platforms: normalizeOptionalStringList(raw.platforms, "manifest.compatibility.platforms"),
-        repo_types: normalizeOptionalStringList(raw.repo_types, "manifest.compatibility.repo_types"),
-    };
-}
-function normalizeRunProfile(raw, field) {
-    if (!isRecord(raw))
-        throw new Error(invalidFieldMessage(field, "object"));
-    return {
-        mode: normalizeRequiredString(raw.mode, `${field}.mode`),
-        sandbox: normalizeOptionalString(raw.sandbox, `${field}.sandbox`),
-        writes_artifacts_to: normalizeOptionalStringList(raw.writes_artifacts_to, `${field}.writes_artifacts_to`),
-    };
-}
-function normalizeSkills(raw) {
-    if (raw === undefined)
-        return undefined;
-    if (!Array.isArray(raw))
-        throw new Error(invalidFieldMessage("manifest.skills", "array"));
-    return raw.map((entry, index) => {
-        if (!isRecord(entry))
-            throw new Error(invalidFieldMessage(`manifest.skills[${index}]`, "object"));
-        return {
-            id: normalizeSkillId(normalizeRequiredString(entry.id, `manifest.skills[${index}].id`)),
-            summary: normalizeRequiredString(entry.summary, `manifest.skills[${index}].summary`),
-            kind: normalizeRequiredString(entry.kind, `manifest.skills[${index}].kind`),
-            file: normalizeRecipeRelativePath(`manifest.skills[${index}].file`, normalizeRequiredString(entry.file, `manifest.skills[${index}].file`)),
-        };
-    });
-}
-function normalizeTools(raw) {
-    if (raw === undefined)
-        return undefined;
-    if (!Array.isArray(raw))
-        throw new Error(invalidFieldMessage("manifest.tools", "array"));
-    return raw.map((entry, index) => {
-        if (!isRecord(entry))
-            throw new Error(invalidFieldMessage(`manifest.tools[${index}]`, "object"));
-        const runtime = normalizeRequiredString(entry.runtime, `manifest.tools[${index}].runtime`);
-        if (runtime !== "node" && runtime !== "bash") {
-            throw new Error(invalidFieldMessage(`manifest.tools[${index}].runtime`, '"node" | "bash"'));
-        }
-        return {
-            id: normalizeToolId(normalizeRequiredString(entry.id, `manifest.tools[${index}].id`)),
-            summary: normalizeRequiredString(entry.summary, `manifest.tools[${index}].summary`),
-            runtime,
-            entrypoint: normalizeRecipeRelativePath(`manifest.tools[${index}].entrypoint`, normalizeRequiredString(entry.entrypoint, `manifest.tools[${index}].entrypoint`)),
-            permissions: normalizeOptionalStringList(entry.permissions, `manifest.tools[${index}].permissions`),
-            timeout_ms: normalizeNumber(entry.timeout_ms, `manifest.tools[${index}].timeout_ms`),
-            cwd_policy: normalizeOptionalString(entry.cwd_policy, `manifest.tools[${index}].cwd_policy`),
-        };
-    });
-}
-function normalizeAgents(raw) {
-    if (raw === undefined)
-        return undefined;
-    if (!Array.isArray(raw))
-        throw new Error(invalidFieldMessage("manifest.agents", "array"));
-    return raw.map((entry, index) => {
-        if (!isRecord(entry))
-            throw new Error(invalidFieldMessage(`manifest.agents[${index}]`, "object"));
-        return {
-            id: normalizeAgentId(normalizeRequiredString(entry.id, `manifest.agents[${index}].id`)),
-            display_name: normalizeRequiredString(entry.display_name, `manifest.agents[${index}].display_name`),
-            role: normalizeRequiredString(entry.role, `manifest.agents[${index}].role`),
-            summary: normalizeRequiredString(entry.summary, `manifest.agents[${index}].summary`),
-            skills: normalizeOptionalStringList(entry.skills, `manifest.agents[${index}].skills`),
-            tools: normalizeOptionalStringList(entry.tools, `manifest.agents[${index}].tools`),
-            file: normalizeRecipeRelativePath(`manifest.agents[${index}].file`, normalizeRequiredString(entry.file, `manifest.agents[${index}].file`)),
-        };
-    });
-}
-function normalizeScenarios(raw) {
-    if (!Array.isArray(raw) || raw.length === 0) {
-        throw new Error(invalidFieldMessage("manifest.scenarios", "non-empty array"));
-    }
-    return raw.map((entry, index) => {
-        if (!isRecord(entry)) {
-            throw new Error(invalidFieldMessage(`manifest.scenarios[${index}]`, "object"));
-        }
-        return {
-            id: normalizeScenarioId(normalizeRequiredString(entry.id, `manifest.scenarios[${index}].id`)),
-            name: normalizeRequiredString(entry.name, `manifest.scenarios[${index}].name`),
-            summary: normalizeRequiredString(entry.summary, `manifest.scenarios[${index}].summary`),
-            description: normalizeOptionalString(entry.description, `manifest.scenarios[${index}].description`),
-            use_when: normalizeStringList(entry.use_when, `manifest.scenarios[${index}].use_when`, {
-                minLength: 1,
-            }),
-            avoid_when: normalizeOptionalStringList(entry.avoid_when, `manifest.scenarios[${index}].avoid_when`),
-            required_inputs: normalizeStringList(entry.required_inputs, `manifest.scenarios[${index}].required_inputs`),
-            outputs: normalizeStringList(entry.outputs, `manifest.scenarios[${index}].outputs`),
-            permissions: normalizeStringList(Array.isArray(entry.permissions) ? entry.permissions : [], `manifest.scenarios[${index}].permissions`),
-            artifacts: normalizeStringList(Array.isArray(entry.artifacts) ? entry.artifacts : [], `manifest.scenarios[${index}].artifacts`),
-            agents_involved: normalizeStringList(entry.agents_involved, `manifest.scenarios[${index}].agents_involved`, { minLength: 1 }),
-            skills_used: normalizeStringList(Array.isArray(entry.skills_used) ? entry.skills_used : [], `manifest.scenarios[${index}].skills_used`),
-            tools_used: normalizeStringList(Array.isArray(entry.tools_used) ? entry.tools_used : [], `manifest.scenarios[${index}].tools_used`),
-            run_profile: normalizeRunProfile(entry.run_profile, `manifest.scenarios[${index}].run_profile`),
-            file: normalizeRecipeRelativePath(`manifest.scenarios[${index}].file`, normalizeRequiredString(entry.file, `manifest.scenarios[${index}].file`)),
-        };
-    });
-}
-function assertUniqueIds(field, items) {
-    const seen = new Set();
-    for (const item of items) {
-        if (seen.has(item.id)) {
-            throw new Error(invalidFieldMessage(field, `unique ids (duplicate: ${item.id})`));
-        }
-        seen.add(item.id);
-    }
-}
-function assertKnownReferences(field, refs, known) {
-    if (!refs || refs.length === 0)
-        return;
-    const missing = refs.filter((ref) => !known.has(ref));
-    if (missing.length > 0) {
-        throw new Error(invalidFieldMessage(field, `known ids (missing: ${missing.join(", ")})`));
-    }
-}
-export function validateRecipeManifest(raw) {
-    if (!isRecord(raw))
-        throw new Error(invalidFieldMessage("manifest", "object"));
-    if (raw.schema_version !== "1")
-        throw new Error(invalidFieldMessage("manifest.schema_version", '"1"'));
-    const id = normalizeRecipeId(normalizeRequiredString(raw.id, "manifest.id"));
-    const version = normalizeRequiredString(raw.version, "manifest.version");
-    const tags = normalizeRecipeTags(raw.tags);
-    const compatibility = normalizeCompatibility(raw.compatibility);
-    const skills = normalizeSkills(raw.skills);
-    const tools = normalizeTools(raw.tools);
-    const agents = normalizeAgents(raw.agents);
-    const scenarios = normalizeScenarios(raw.scenarios);
-    if (skills)
-        assertUniqueIds("manifest.skills", skills);
-    if (tools)
-        assertUniqueIds("manifest.tools", tools);
-    if (agents)
-        assertUniqueIds("manifest.agents", agents);
-    assertUniqueIds("manifest.scenarios", scenarios);
-    const skillIds = new Set((skills ?? []).map((skill) => skill.id));
-    const toolIds = new Set((tools ?? []).map((tool) => tool.id));
-    const agentIds = new Set((agents ?? []).map((agent) => agent.id));
-    for (const [index, agent] of (agents ?? []).entries()) {
-        assertKnownReferences(`manifest.agents[${index}].skills`, agent.skills, skillIds);
-        assertKnownReferences(`manifest.agents[${index}].tools`, agent.tools, toolIds);
-    }
-    for (const [index, scenario] of scenarios.entries()) {
-        assertKnownReferences(`manifest.scenarios[${index}].agents_involved`, scenario.agents_involved, agentIds);
-        assertKnownReferences(`manifest.scenarios[${index}].skills_used`, scenario.skills_used, skillIds);
-        assertKnownReferences(`manifest.scenarios[${index}].tools_used`, scenario.tools_used, toolIds);
-    }
-    return {
-        schema_version: "1",
-        id,
-        version,
-        name: normalizeRequiredString(raw.name, "manifest.name"),
-        summary: normalizeRequiredString(raw.summary, "manifest.summary"),
-        description: normalizeRequiredString(raw.description, "manifest.description"),
-        tags: tags.length > 0 ? tags : undefined,
-        compatibility,
-        skills,
-        agents,
-        tools,
-        scenarios,
-    };
-}
-export async function readRecipeManifest(manifestPath) {
-    const raw = JSON.parse(await readFile(manifestPath, "utf8"));
-    return validateRecipeManifest(raw);
-}

package/dist/commands/recipes/impl/normalize.d.ts

@@ -1,8 +0,0 @@
-export declare function normalizeRecipeId(value: string): string;
-export declare function normalizeAgentId(value: string): string;
-export declare function normalizeSkillId(value: string): string;
-export declare function normalizeToolId(value: string): string;
-export declare function normalizeScenarioId(value: string): string;
-export declare function normalizeRecipeTags(value: unknown): string[];
-export declare function normalizeRecipeRelativePath(field: string, value: string): string;
-//# sourceMappingURL=normalize.d.ts.map

package/dist/commands/recipes/impl/normalize.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../src/commands/recipes/impl/normalize.ts"],"names":[],"mappings":"AAmBA,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAQ5D;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAWhF"}