agentplane 0.3.5 → 0.3.7

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

@@ -1,40 +1,236 @@
 import { readFile } from "node:fs/promises";
 import { invalidFieldMessage, requiredFieldMessage } from "../../../cli/output.js";
 import { isRecord } from "../../../shared/guards.js";
-import { normalizeRecipeId, normalizeRecipeTags } from "./normalize.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 normalizeBoolean(raw, field) {
+    if (raw === undefined)
+        return undefined;
+    if (typeof raw !== "boolean")
+        throw new Error(invalidFieldMessage(field, "boolean"));
+    return raw;
+}
+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`),
+        network: normalizeBoolean(raw.network, `${field}.network`),
+        requires_human_approval: normalizeBoolean(raw.requires_human_approval, `${field}.requires_human_approval`),
+        writes_artifacts_to: normalizeOptionalStringList(raw.writes_artifacts_to, `${field}.writes_artifacts_to`),
+        expected_exit_contract: normalizeOptionalString(raw.expected_exit_contract, `${field}.expected_exit_contract`),
+    };
+}
+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"'));
-    if (typeof raw.id !== "string")
-        throw new Error(invalidFieldMessage("manifest.id", "string"));
-    if (typeof raw.version !== "string")
-        throw new Error(invalidFieldMessage("manifest.version", "string"));
-    if (typeof raw.name !== "string")
-        throw new Error(invalidFieldMessage("manifest.name", "string"));
-    if (typeof raw.summary !== "string")
-        throw new Error(invalidFieldMessage("manifest.summary", "string"));
-    if (typeof raw.description !== "string")
-        throw new Error(invalidFieldMessage("manifest.description", "string"));
-    const id = normalizeRecipeId(raw.id);
-    const version = raw.version.trim();
-    if (!version)
-        throw new Error(requiredFieldMessage("manifest.version"));
+    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: raw.name.trim(),
-        summary: raw.summary.trim(),
-        description: raw.description.trim(),
+        name: normalizeRequiredString(raw.name, "manifest.name"),
+        summary: normalizeRequiredString(raw.summary, "manifest.summary"),
+        description: normalizeRequiredString(raw.description, "manifest.description"),
         tags: tags.length > 0 ? tags : undefined,
-        agents: Array.isArray(raw.agents) ? raw.agents : undefined,
-        tools: Array.isArray(raw.tools) ? raw.tools : undefined,
-        scenarios: Array.isArray(raw.scenarios)
-            ? raw.scenarios
-            : undefined,
+        compatibility,
+        skills,
+        agents,
+        tools,
+        scenarios,
     };
 }
 export async function readRecipeManifest(manifestPath) {

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

@@ -1,5 +1,8 @@
 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 +1 @@
-{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../src/commands/recipes/impl/normalize.ts"],"names":[],"mappings":"AAOA,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAUvD;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAUtD;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAUzD;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAQ5D"}
+{"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"}

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

@@ -1,40 +1,31 @@
 import { invalidPathMessage, requiredFieldMessage, invalidFieldMessage, } from "../../../cli/output.js";
 import { dedupeStrings } from "../../../shared/strings.js";
-export function normalizeRecipeId(value) {
+function normalizeScopedId(field, value) {
     const trimmed = value.trim();
     if (!trimmed)
-        throw new Error(requiredFieldMessage("manifest.id"));
+        throw new Error(requiredFieldMessage(field));
     if (trimmed.includes("/") || trimmed.includes("\\")) {
-        throw new Error(invalidPathMessage("manifest.id", "must not contain path separators"));
+        throw new Error(invalidPathMessage(field, "must not contain path separators"));
     }
     if (trimmed === "." || trimmed === "..") {
-        throw new Error(invalidPathMessage("manifest.id", "must not be '.' or '..'"));
+        throw new Error(invalidPathMessage(field, "must not be '.' or '..'"));
     }
     return trimmed;
 }
+export function normalizeRecipeId(value) {
+    return normalizeScopedId("manifest.id", value);
+}
 export function normalizeAgentId(value) {
-    const trimmed = value.trim();
-    if (!trimmed)
-        throw new Error(requiredFieldMessage("agent.id"));
-    if (trimmed.includes("/") || trimmed.includes("\\")) {
-        throw new Error(invalidPathMessage("agent.id", "must not contain path separators"));
-    }
-    if (trimmed === "." || trimmed === "..") {
-        throw new Error(invalidPathMessage("agent.id", "must not be '.' or '..'"));
-    }
-    return trimmed;
+    return normalizeScopedId("agent.id", value);
+}
+export function normalizeSkillId(value) {
+    return normalizeScopedId("skill.id", value);
+}
+export function normalizeToolId(value) {
+    return normalizeScopedId("tool.id", value);
 }
 export function normalizeScenarioId(value) {
-    const trimmed = value.trim();
-    if (!trimmed)
-        throw new Error(requiredFieldMessage("scenario.id"));
-    if (trimmed.includes("/") || trimmed.includes("\\")) {
-        throw new Error(invalidPathMessage("scenario.id", "must not contain path separators"));
-    }
-    if (trimmed === "." || trimmed === "..") {
-        throw new Error(invalidPathMessage("scenario.id", "must not be '.' or '..'"));
-    }
-    return trimmed;
+    return normalizeScopedId("scenario.id", value);
 }
 export function normalizeRecipeTags(value) {
     if (value === undefined)
@@ -48,3 +39,16 @@ export function normalizeRecipeTags(value) {
     });
     return dedupeStrings(tags);
 }
+export function normalizeRecipeRelativePath(field, value) {
+    const trimmed = value.trim().replaceAll("\\", "/");
+    if (!trimmed)
+        throw new Error(requiredFieldMessage(field));
+    if (trimmed.startsWith("/")) {
+        throw new Error(invalidPathMessage(field, "must be relative"));
+    }
+    const segments = trimmed.split("/");
+    if (segments.some((segment) => !segment || segment === "." || segment === "..")) {
+        throw new Error(invalidPathMessage(field, "must stay within the recipe root"));
+    }
+    return trimmed;
+}

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

@@ -7,6 +7,15 @@ export declare function resolveInstalledRecipeDir(entry: {
     id: string;
     version: string;
 }): string;
+export declare function resolveProjectRecipesDir(resolved: {
+    agentplaneDir: string;
+}): string;
+export declare function resolveProjectInstalledRecipeDir(resolved: {
+    agentplaneDir: string;
+}, recipeId: string): string;
+export declare function resolveProjectRecipeInstallMetaPath(resolved: {
+    agentplaneDir: string;
+}, recipeId: string): string;
 export declare function resolveProjectRecipesCacheDir(resolved: {
     agentplaneDir: string;
 }): string;

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

@@ -1 +1 @@
-{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../../src/commands/recipes/impl/paths.ts"],"names":[],"mappings":"AAYA,wBAAgB,qBAAqB,IAAI,MAAM,CAI9C;AAED,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD;AAED,wBAAgB,2BAA2B,IAAI,MAAM,CAEpD;AAED,wBAAgB,4BAA4B,IAAI,MAAM,CAErD;AAED,wBAAgB,+BAA+B,IAAI,MAAM,CAExD;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAExF;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAEzF"}
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../../src/commands/recipes/impl/paths.ts"],"names":[],"mappings":"AAcA,wBAAgB,qBAAqB,IAAI,MAAM,CAI9C;AAED,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD;AAED,wBAAgB,2BAA2B,IAAI,MAAM,CAEpD;AAED,wBAAgB,4BAA4B,IAAI,MAAM,CAErD;AAED,wBAAgB,+BAA+B,IAAI,MAAM,CAExD;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAExF;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAEpF;AAED,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,EACnC,QAAQ,EAAE,MAAM,GACf,MAAM,CAER;AAED,wBAAgB,mCAAmC,CACjD,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,EACnC,QAAQ,EAAE,MAAM,GACf,MAAM,CAER;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAEzF"}

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

@@ -1,6 +1,6 @@
 import os from "node:os";
 import path from "node:path";
-import { AGENTPLANE_HOME_ENV, GLOBAL_RECIPES_DIR_NAME, INSTALLED_RECIPES_NAME, PROJECT_RECIPES_CACHE_DIR_NAME, RECIPES_REMOTE_INDEX_NAME, RECIPES_REMOTE_INDEX_SIG_NAME, } from "./constants.js";
+import { AGENTPLANE_HOME_ENV, GLOBAL_RECIPES_DIR_NAME, INSTALLED_RECIPES_NAME, RECIPE_INSTALL_META_NAME, PROJECT_RECIPES_CACHE_DIR_NAME, RECIPES_DIR_NAME, RECIPES_REMOTE_INDEX_NAME, RECIPES_REMOTE_INDEX_SIG_NAME, } from "./constants.js";
 export function resolveAgentplaneHome() {
     const overridden = process.env[AGENTPLANE_HOME_ENV]?.trim();
     if (overridden)
@@ -22,6 +22,15 @@ export function resolveRecipesIndexCacheSigPath() {
 export function resolveInstalledRecipeDir(entry) {
     return path.join(resolveGlobalRecipesDir(), entry.id, entry.version);
 }
+export function resolveProjectRecipesDir(resolved) {
+    return path.join(resolved.agentplaneDir, RECIPES_DIR_NAME);
+}
+export function resolveProjectInstalledRecipeDir(resolved, recipeId) {
+    return path.join(resolveProjectRecipesDir(resolved), recipeId);
+}
+export function resolveProjectRecipeInstallMetaPath(resolved, recipeId) {
+    return path.join(resolveProjectInstalledRecipeDir(resolved, recipeId), RECIPE_INSTALL_META_NAME);
+}
 export function resolveProjectRecipesCacheDir(resolved) {
     return path.join(resolved.agentplaneDir, PROJECT_RECIPES_CACHE_DIR_NAME);
 }

package/dist/commands/recipes/impl/project-installed-recipes.d.ts

@@ -0,0 +1,7 @@
+import type { InstalledRecipesFile, RecipeInstallMetadata } from "./types.js";
+export declare function readRecipeInstallMetadata(filePath: string): Promise<RecipeInstallMetadata | null>;
+export declare function writeRecipeInstallMetadata(filePath: string, metadata: RecipeInstallMetadata): Promise<void>;
+export declare function readProjectInstalledRecipes(opts: {
+    agentplaneDir: string;
+}): Promise<InstalledRecipesFile>;
+//# sourceMappingURL=project-installed-recipes.d.ts.map

package/dist/commands/recipes/impl/project-installed-recipes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-installed-recipes.d.ts","sourceRoot":"","sources":["../../../../src/commands/recipes/impl/project-installed-recipes.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAwB,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAuCpG,wBAAsB,yBAAyB,CAC7C,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,CASvC;AAED,wBAAsB,0BAA0B,CAC9C,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,qBAAqB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAGf;AAED,wBAAsB,2BAA2B,CAAC,IAAI,EAAE;IACtD,aAAa,EAAE,MAAM,CAAC;CACvB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA0DhC"}

package/dist/commands/recipes/impl/project-installed-recipes.js

@@ -0,0 +1,102 @@
+import { mkdir, readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileExists, getPathKind } from "../../../cli/fs-utils.js";
+import { invalidFieldMessage, missingFileMessage } from "../../../cli/output.js";
+import { isRecord } from "../../../shared/guards.js";
+import { writeJsonStableIfChanged } from "../../../shared/write-if-changed.js";
+import { readRecipeManifest } from "./manifest.js";
+import { normalizeRecipeTags } from "./normalize.js";
+import { resolveProjectInstalledRecipeDir, resolveProjectRecipeInstallMetaPath, resolveProjectRecipesDir, } from "./paths.js";
+function validateRecipeInstallMetadata(raw) {
+    if (!isRecord(raw))
+        throw new Error(invalidFieldMessage("recipe install metadata", "object"));
+    const id = typeof raw.id === "string" ? raw.id.trim() : "";
+    const version = typeof raw.version === "string" ? raw.version.trim() : "";
+    const source = typeof raw.source === "string" ? raw.source.trim() : "";
+    const installedAt = typeof raw.installed_at === "string" ? raw.installed_at.trim() : "";
+    const installMode = raw.install_mode === undefined || raw.install_mode === "project-local"
+        ? raw.install_mode
+        : null;
+    if (raw.schema_version !== 1) {
+        throw new Error(invalidFieldMessage("recipe install metadata.schema_version", "1"));
+    }
+    if (!id || !version || !source || !installedAt) {
+        throw new Error(invalidFieldMessage("recipe install metadata", "id, version, source, installed_at"));
+    }
+    if (installMode === null) {
+        throw new Error(invalidFieldMessage("recipe install metadata.install_mode", '"project-local"'));
+    }
+    const tags = normalizeRecipeTags(raw.tags ?? []);
+    return {
+        schema_version: 1,
+        id,
+        version,
+        source,
+        installed_at: installedAt,
+        tags,
+        install_mode: installMode,
+    };
+}
+function sortInstalledRecipes(entries) {
+    return [...entries].toSorted((a, b) => a.id.localeCompare(b.id));
+}
+export async function readRecipeInstallMetadata(filePath) {
+    try {
+        const raw = JSON.parse(await readFile(filePath, "utf8"));
+        return validateRecipeInstallMetadata(raw);
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+export async function writeRecipeInstallMetadata(filePath, metadata) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeJsonStableIfChanged(filePath, metadata);
+}
+export async function readProjectInstalledRecipes(opts) {
+    const recipesDir = resolveProjectRecipesDir(opts);
+    if ((await getPathKind(recipesDir)) !== "dir") {
+        return { schema_version: 1, updated_at: "", recipes: [] };
+    }
+    const entries = [];
+    const dirs = await readdir(recipesDir, { withFileTypes: true });
+    for (const dirent of dirs) {
+        if (!dirent.isDirectory())
+            continue;
+        const recipeDir = resolveProjectInstalledRecipeDir(opts, dirent.name);
+        const manifestPath = path.join(recipeDir, "manifest.json");
+        if (!(await fileExists(manifestPath))) {
+            throw new Error(missingFileMessage("installed recipe manifest", manifestPath));
+        }
+        const manifest = await readRecipeManifest(manifestPath);
+        if (manifest.id !== dirent.name) {
+            throw new Error(invalidFieldMessage(`installed recipe directory ${dirent.name}`, `manifest.id=${dirent.name}`));
+        }
+        const metadata = await readRecipeInstallMetadata(resolveProjectRecipeInstallMetaPath(opts, dirent.name));
+        if (metadata && (metadata.id !== manifest.id || metadata.version !== manifest.version)) {
+            throw new Error(invalidFieldMessage(`recipe install metadata ${dirent.name}`, "id/version matching manifest"));
+        }
+        entries.push({
+            id: manifest.id,
+            version: manifest.version,
+            source: metadata?.source ?? "project-local",
+            installed_at: metadata?.installed_at ?? "",
+            tags: normalizeRecipeTags(metadata?.tags ?? manifest.tags ?? []),
+            manifest,
+        });
+    }
+    const sorted = sortInstalledRecipes(entries);
+    const updatedAt = sorted
+        .map((entry) => entry.installed_at)
+        .filter(Boolean)
+        .toSorted()
+        .at(-1);
+    return {
+        schema_version: 1,
+        updated_at: updatedAt ?? "",
+        recipes: sorted,
+    };
+}

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

@@ -0,0 +1,20 @@
+import type { ResolvedProject } from "@agentplaneorg/core";
+import type { RecipeCompatibility, RecipeResolverCompatibility, RecipeResolverContext, RecipeScenarioDescriptor, ResolveRecipeScenarioSelectionFlags, ResolvedRecipeRunProfile, ResolvedRecipeScenario, ResolvedRecipeScenarioSelection } from "./types.js";
+export declare function buildRecipeResolverContext(opts: {
+    project: ResolvedProject;
+}): Promise<RecipeResolverContext>;
+export declare function resolveRecipeCompatibility(opts: {
+    compatibility?: RecipeCompatibility;
+    context: RecipeResolverContext;
+}): RecipeResolverCompatibility;
+export declare function normalizeResolvedRecipeRunProfile(scenario: RecipeScenarioDescriptor): ResolvedRecipeRunProfile;
+export declare function listResolvedRecipeScenarios(opts: {
+    project: ResolvedProject;
+    recipeId?: string;
+    includeIncompatible?: boolean;
+}): Promise<ResolvedRecipeScenario[]>;
+export declare function resolveRecipeScenarioSelection(opts: {
+    project: ResolvedProject;
+    flags: ResolveRecipeScenarioSelectionFlags;
+}): Promise<ResolvedRecipeScenarioSelection>;
+//# sourceMappingURL=resolver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../../../src/commands/recipes/impl/resolver.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAS3D,OAAO,KAAK,EAEV,mBAAmB,EACnB,2BAA2B,EAE3B,qBAAqB,EAErB,wBAAwB,EACxB,mCAAmC,EACnC,wBAAwB,EACxB,sBAAsB,EACtB,+BAA+B,EAChC,MAAM,YAAY,CAAC;AAsBpB,wBAAsB,0BAA0B,CAAC,IAAI,EAAE;IACrD,OAAO,EAAE,eAAe,CAAC;CAC1B,GAAG,OAAO,CAAC,qBAAqB,CAAC,CASjC;AAYD,wBAAgB,0BAA0B,CAAC,IAAI,EAAE;IAC/C,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC,OAAO,EAAE,qBAAqB,CAAC;CAChC,GAAG,2BAA2B,CAkG9B;AAED,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,wBAAwB,GACjC,wBAAwB,CAmB1B;AA6BD,wBAAsB,2BAA2B,CAAC,IAAI,EAAE;IACtD,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,GAAG,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAsBpC;AAED,wBAAsB,8BAA8B,CAAC,IAAI,EAAE;IACzD,OAAO,EAAE,eAAe,CAAC;IACzB,KAAK,EAAE,mCAAmC,CAAC;CAC5C,GAAG,OAAO,CAAC,+BAA+B,CAAC,CA2D3C"}