@vibe-engineer/adapter-pi 0.1.0

package/dist/capabilities/index.d.ts

@@ -0,0 +1,12 @@
+import { AdapterCapabilityMatrix, AdapterCapability, ValidationResult } from '../schema/index.js';
+
+declare const PI_ADAPTER_ID: "pi";
+declare const PI_ADAPTER_CAPABILITY_SCHEMA_VERSION: "pi-adapter-capability-matrix/v1";
+declare const VIBE_ENGINEER_SKILLS: ("brainstorm" | "grill-me" | "task" | "plan" | "build" | "ship")[];
+declare const PI_ADAPTER_CAPABILITY_MATRIX: AdapterCapabilityMatrix;
+declare const getPiAdapterCapabilityMatrix: () => AdapterCapabilityMatrix;
+declare const validatePiAdapterCapabilityMatrix: (value: unknown) => ValidationResult<AdapterCapabilityMatrix>;
+declare const getAdapterCapabilityById: (matrix: AdapterCapabilityMatrix, adapterId: string) => AdapterCapability | undefined;
+declare const isAdapterManifestSelectable: (matrix: AdapterCapabilityMatrix, adapterId: string) => boolean;
+
+export { PI_ADAPTER_CAPABILITY_MATRIX, PI_ADAPTER_CAPABILITY_SCHEMA_VERSION, PI_ADAPTER_ID, VIBE_ENGINEER_SKILLS, getAdapterCapabilityById, getPiAdapterCapabilityMatrix, isAdapterManifestSelectable, validatePiAdapterCapabilityMatrix };

package/dist/capabilities/index.js

@@ -0,0 +1,21 @@
+import {
+  PI_ADAPTER_CAPABILITY_MATRIX,
+  PI_ADAPTER_CAPABILITY_SCHEMA_VERSION,
+  PI_ADAPTER_ID,
+  VIBE_ENGINEER_SKILLS,
+  getAdapterCapabilityById,
+  getPiAdapterCapabilityMatrix,
+  isAdapterManifestSelectable,
+  validatePiAdapterCapabilityMatrix
+} from "../chunk-RC3EILIE.js";
+import "../chunk-VXZJPOEE.js";
+export {
+  PI_ADAPTER_CAPABILITY_MATRIX,
+  PI_ADAPTER_CAPABILITY_SCHEMA_VERSION,
+  PI_ADAPTER_ID,
+  VIBE_ENGINEER_SKILLS,
+  getAdapterCapabilityById,
+  getPiAdapterCapabilityMatrix,
+  isAdapterManifestSelectable,
+  validatePiAdapterCapabilityMatrix
+};

package/dist/chunk-PJHJYGIJ.js

