@acidicsoil/portable-capabilities 0.1.9 → 0.1.10

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.1.10
+
+### Patch Changes
+
+- [#75](https://github.com/AcidicSoil/portable-capabilities/pull/75) [`169d407`](https://github.com/AcidicSoil/portable-capabilities/commit/169d407d8b7e544db6f9b71f1521bac87df0d459) Thanks [@AcidicSoil](https://github.com/AcidicSoil)! - ● @acidicsoil/portable-capabilities@0.1.9
+
 ## 0.1.9
 
 ### Patch Changes

package/README.md

@@ -122,6 +122,7 @@ CONSUMER=/tmp/portable-capabilities-consumer
 mkdir -p "$CONSUMER"
 pnpm cli -- install \
   --runtime codex \
+  --runtime-version 0.147.0 \
   --capability convention-mining \
   --project "$CONSUMER" \
   --approval-policy preapproved

package/dist-release/cli.js

@@ -11733,7 +11733,7 @@ function writeEnvelope(envelope, format2) {
 }
 
 // packages/cli/src/release.ts
-var cliVersion = true ? "0.1.9" : createRequire(import.meta.url)("../../../package.json").version;
+var cliVersion = true ? "0.1.10" : createRequire(import.meta.url)("../../../package.json").version;
 
 // packages/adapters/src/antigravity/materialize.ts
 import { resolve as resolve2 } from "node:path";
@@ -13073,6 +13073,7 @@ var codexRuntimeEvidence = Object.freeze([
 ]);
 
 // packages/adapters/src/dcode/materialize.ts
+import { readFile as readFile3 } from "node:fs/promises";
 import { resolve as resolve5 } from "node:path";
 var marker4 = "<!-- portable-capabilities:owned dcode -->";
 function destination4(value) {
@@ -13118,7 +13119,32 @@ function registration3(operation) {
   return `${JSON.stringify({ adapterId: operation.adapterId, kind: operation.kind, target: operation.target }, null, 2)}
 `;
 }
-function prepareDCodeMaterialization(plan, root) {
+async function mergedInstructions(root, path9, operations, removedIds) {
+  let existing;
+  try {
+    existing = await readFile3(resolve5(root, path9), "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (!existing && operations.length === 0) return void 0;
+  const selectedIds = new Set(operations.map((operation) => operation.id));
+  const existingText = existing ?? "";
+  const firstHeading = existingText.search(/^## .+$/mu);
+  const preamble = firstHeading >= 0 ? existingText.slice(0, firstHeading).trim() : existingText.trim();
+  const sections = firstHeading >= 0 ? existingText.slice(firstHeading).split(/(?=^## .+$)/mu) : [];
+  const retained = sections.filter((section) => {
+    const id = section.match(/^## ([^\n]+)/u)?.[1] ?? "";
+    return !selectedIds.has(id) && !removedIds.some((removedId) => id.startsWith(`${removedId}:`));
+  }).map((section) => section.trim());
+  const generated = operations.slice().sort((left, right) => left.id.localeCompare(right.id)).map((operation) => `## ${operation.id}
+
+${operation.content.trim()}`);
+  const sectionsToWrite = [...retained, ...generated];
+  return sectionsToWrite.length > 0 ? `${preamble || marker4}
+${sectionsToWrite.join("\n\n")}
+` : void 0;
+}
+async function prepareDCodeMaterialization(plan, root) {
   if (plan.runtimeId !== "dcode") throw new Error(`DCode adapter cannot prepare ${plan.runtimeId}`);
   const mutations = [];
   const diagnostics = [];
@@ -13220,28 +13246,39 @@ function prepareDCodeMaterialization(plan, root) {
         );
     }
   }
-  if (instructionOperations.length > 0) {
+  const instructionRemovals = plan.operations.filter(
+    (operation) => operation.kind === "RemoveOwnedArtifact" && /^\.deepagents\/skills\/[^/]+\/SKILL\.md$/u.test(destination4(operation.detail))
+  );
+  if (instructionOperations.length > 0 || instructionRemovals.length > 0) {
     const instructionPath = ".deepagents/AGENTS.md";
     confined4(root, instructionPath);
-    const content = instructionOperations.sort((left, right) => left.id.localeCompare(right.id)).map((operation) => `## ${operation.id}
-
-${operation.content.trim()}`).join("\n\n");
-    const first = instructionOperations[0];
-    mutations.push({
-      path: instructionPath,
-      kind: "write",
-      content: `<!-- portable-capabilities:owned dcode -->
-${content}
-`,
-      mode: 420,
-      operationId: "dcode:shared-instructions",
-      sourceProjectionOperationId: first.sourceProjectionOperationId,
-      ownershipIntent: first.ownershipIntent,
-      approval: first.approval,
-      rollback: first.rollback,
-      upgrade: first.upgrade,
-      uninstall: first.uninstall
+    const first = instructionOperations[0] ?? instructionRemovals[0];
+    if (!first) throw new Error("DCode shared instruction operation is missing");
+    const removedIds = instructionRemovals.flatMap((operation) => {
+      const match = operation.detail.match(/^\.deepagents\/skills\/([^/]+)\/SKILL\.md$/u);
+      return match?.[1] ? [match[1]] : [];
     });
+    const content = await mergedInstructions(
+      root,
+      instructionPath,
+      instructionOperations,
+      removedIds
+    );
+    mutations.push(
+      content ? {
+        path: instructionPath,
+        kind: "write",
+        content,
+        mode: 420,
+        operationId: "dcode:shared-instructions",
+        sourceProjectionOperationId: first.sourceProjectionOperationId,
+        ownershipIntent: first.ownershipIntent,
+        approval: first.approval,
+        rollback: first.rollback,
+        upgrade: first.upgrade,
+        uninstall: first.uninstall
+      } : { path: instructionPath, kind: "remove", ...metadata3(first) }
+    );
   }
   return Object.freeze({
     runtimeId: plan.runtimeId,
@@ -15253,19 +15290,19 @@ function normalizeSetupRequest(input) {
 // packages/cli/src/setup/service.ts
 import { createHash as createHash16 } from "node:crypto";
 import { existsSync as existsSync2 } from "node:fs";
-import { readdir as readdir3, readFile as readFile5 } from "node:fs/promises";
+import { readdir as readdir3, readFile as readFile6 } from "node:fs/promises";
 import { dirname as dirname4, isAbsolute as isAbsolute3, relative as relative3, resolve as resolve11 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { parse as parse3 } from "yaml";
 
 // packages/cli/src/installation/lifecycle.ts
 import { createHash as createHash15 } from "node:crypto";
-import { chmod, copyFile, lstat as lstat2, mkdir as mkdir3, readFile as readFile4, rename as rename2, rm, writeFile as writeFile3 } from "node:fs/promises";
+import { chmod, copyFile, lstat as lstat2, mkdir as mkdir3, readFile as readFile5, rename as rename2, rm, writeFile as writeFile3 } from "node:fs/promises";
 import { dirname as dirname3, isAbsolute as isAbsolute2, join as join3, relative as relative2, resolve as resolve10, sep } from "node:path";
 
 // packages/cli/src/installation/manifest.ts
 import { createHash as createHash14 } from "node:crypto";
-import { mkdir as mkdir2, readFile as readFile3, rename, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile4, rename, stat, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname2, join as join2 } from "node:path";
 var installationManifestName = ".portable-capabilities-manifest.json";
 var installationJournalName = ".portable-capabilities-journal.json";
@@ -15319,7 +15356,7 @@ function verifyInstallationManifestDigest(manifest) {
   }
 }
 async function digestFile(path9) {
-  return digestBytes(await readFile3(path9));
+  return digestBytes(await readFile4(path9));
 }
 function manifestPath(targetRoot) {
   return join2(targetRoot, installationManifestName);
@@ -15330,7 +15367,7 @@ function journalPath(targetRoot) {
 async function readInstallationManifest(targetRoot) {
   try {
     const parsed = JSON.parse(
-      await readFile3(manifestPath(targetRoot), "utf8")
+      await readFile4(manifestPath(targetRoot), "utf8")
     );
     if (parsed.schemaVersion !== "1.1.0" || !Array.isArray(parsed.entries)) {
       throw new Error("Invalid installation manifest shape");
@@ -15607,6 +15644,19 @@ async function assertPlanPathsSafe(targetRoot, plan) {
 }
 async function executePreparedInstallation(options) {
   const manifest = await readInstallationManifest(options.targetRoot);
+  const operation = options.preparedOperation ?? "install";
+  if (options.preparedDiagnostics?.length) {
+    return result(operation, "degraded", {
+      ok: false,
+      diagnostics: options.preparedDiagnostics
+    });
+  }
+  if (options.preparedMutations.length === 0) {
+    return result(operation, "degraded", {
+      ok: false,
+      diagnostics: ["No prepared mutations can be installed"]
+    });
+  }
   const duplicatePaths = /* @__PURE__ */ new Set();
   for (const mutation of options.preparedMutations) {
     if (duplicatePaths.has(mutation.path)) {
@@ -15635,7 +15685,7 @@ async function executePreparedInstallation(options) {
     const exists = await pathExists(target);
     if (mutation.ownershipIntent === "preserve-user" && exists) continue;
     if (exists && mutation.kind === "write" && mutation.ownershipIntent === "own") {
-      const current = await readFile4(target, "utf8");
+      const current = await readFile5(target, "utf8");
       const ownedEntry = manifest?.entries.find((entry) => entry.path === mutation.path);
       const isManifestOwned = ownedEntry !== void 0 && await digestFile(target) === ownedEntry.digest;
       if (!current.includes("portable-capabilities:owned") && !isManifestOwned)
@@ -15681,7 +15731,6 @@ async function executePreparedInstallation(options) {
     packageIdentities,
     entries: nextEntries
   };
-  const operation = options.preparedOperation ?? "install";
   if (options.dryRun)
     return result(operation, manifest ? "healthy" : "missing", {
       dryRun: true,
@@ -15716,63 +15765,6 @@ async function statusInstallation(targetRoot) {
     manifest
   });
 }
-async function removeInstallation(targetRoot, faultInjector, capabilityIds) {
-  const manifest = await readInstallationManifest(targetRoot);
-  if (!manifest) return result("remove", "missing", { ok: false });
-  const selected = new Set(capabilityIds ?? []);
-  const scoped = (path9) => {
-    if (selected.size === 0) return true;
-    const normalized = path9.replaceAll("\\", "/");
-    return [...selected].some(
-      (id) => normalized.includes(`/skills/${id}/`) || normalized.endsWith(`/skills/${id}`)
-    );
-  };
-  const classifications = await classifyManifestEntries(manifest);
-  const unchanged = new Set(
-    classifications.unchanged.filter((entry) => scoped(entry.path)).map((entry) => entry.path)
-  );
-  const removes = manifest.entries.filter((entry) => unchanged.has(entry.path)).map((entry) => entry.path);
-  const preserved = manifest.entries.filter((entry) => !unchanged.has(entry.path));
-  const nextManifest = preserved.length ? (() => {
-    const entries = Object.freeze(preserved);
-    const preservedPaths = new Set(entries.map((entry) => entry.path));
-    const packageIdentities = Object.freeze(
-      manifest.packageIdentities.filter((identity3) => preservedPaths.has(identity3.lockPath))
-    );
-    const packageDigest = packageEntriesDigest(entries, packageIdentities);
-    const base = {
-      runtimeId: manifest.runtimeId,
-      packageVersion: manifest.packageVersion,
-      targetRoot: manifest.targetRoot,
-      journalVersion: manifest.journalVersion,
-      lifecycleState: "modified",
-      packageIdentities,
-      entries
-    };
-    return {
-      ...manifest,
-      ...base,
-      packageDigest,
-      installationDigest: installationOwnershipDigest(packageDigest, base)
-    };
-  })() : void 0;
-  return commitPlan(
-    "remove",
-    {
-      sourceRoot: targetRoot,
-      targetRoot,
-      runtimeId: manifest.runtimeId,
-      packageVersion: manifest.packageVersion,
-      ...faultInjector ? { faultInjector } : {}
-    },
-    {
-      writes: [],
-      removes,
-      preserved: preserved.map((entry) => entry.path),
-      ...nextManifest ? { nextManifest } : {}
-    }
-  );
-}
 
 // packages/cli/src/setup/service.ts
 function roleFacet(role, name) {
@@ -15833,7 +15825,7 @@ async function loadCanonicalArtifact(catalogRoot, capabilityId) {
   if (!capabilityId || /[\\/]/u.test(capabilityId))
     throw new Error("capability IDs must be single path segments");
   const file = resolve11(catalogRoot, "roles", `${capabilityId}.yaml`);
-  const role = parse3(await readFile5(file, "utf8"));
+  const role = parse3(await readFile6(file, "utf8"));
   if (role.schemaVersion !== "1.0" || role.id !== capabilityId || !role.purpose || !Array.isArray(role.inputs) || !role.output || !role.family || !role.taxonomy || !Array.isArray(role.precedence) || !Array.isArray(role.requiredBehavior) || !Array.isArray(role.forbiddenBehavior) || !Array.isArray(role.evaluation?.criteria)) {
     throw new Error(`Invalid canonical capability: ${file}`);
   }
@@ -15842,7 +15834,7 @@ async function loadCanonicalArtifact(catalogRoot, capabilityId) {
   const schemaRelativePath = relative3(resolve11(catalogRoot), schemaFile);
   if (isAbsolute3(schemaRelativePath) || schemaRelativePath.startsWith(".."))
     throw new Error(`Canonical output schema escapes catalog: ${role.output.schema}`);
-  const schemaContent = await readFile5(schemaFile, "utf8");
+  const schemaContent = await readFile6(schemaFile, "utf8");
   const contract = operationalContract(role);
   const contractContent = `${JSON.stringify(
     { ...role, output: { ...role.output, schema: "resources/output.schema.json" } },
@@ -15915,6 +15907,27 @@ function previewSetup(request, artifact, descriptor, claims, ownershipManifest)
   const body = { ...plan, selectedSurfaces, conversions, conflicts };
   return { ...body, digest: stableDigest(body) };
 }
+function composeInstallationPlan(previews, artifacts, runtimeId) {
+  const first = previews[0]?.installationPlan;
+  if (!first) throw new Error("at least one installation plan is required");
+  const operations = previews.flatMap((preview, index) => {
+    const capabilityId = artifacts[index]?.id;
+    if (!capabilityId) throw new Error("installation plan is missing its capability");
+    return preview.installationPlan.operations.map((operation) => ({
+      ...operation,
+      id: `${capabilityId}:${operation.id}`,
+      sourceProjectionOperationId: `${capabilityId}:${operation.sourceProjectionOperationId}`
+    }));
+  });
+  const base = {
+    schemaVersion: first.schemaVersion,
+    id: `installation:${runtimeId}:${artifacts.map((artifact) => artifact.id).join(",")}`,
+    runtimeId,
+    scope: first.scope,
+    operations
+  };
+  return { ...base, digest: stableDigest(base) };
+}
 function defaultCatalogRoot() {
   const moduleDir = dirname4(fileURLToPath4(import.meta.url));
   const packagedCatalog = [resolve11(moduleDir, "catalog"), resolve11(moduleDir, "../catalog")].find(
@@ -15973,23 +15986,33 @@ async function executeSetupSelection(request, artifacts, descriptor, claims, con
     ...context.faultInjector ? { faultInjector: context.faultInjector } : {}
   };
   const runtime = resolveProductionRuntime(executionRequest.runtimeId);
-  const lifecycle = executionRequest.intent === "setup" || executionRequest.intent === "update" ? await executePreparedInstallation({
-    ...lifecycleOptions,
-    preparedOperation: executionRequest.intent === "update" ? "upgrade" : "install",
-    preparedMutations: (await Promise.all(
-      previews.map((preview) => runtime.prepare(preview.installationPlan, targetRoot))
-    )).flatMap((prepared) => prepared.mutations)
-  }) : executionRequest.intent === "remove" ? await removeInstallation(
-    targetRoot,
-    context.faultInjector,
-    executionRequest.capabilityIds
-  ) : await statusInstallation(targetRoot);
+  const lifecycle = executionRequest.intent === "setup" || executionRequest.intent === "update" || executionRequest.intent === "remove" ? await (async () => {
+    const installationPlan = composeInstallationPlan(
+      previews,
+      planningArtifacts,
+      executionRequest.runtimeId
+    );
+    const prepared = await runtime.prepare(installationPlan, targetRoot);
+    if (prepared.runtimeId !== installationPlan.runtimeId || prepared.planId !== installationPlan.id) {
+      throw new Error(`Materializer returned an invalid ${executionRequest.runtimeId} plan`);
+    }
+    const duplicatePath = prepared.mutations.map((mutation) => mutation.path).find((path9, index, paths) => paths.indexOf(path9) !== index);
+    if (duplicatePath)
+      throw new Error(`Selection produced duplicate prepared path: ${duplicatePath}`);
+    return executePreparedInstallation({
+      ...lifecycleOptions,
+      preparedOperation: executionRequest.intent === "update" ? "upgrade" : executionRequest.intent === "remove" ? "remove" : "install",
+      preparedMutations: prepared.mutations,
+      ...prepared.diagnostics ? {
+        preparedDiagnostics: prepared.diagnostics.map(
+          (diagnostic6) => `${diagnostic6.kind}: ${diagnostic6.message}`
+        )
+      } : {}
+    });
+  })() : await statusInstallation(targetRoot);
   return { request, previews, lifecycle };
 }
 
-// packages/cli/src/wizard.ts
-import { execFileSync } from "node:child_process";
-
 // node_modules/.pnpm/@clack+core@1.4.3/node_modules/@clack/core/dist/index.mjs
 import { styleText } from "node:util";
 import { stdout, stdin } from "node:process";
@@ -17197,6 +17220,73 @@ ${r2}
   }
 }).prompt();
 
+// packages/cli/src/setup/probe.ts
+import { execFileSync } from "node:child_process";
+var executables = Object.freeze({
+  antigravity: "agy",
+  "claude-code": "claude",
+  codex: "codex",
+  dcode: "dcode",
+  "oh-my-pi": "omp",
+  opencode: "opencode",
+  pi: "pi"
+});
+function resolveRuntimeProbe(runtimeId) {
+  const runtime = resolveProductionRuntime(runtimeId);
+  const canonicalId = runtime.descriptor.id;
+  const executable = executables[canonicalId];
+  if (!executable) throw new Error(`No runtime probe configured for ${canonicalId}`);
+  return {
+    runtimeId: canonicalId,
+    executable,
+    args: ["--version"],
+    supportedVersions: runtime.descriptor.supportedVersions
+  };
+}
+function parseVersion2(output) {
+  return output.match(/\bv?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\b/u)?.[1];
+}
+function defaultRun(probe) {
+  return execFileSync(probe.executable, probe.args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 5e3
+  });
+}
+function probeRuntimeVersion(runtimeId, options = {}) {
+  const probe = resolveRuntimeProbe(runtimeId);
+  let output;
+  try {
+    output = (options.run ?? defaultRun)(probe);
+  } catch (error) {
+    const code = error.code;
+    const unavailable = code === "ENOENT" || code === "EACCES";
+    return {
+      status: unavailable ? "unavailable" : "failed",
+      runtimeId: probe.runtimeId,
+      executable: probe.executable,
+      reason: unavailable ? `${probe.executable} is not installed or is not executable` : error instanceof Error ? error.message : String(error)
+    };
+  }
+  const version = parseVersion2(output);
+  if (!version)
+    return {
+      status: "unknown-version",
+      runtimeId: probe.runtimeId,
+      executable: probe.executable,
+      reason: "version probe returned no parseable semantic version"
+    };
+  if (!probe.supportedVersions.some((range) => isRuntimeVersionInRange(range, version)))
+    return {
+      status: "unsupported-version",
+      runtimeId: probe.runtimeId,
+      executable: probe.executable,
+      version,
+      reason: `version ${version} is outside the supported runtime ranges`
+    };
+  return { status: "detected", runtimeId: probe.runtimeId, executable: probe.executable, version };
+}
+
 // packages/cli/src/wizard.ts
 var supportedRuntimes = [...productionRuntimeRegistry.keys()];
 function unwrap(value) {
@@ -17207,17 +17297,6 @@ function unwrap(value) {
   }
   return value;
 }
-function detectRuntimeVersion(runtime) {
-  try {
-    const output = execFileSync(runtime, ["--version"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    return output.match(/\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?/)?.[0] ?? "unknown";
-  } catch {
-    return "unknown";
-  }
-}
 async function runInstallWizard() {
   intro("Portable Capabilities setup");
   try {
@@ -17237,6 +17316,12 @@ async function runInstallWizard() {
         options: supportedRuntimes.map((value) => ({ value, label: value }))
       })
     );
+    const probe = probeRuntimeVersion(runtime);
+    if (probe.status !== "detected" || !probe.version) {
+      log.error(`${runtime}: ${probe.reason ?? probe.status}`);
+      process.exitCode = 4;
+      return;
+    }
     const target = String(
       unwrap(
         await text({
@@ -17254,7 +17339,7 @@ async function runInstallWizard() {
     );
     const request = normalizeSetupRequest({
       runtimeId: runtime,
-      runtimeVersion: detectRuntimeVersion(runtime),
+      runtimeVersion: probe.version,
       scope: "project",
       projectDirectory: target,
       capabilityIds,
@@ -17276,7 +17361,7 @@ async function runInstallWizard() {
       runtimeEntry.claims,
       { sourceRoot: process.cwd(), packageVersion: cliVersion }
     );
-    if (!result2.lifecycle || !result2.lifecycle.ok) {
+    if (!result2.lifecycle?.ok) {
       for (const diagnostic6 of result2.lifecycle?.diagnostics ?? ["Approval required."])
         log.error(diagnostic6);
       process.exitCode = 4;