@@ -0,0 +1,392 @@
+import {
+  getPiAdapterCapabilityMatrix
+} from "./chunk-RC3EILIE.js";
+import {
+  SKILL_IDS,
+  createDownstreamManifestSummary,
+  validateCapabilityMatrix,
+  validateGeneratedFileManifest
+} from "./chunk-VXZJPOEE.js";
+
+// src/generated-file-manifest/index.ts
+var PI_GENERATED_FILE_MANIFEST_SCHEMA_VERSION = "pi-generated-file-manifest/v1";
+var version = (formatName, formatVersion) => ({
+  formatName,
+  formatVersion,
+  schemaVersion: PI_GENERATED_FILE_MANIFEST_SCHEMA_VERSION,
+  adapterCapabilityVersion: "pi-adapter-capability-matrix/v1"
+});
+var trustSecurity = (overrides) => ({
+  ...overrides,
+  evidence: {
+    state: "known",
+    source: "DL-06-agentic-harness-integrations.md + DL-22-security-safety-model.md",
+    notes: "Generated-file family carries explicit trust, sandbox, credential, command, external-integration, and destructive-operation semantics."
+  }
+});
+var family = (familyId, description, pathPatterns, producedByLane, consumedByLanes, security, fileVersion, readinessState, reason) => ({
+  familyId,
+  description,
+  pathPatterns,
+  owner: {
+    ownerKind: "lane",
+    ownerId: producedByLane,
+    writePathScope: pathPatterns,
+    allowedOperations: ["generate-in-later-lane", "validate"]
+  },
+  producedByLane,
+  consumedByLanes,
+  trustSecurity: security,
+  version: fileVersion,
+  readiness: {
+    state: readinessState,
+    reason
+  }
+});
+var projectInstructionSecurity = trustSecurity({
+  classification: "project-instruction",
+  trustBoundary: "Project-local instructions are loaded by pi after project trust; content must remain domain-neutral and cannot embed secrets.",
+  projectTrustRequired: true,
+  executesCode: false,
+  commandPolicy: "not-applicable",
+  sandboxCapability: "not_provided",
+  credentialPolicy: "no-credentials-required",
+  externalIntegration: "disabled-by-default",
+  destructiveOperationPolicy: "forbidden"
+});
+var PI_GENERATED_FILE_MANIFEST = {
+  schemaVersion: PI_GENERATED_FILE_MANIFEST_SCHEMA_VERSION,
+  adapterId: "pi",
+  adapterCapabilityVersion: "pi-adapter-capability-matrix/v1",
+  producedByLane: "I-14A-pi-adapter-capability-generated-file-manifest",
+  families: [
+    family(
+      "pi-skill-files",
+      "Agent Skills-compatible files for the six locked vibe-engineer skills.",
+      [".pi/skills/<skill>/SKILL.md", ".agents/skills/<skill>/SKILL.md"],
+      "I-14B-pi-adapter-runtime-skill-consumption",
+      ["I-14B-pi-adapter-runtime-skill-consumption", "I-15A-create-import-cli-ux-selected-harness", "I-21-build-skill-orchestration"],
+      projectInstructionSecurity,
+      version("Agent Skills SKILL.md", "v1"),
+      "ready",
+      "Manifest family is declared and validated by I-14A; actual file generation/runtime proof belongs to I-14B/I-15A."
+    ),
+    family(
+      "pi-prompt-templates",
+      "Reusable pi slash-command prompt templates for generated skill workflows.",
+      [".pi/prompts/<name>.md"],
+      "I-14B-pi-adapter-runtime-skill-consumption",
+      ["I-14B-pi-adapter-runtime-skill-consumption", "I-15A-create-import-cli-ux-selected-harness"],
+      projectInstructionSecurity,
+      version("Pi prompt template markdown", "v1"),
+      "ready",
+      "Templates are an allowed family only when downstream lanes validate manifest metadata and avoid silent unsupported behavior."
+    ),
+    family(
+      "pi-extensions",
+      "Optional TypeScript extensions for commands, tools, hooks, permission/path gates, subagent or plan-mode-like behavior, and dynamic resources.",
+      [".pi/extensions/<name>.ts", ".pi/extensions/<name>/index.ts"],
+      "I-14B-pi-adapter-runtime-skill-consumption",
+      ["I-14B-pi-adapter-runtime-skill-consumption", "I-18-security-safety-hooks-policy", "I-21-build-skill-orchestration"],
+      trustSecurity({
+        classification: "executable-extension",
+        trustBoundary: "TypeScript extension code executes with pi/package permissions after project trust; no sandbox isolation is claimed by I-14A.",
+        projectTrustRequired: true,
+        executesCode: true,
+        commandPolicy: "default-deny",
+        sandboxCapability: "not_provided",
+        credentialPolicy: "operator-supplied-only",
+        externalIntegration: "disabled-by-default",
+        destructiveOperationPolicy: "approval-required"
+      }),
+      version("Pi TypeScript extension", "v1"),
+      "blocked",
+      "Executable extension generation and live loading are intentionally blocked until I-14B/I-18 prove the actual runtime/security boundary."
+    ),
+    family(
+      "pi-package-manifest",
+      "Optional package.json `pi` key for shareable resources.",
+      ["package.json#pi"],
+      "I-14B-pi-adapter-runtime-skill-consumption",
+      ["I-14B-pi-adapter-runtime-skill-consumption", "I-15B-starter-template-harness-consumption"],
+      trustSecurity({
+        classification: "package-manifest",
+        trustBoundary: "Pi package install/update/trust behavior must be explicit before a package manifest is generated or consumed.",
+        projectTrustRequired: true,
+        executesCode: true,
+        commandPolicy: "default-deny",
+        sandboxCapability: "not_provided",
+        credentialPolicy: "operator-supplied-only",
+        externalIntegration: "disabled-by-default",
+        destructiveOperationPolicy: "approval-required"
+      }),
+      version("Pi package manifest key", "v1"),
+      "deferred",
+      "Optional package distribution is declared for compatibility but not generated by I-14A."
+    ),
+    family(
+      "context-files",
+      "Project context/instruction files loaded by pi and optional cross-harness compatibility context.",
+      ["AGENTS.md", "CLAUDE.md"],
+      "I-15A-create-import-cli-ux-selected-harness",
+      ["I-15A-create-import-cli-ux-selected-harness", "I-08-context-graph-index-drift", "I-21-build-skill-orchestration"],
+      projectInstructionSecurity,
+      version("Pi context file", "v1"),
+      "ready",
+      "Context file family is ready as manifest data; actual starter/create writes belong to I-15A."
+    ),
+    family(
+      "harness-config",
+      "Generated harness config fields recording `agenticHarness: pi` and adapter capability/version metadata.",
+      ["generated harness config field: agenticHarness=pi", "generated harness config field: adapterCapabilityVersion", "generated harness config field: generatedFileManifestVersion"],
+      "I-15A-create-import-cli-ux-selected-harness",
+      ["I-15A-create-import-cli-ux-selected-harness", "I-15B-starter-template-harness-consumption", "I-21-build-skill-orchestration"],
+      trustSecurity({
+        classification: "configuration",
+        trustBoundary: "Configuration selects the typed pi adapter manifest only; it must not silently enable unsupported non-pi harnesses or runtime claims.",
+        projectTrustRequired: false,
+        executesCode: false,
+        commandPolicy: "not-applicable",
+        sandboxCapability: "not_provided",
+        credentialPolicy: "no-credentials-required",
+        externalIntegration: "disabled-by-default",
+        destructiveOperationPolicy: "forbidden"
+      }),
+      version("vibe-engineer harness adapter config", "v1"),
+      "ready",
+      "Config metadata is ready for downstream consumption after this manifest validates; create/import behavior remains I-15A-owned."
+    )
+  ]
+};
+var getPiGeneratedFileManifest = () => structuredClone(PI_GENERATED_FILE_MANIFEST);
+var validatePiGeneratedFileManifest = (value) => validateGeneratedFileManifest(value);
+var createPiDownstreamManifestSummary = () => createDownstreamManifestSummary(getPiAdapterCapabilityMatrix(), getPiGeneratedFileManifest());
+
+// src/create-consumption/index.ts
+var CREATE_PI_ASSET_FAMILIES = Object.freeze(["pi-skill-files", "pi-prompt-templates"]);
+var CREATE_CONSUMER_LANE = "I-15A-create-import-cli-ux-selected-harness";
+var RUNTIME_PRODUCER_LANE = "I-14B-pi-adapter-runtime-skill-consumption";
+var PI_SKILL_PATTERN = ".pi/skills/<skill>/SKILL.md";
+var PI_PROMPT_PATTERN = ".pi/prompts/<name>.md";
+var EXCLUDED_FAMILY_IDS = Object.freeze(["pi-extensions", "pi-package-manifest", "context-files", "harness-config"]);
+var forbiddenDomainMarkers = () => Object.freeze([
+  "ecommerce",
+  "fashion",
+  "inventory",
+  "tenant",
+  "checkout",
+  "telegram",
+  "instagram",
+  "billz",
+  "pharmacy",
+  "ai-pipeline"
+]);
+var isCreateFamilyId = (familyId) => CREATE_PI_ASSET_FAMILIES.includes(familyId);
+var issue = (issues, path, code, message) => {
+  issues.push({ path, code, message, severity: "error" });
+};
+var familyById = (manifest, familyId) => manifest.families.find((family2) => family2.familyId === familyId);
+var sameStringSet = (actual, expected) => {
+  if (actual.length !== expected.length) return false;
+  const actualSet = new Set(actual);
+  return actualSet.size === actual.length && expected.every((expectedValue) => actualSet.has(expectedValue));
+};
+var relativePathSafe = (path) => path.length > 0 && !path.startsWith("/") && !path.startsWith("~") && !path.includes(":\\") && !path.split("/").some((segment) => segment === "" || segment === "..");
+var hasDomainMarker = (content) => {
+  const lower = content.toLowerCase();
+  for (const marker of forbiddenDomainMarkers()) {
+    if (lower.includes(marker.toLowerCase())) return marker;
+  }
+  return null;
+};
+var validateManifestAndMatrix = (manifest, capabilityMatrix, issues) => {
+  const matrixValidation = validateCapabilityMatrix(capabilityMatrix);
+  if (!matrixValidation.valid) {
+    for (const matrixIssue of matrixValidation.issues) {
+      issue(issues, `capabilityMatrix${matrixIssue.path.slice(1)}`, matrixIssue.code, matrixIssue.message);
+    }
+  }
+  const manifestValidation = validateGeneratedFileManifest(manifest);
+  if (!manifestValidation.valid) {
+    for (const manifestIssue of manifestValidation.issues) {
+      issue(issues, `generatedFileManifest${manifestIssue.path.slice(1)}`, manifestIssue.code, manifestIssue.message);
+    }
+  }
+  const selectedFamilies = manifest.families.filter((family2) => isCreateFamilyId(family2.familyId));
+  if (!sameStringSet(selectedFamilies.map((family2) => family2.familyId), [...CREATE_PI_ASSET_FAMILIES])) {
+    issue(issues, "generatedFileManifest.families", "create_pi_asset_family_set_mismatch", "Create pi asset selector must be exactly pi-skill-files plus pi-prompt-templates.");
+  }
+  for (const familyId of CREATE_PI_ASSET_FAMILIES) {
+    const family2 = familyById(manifest, familyId);
+    if (family2 === void 0) {
+      issue(issues, `generatedFileManifest.families.${familyId}`, "missing_create_pi_asset_family", `Required create pi asset family '${familyId}' is absent.`);
+      continue;
+    }
+    if (family2.readiness.state !== "ready") {
+      issue(issues, `generatedFileManifest.families.${familyId}.readiness`, "create_pi_asset_family_not_ready", `Create pi asset family '${familyId}' must be ready.`);
+    }
+    if (family2.producedByLane !== RUNTIME_PRODUCER_LANE) {
+      issue(issues, `generatedFileManifest.families.${familyId}.producedByLane`, "create_pi_asset_family_wrong_producer", `Create pi asset family '${familyId}' must be produced by ${RUNTIME_PRODUCER_LANE}.`);
+    }
+    if (!family2.consumedByLanes.includes(CREATE_CONSUMER_LANE)) {
+      issue(issues, `generatedFileManifest.families.${familyId}.consumedByLanes`, "create_pi_asset_family_not_consumed_by_create", `Create pi asset family '${familyId}' must be consumed by ${CREATE_CONSUMER_LANE}.`);
+    }
+  }
+  for (const excludedFamilyId of EXCLUDED_FAMILY_IDS) {
+    if (CREATE_PI_ASSET_FAMILIES.includes(excludedFamilyId)) {
+      issue(issues, `generatedFileManifest.families.${excludedFamilyId}`, "blocked_or_i15a_family_selected", `Family '${excludedFamilyId}' must never be selected for create pi asset writes.`);
+    }
+  }
+};
+var promptPath = (skillId) => `.pi/prompts/vibe-${skillId}.md`;
+var skillPath = (skillId) => `.pi/skills/${skillId}/SKILL.md`;
+var selectCreatePiAssets = (input) => {
+  const manifest = input?.manifest ?? getPiGeneratedFileManifest();
+  const capabilityMatrix = input?.capabilityMatrix ?? getPiAdapterCapabilityMatrix();
+  const issues = [];
+  validateManifestAndMatrix(manifest, capabilityMatrix, issues);
+  const skillFamily = familyById(manifest, "pi-skill-files");
+  const promptFamily = familyById(manifest, "pi-prompt-templates");
+  if (skillFamily !== void 0 && !skillFamily.pathPatterns.includes(PI_SKILL_PATTERN)) {
+    issue(issues, "generatedFileManifest.families.pi-skill-files.pathPatterns", "missing_pi_skill_path_pattern", "Create pi assets require the .pi skill path pattern, not an alternate only.");
+  }
+  if (promptFamily !== void 0 && !promptFamily.pathPatterns.includes(PI_PROMPT_PATTERN)) {
+    issue(issues, "generatedFileManifest.families.pi-prompt-templates.pathPatterns", "missing_pi_prompt_path_pattern", "Create pi assets require the .pi prompt path pattern.");
+  }
+  if (issues.length > 0) {
+    throw new CreatePiAssetValidationError("Create pi asset family selection failed.", issues);
+  }
+  return Object.freeze([
+    ...SKILL_IDS.map((skillId) => ({
+      kind: "skill",
+      familyId: "pi-skill-files",
+      skillId,
+      path: skillPath(skillId),
+      shippedTemplatePath: `templates/pi/runtime-fixtures/${skillPath(skillId)}`,
+      manifestPathPattern: PI_SKILL_PATTERN
+    })),
+    ...SKILL_IDS.map((skillId) => ({
+      kind: "prompt-template",
+      familyId: "pi-prompt-templates",
+      skillId,
+      path: promptPath(skillId),
+      shippedTemplatePath: `templates/pi/runtime-fixtures/${promptPath(skillId)}`,
+      manifestPathPattern: PI_PROMPT_PATTERN
+    }))
+  ]);
+};
+var CreatePiAssetValidationError = class _CreatePiAssetValidationError extends Error {
+  issues;
+  constructor(message, issues) {
+    super(message);
+    this.name = "CreatePiAssetValidationError";
+    this.issues = issues;
+    Object.setPrototypeOf(this, _CreatePiAssetValidationError.prototype);
+  }
+};
+var validateCreatePiAssetWritePlan = (input) => {
+  const issues = [];
+  validateManifestAndMatrix(input.manifest, input.capabilityMatrix, issues);
+  let expectedAssets = [];
+  try {
+    expectedAssets = selectCreatePiAssets({ manifest: input.manifest, capabilityMatrix: input.capabilityMatrix });
+  } catch (error) {
+    if (error instanceof CreatePiAssetValidationError) {
+      issues.push(...error.issues);
+    } else {
+      issue(issues, "generatedFileManifest", "create_pi_asset_selection_failed", "Create pi asset selector failed unexpectedly.");
+    }
+  }
+  const expectedByPath = new Map(expectedAssets.map((asset) => [asset.path, asset]));
+  if (input.writes.length !== expectedAssets.length) {
+    issue(issues, "writes", "create_pi_asset_write_count_mismatch", "Create pi asset write plan must contain exactly six skill files and six prompt templates.");
+  }
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (let index = 0; index < input.writes.length; index += 1) {
+    const write = input.writes[index];
+    if (write === void 0) {
+      issue(issues, `writes[${index}]`, "missing_write", "Create pi asset write is missing.");
+      continue;
+    }
+    if (!relativePathSafe(write.path)) {
+      issue(issues, `writes[${index}].path`, "unsafe_write_path", "Create pi asset write path must be relative and non-traversing.");
+    }
+    if (seenPaths.has(write.path)) {
+      issue(issues, `writes[${index}].path`, "duplicate_write_path", "Create pi asset write paths must be unique.");
+    }
+    seenPaths.add(write.path);
+    const expected = expectedByPath.get(write.path);
+    if (expected === void 0) {
+      issue(issues, `writes[${index}].path`, "write_path_not_in_create_pi_asset_manifest", "Write path is not one of the selected create pi asset paths.");
+    } else if (write.familyId !== expected.familyId || write.kind !== expected.kind || write.skillId !== expected.skillId || write.manifestPathPattern !== expected.manifestPathPattern || write.shippedTemplatePath !== expected.shippedTemplatePath) {
+      issue(issues, `writes[${index}]`, "write_descriptor_mismatch", "Write descriptor must match the selected create pi asset descriptor exactly.");
+    }
+    if (write.content.trim().length === 0) {
+      issue(issues, `writes[${index}].content`, "empty_create_pi_asset_content", "Create pi asset content must be non-empty.");
+    }
+    const marker = hasDomainMarker(write.content);
+    if (marker !== null) {
+      issue(issues, `writes[${index}].content`, "create_pi_asset_domain_marker", `Create pi asset content contains forbidden domain marker '${marker}'.`);
+    }
+  }
+  for (const expected of expectedAssets) {
+    if (!seenPaths.has(expected.path)) {
+      issue(issues, `writes.${expected.path}`, "missing_create_pi_asset_write", `Missing create pi asset write for ${expected.path}.`);
+    }
+  }
+  const existingByPath = new Map(input.existingPaths.map((entry) => [entry.path, entry]));
+  for (const write of input.writes) {
+    const pathSegments = write.path.split("/");
+    for (let segmentCount = 1; segmentCount < pathSegments.length; segmentCount += 1) {
+      const parentPath = pathSegments.slice(0, segmentCount).join("/");
+      const parent = existingByPath.get(parentPath);
+      if (parent === void 0 || parent.kind === "missing" || parent.kind === "directory") continue;
+      if (parent.kind === "symlink") {
+        issue(issues, `existingPaths.${parentPath}`, "ancestor_symlink_write_escape", "Create pi asset write refuses symlink ancestors because they may escape the project root.");
+      } else {
+        issue(issues, `existingPaths.${parentPath}`, "parent_path_not_directory", "Create pi asset write requires every existing parent path to be a directory.");
+      }
+    }
+    const existing = existingByPath.get(write.path);
+    if (existing === void 0 || existing.kind === "missing") continue;
+    if (existing.kind === "symlink") {
+      issue(issues, `existingPaths.${write.path}`, "symlink_write_escape", "Create pi asset write refuses symlink targets because they may escape the project root.");
+      continue;
+    }
+    if (existing.kind === "directory") {
+      issue(issues, `existingPaths.${write.path}`, "unsafe_overwrite_conflict", "Create pi asset write refuses to overwrite a directory.");
+      continue;
+    }
+    if (input.conflictPolicy === "fail-on-conflict") {
+      issue(issues, `existingPaths.${write.path}`, "unsafe_overwrite_conflict", "Create pi asset write refuses existing files under fail-on-conflict policy.");
+      continue;
+    }
+    if (existing.currentContent !== write.content) {
+      issue(issues, `existingPaths.${write.path}`, "unsafe_overwrite_conflict", "Create pi asset write only permits identical-content overwrites in import mode.");
+    }
+  }
+  if (issues.length > 0) {
+    return { valid: false, issues };
+  }
+  return {
+    valid: true,
+    value: {
+      conflictPolicy: input.conflictPolicy,
+      writes: input.writes,
+      families: [...CREATE_PI_ASSET_FAMILIES]
+    },
+    issues: []
+  };
+};
+
+export {
+  CREATE_PI_ASSET_FAMILIES,
+  selectCreatePiAssets,
+  CreatePiAssetValidationError,
+  validateCreatePiAssetWritePlan,
+  PI_GENERATED_FILE_MANIFEST_SCHEMA_VERSION,
+  PI_GENERATED_FILE_MANIFEST,
+  getPiGeneratedFileManifest,
+  validatePiGeneratedFileManifest,
+  createPiDownstreamManifestSummary
+};