@fraylabs/possible 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fraylabs/possible",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Create, publish, discover, and reuse source-owned AI Outcomes",
   "keywords": [
     "codex",
@@ -23,15 +23,10 @@
   "bin": {
     "possible": "src/index.mjs"
   },
-  "files": [
-    "assets/possible",
-    "src"
-  ],
+  "files": ["src"],
   "scripts": {
-    "build": "node scripts/sync-skill.mjs",
-    "test": "node --test test/*.test.mjs",
-    "sync:skill": "node scripts/sync-skill.mjs",
-    "prepack": "node scripts/sync-skill.mjs"
+    "build": "node --check src/index.mjs && node --check src/directory.mjs",
+    "test": "node --test test/*.test.mjs"
   },
   "engines": {
     "node": ">=22"

package/src/directory.mjs

@@ -0,0 +1,91 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+
+const DEFAULT_ENDPOINT = "https://reminiscent-lark-333.convex.site/api/outcomes";
+
+const directoryEndpoint = () => process.env.POSSIBLE_DIRECTORY_ENDPOINT?.trim() || DEFAULT_ENDPOINT;
+
+async function requestDirectory(parameters, fetchImplementation = fetch) {
+  const url = new URL(directoryEndpoint());
+  for (const [name, value] of Object.entries(parameters)) url.searchParams.set(name, value);
+  const response = await fetchImplementation(url, { headers: { accept: "application/json" } });
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(body.error || `Possible directory returned HTTP ${response.status}`);
+  return body;
+}
+
+function installationPath(environment = process.env) {
+  const home = environment.POSSIBLE_HOME ? resolve(environment.POSSIBLE_HOME) : join(homedir(), ".possible");
+  return join(home, "installation.json");
+}
+
+async function installationToken(environment = process.env) {
+  const path = installationPath(environment);
+  try {
+    const stored = JSON.parse(await readFile(path, "utf8"));
+    if (stored?.schemaVersion === 1 && typeof stored.id === "string") return stored.id;
+  } catch (error) {
+    if (error?.code !== "ENOENT" && !(error instanceof SyntaxError)) return undefined;
+  }
+  const id = randomUUID();
+  try {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify({ schemaVersion: 1, id }, null, 2)}\n`, { flag: "wx" });
+    return id;
+  } catch (error) {
+    if (error?.code === "EEXIST") return installationToken(environment);
+    return undefined;
+  }
+}
+
+async function recordUse(outcomeId, { fetchImplementation = fetch, environment = process.env } = {}) {
+  if (environment.CI || environment.POSSIBLE_TELEMETRY === "0") return;
+  const token = await installationToken(environment);
+  if (!token) return;
+  const endpoint = new URL(directoryEndpoint());
+  endpoint.pathname = `${endpoint.pathname.replace(/\/$/, "")}/use`;
+  endpoint.search = "";
+  try {
+    await fetchImplementation(endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json", accept: "application/json" },
+      body: JSON.stringify({
+        outcomeId,
+        visitorHash: createHash("sha256").update(token).digest("hex"),
+        source: "cli",
+        ci: false,
+      }),
+    });
+  } catch {
+    // Usage reporting never blocks access to a published prompt.
+  }
+}
+
+export async function searchOutcomes(query, options = {}) {
+  const normalized = String(query ?? "").trim();
+  if (!normalized) throw new Error("Search requires an ordinary-language query");
+  const body = await requestDirectory({ q: normalized, limit: "5" }, options.fetchImplementation);
+  return Array.isArray(body.outcomes) ? body.outcomes : [];
+}
+
+export async function fetchOutcome(id, options = {}) {
+  const normalized = String(id ?? "").trim();
+  if (!normalized) throw new Error("Fetch requires an Outcome ID from search results");
+  const body = await requestDirectory({ id: normalized }, options.fetchImplementation);
+  if (!body.outcome || typeof body.outcome.prompt !== "string") throw new Error("Possible returned an invalid Outcome");
+  await recordUse(body.outcome.id, options);
+  return body.outcome;
+}
+
+export function formatSearchResults(outcomes) {
+  if (!outcomes.length) return "No matching Outcomes found.\n";
+  return `${outcomes.map((outcome, index) => [
+    `${index + 1}. ${outcome.title}`,
+    `   ${outcome.summary}`,
+    ...(outcome.primary_attribution ? [`   Primary: ${outcome.primary_attribution.kind === "product" ? outcome.primary_attribution.id : `${outcome.primary_attribution.repository}/${outcome.primary_attribution.directory}`}`] : []),
+    `   ID: ${outcome.id}`,
+    `   Source: ${outcome.source_locator}`,
+  ].join("\n")).join("\n\n")}\n`;
+}

package/src/index.mjs

@@ -2,25 +2,28 @@
 
 import process from "node:process";
 import { runBookmarkCommand } from "./bookmarks.mjs";
-import { installPossibleSkill } from "./init.mjs";
+import { fetchOutcome, formatSearchResults, searchOutcomes } from "./directory.mjs";
 import { addOutcomeSource, createOutcome, publishOutcomeSource, useOutcome, validateOutcomes } from "./outcome-commands.mjs";
 
 const HELP = `Possible CLI
 
 Usage:
-  possible init
-  possible create <slug>
+  possible create <slug> --product <owner/product>
+  possible create <slug> --skill <owner/repository> <directory> <commit>
   possible validate [directory]
   possible publish [owner/repository | https://publisher.example]
+  possible search <ordinary-language query>
+  possible fetch <outcome-id>
   possible add <owner/repository | https://publisher.example>
   possible use <source>@<slug>
   possible bookmark <command>
 
 Commands:
-  init      Install the optional Possible prompt-preparation skill into this project
-  create    Create outcome.json, outcome.md, prompt.md, and media/ for one Outcome
+  create    Create one Outcome with its required primary Product or Skill
   validate  Validate every Outcome folder below a directory
   publish   Validate and submit one public publisher source; no account required
+  search    Find relevant Outcomes in the live public directory
+  fetch     Print one directory Outcome's exact prompt
   add       Discover a public source and save it to .possible/sources.json
   use       Print one exact execution prompt to standard output
   bookmark  add | list | remove locally saved Outcome slugs
@@ -38,9 +41,28 @@ if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
     process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
     process.exitCode = 1;
   }
-} else if (args[0] === "create" && args.length === 2) {
+} else if (args[0] === "search" && args.length >= 2) {
   try {
-    const folder = await createOutcome(args[1]);
+    const outcomes = await searchOutcomes(args.slice(1).join(" "));
+    process.stdout.write(formatSearchResults(outcomes));
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+  }
+} else if (args[0] === "fetch" && args.length === 2) {
+  try {
+    const outcome = await fetchOutcome(args[1]);
+    process.stdout.write(`${outcome.prompt}\n`);
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+  }
+} else if (args[0] === "create" && ((args[2] === "--product" && args.length === 4) || (args[2] === "--skill" && args.length === 6))) {
+  try {
+    const primary = args[2] === "--product"
+      ? { kind: "product", id: args[3] }
+      : { kind: "skill", repository: args[3], directory: args[4], lastReviewedCommit: args[5] };
+    const folder = await createOutcome(args[1], { primary });
     process.stdout.write(`Created ${folder}\n`);
   } catch (error) {
     process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
@@ -81,15 +103,7 @@ if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
     process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
     process.exitCode = 1;
   }
-} else if (args.length !== 1 || args[0] !== "init") {
+} else {
   process.stderr.write(`Unknown command: ${args.join(" ")}\n\n${HELP}`);
   process.exitCode = 1;
-} else {
-  try {
-    const result = await installPossibleSkill();
-    process.stdout.write(`${result.changed ? "Possible installed" : "Possible is already installed"} at ${result.installPath}\n\nOpen Codex in this project and type:\n\n  $possible\n`);
-  } catch (error) {
-    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-    process.exitCode = 1;
-  }
 }

package/src/outcome-commands.mjs

@@ -7,10 +7,11 @@ import { discoverOutcomeSource } from "./sources.mjs";
 
 const execFileAsync = promisify(execFile);
 const SAFE_SLUG = /^[a-z0-9][a-z0-9-]*$/;
-const DEFAULT_PUBLISH_ENDPOINT = "https://abutwsaahahtbtlopczi.supabase.co/functions/v1/register-outcome-source";
+const DEFAULT_PUBLISH_ENDPOINT = "https://reminiscent-lark-333.convex.site/api/outcomes/register";
 
-export async function createOutcome(slug, { directory = process.cwd() } = {}) {
+export async function createOutcome(slug, { directory = process.cwd(), primary } = {}) {
   if (!SAFE_SLUG.test(slug ?? "")) throw new Error("Outcome slug must be lowercase and hyphenated");
+  if (!primary) throw new Error("Choose one primary attribution with --product or --skill");
   const root = resolve(directory);
   const indexPath = join(root, "outcomes.json");
   let publisherIndex = {
@@ -28,13 +29,14 @@ export async function createOutcome(slug, { directory = process.cwd() } = {}) {
   await mkdir(join(folder, "media"), { recursive: true });
   const manifestPath = join(folder, "outcome.json");
   const manifest = {
-    schemaVersion: 3,
+    schemaVersion: 4,
     slug,
     files: { about: "outcome.md", prompt: "prompt.md" },
     authoredAt: null,
     author: { name: "Replace with publisher name", url: "https://example.com" },
     models: [{ provider: "Replace with provider", model: "Replace with model", role: "execution" }],
     requirements: [],
+    primary,
   };
   await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, { flag: "wx" });
   await writeFile(join(folder, "outcome.md"), `# Replace with Outcome name\n\nDescribe the concrete result in one clear opening paragraph.\n`, { flag: "wx" });

package/src/outcome-format.mjs

@@ -8,7 +8,9 @@ const GITHUB_REPOSITORY = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
 const SAFE_REPOSITORY_PATH = /^(?:\.|[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*)$/;
 const MODEL_ROLES = new Set(["authorship", "execution", "review"]);
 const FILE_TYPES = new Set(["image", "video", "audio", "cad", "document", "data", "source", "archive", "other"]);
-const MANIFEST_KEYS = new Set(["schemaVersion", "slug", "files", "authoredAt", "author", "models", "requirements", "products", "skills", "inputs", "artifacts", "preview"]);
+const BASE_MANIFEST_KEYS = ["schemaVersion", "slug", "files", "authoredAt", "author", "models", "requirements", "inputs", "artifacts", "preview"];
+const LEGACY_MANIFEST_KEYS = new Set([...BASE_MANIFEST_KEYS, "products", "skills"]);
+const MANIFEST_KEYS = new Set([...BASE_MANIFEST_KEYS, "primary", "secondary"]);
 
 const asObject = (value, context) => {
   if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${context} must be a JSON object`);
@@ -56,10 +58,59 @@ const validateFiles = (value, context) => {
   });
 };
 
+const validateSkillReference = (value, context, includeKind = false) => {
+  const skill = asObject(value, context);
+  exactKeys(skill, new Set(includeKind ? ["kind", "repository", "lastReviewedCommit", "directory"] : ["repository", "lastReviewedCommit", "directory"]), context);
+  if (includeKind && skill.kind !== "skill") throw new Error(`${context}.kind must be skill`);
+  if (!GITHUB_REPOSITORY.test(string(skill.repository, `${context}.repository`))) throw new Error(`${context}.repository is invalid`);
+  if (!EXACT_REVISION.test(string(skill.lastReviewedCommit, `${context}.lastReviewedCommit`))) throw new Error(`${context}.lastReviewedCommit must be an exact commit`);
+  const directory = string(skill.directory, `${context}.directory`);
+  if (!SAFE_REPOSITORY_PATH.test(directory) || (directory !== "." && directory.split("/").some((part) => part === "." || part === ".."))) throw new Error(`${context}.directory is invalid`);
+  return skill;
+};
+
+const validateAttribution = (value, context) => {
+  const attribution = asObject(value, context);
+  if (attribution.kind === "product") {
+    exactKeys(attribution, new Set(["kind", "id"]), context);
+    if (!PRODUCT_ID.test(string(attribution.id, `${context}.id`))) throw new Error(`${context}.id is invalid`);
+    return attribution;
+  }
+  if (attribution.kind === "skill") return validateSkillReference(attribution, context, true);
+  throw new Error(`${context}.kind must be product or skill`);
+};
+
+export const attributionKey = (attribution) => attribution.kind === "product"
+  ? `product:${attribution.id}`
+  : `skill:${attribution.repository}/${attribution.directory}`;
+
+export function normalizeOutcomeAttributions(manifest) {
+  if (manifest.schemaVersion === 4) {
+    const secondary = manifest.secondary ?? [];
+    const all = [manifest.primary, ...secondary];
+    return {
+      primary: manifest.primary,
+      secondary,
+      products: all.filter((item) => item.kind === "product").map((item) => item.id),
+      skills: all.filter((item) => item.kind === "skill").map(({ kind: _kind, ...skill }) => skill),
+    };
+  }
+  const legacy = [
+    ...(manifest.products ?? []).map((id) => ({ kind: "product", id })),
+    ...(manifest.skills ?? []).map((skill) => ({ kind: "skill", ...skill })),
+  ];
+  return {
+    primary: legacy[0] ?? null,
+    secondary: legacy.slice(1),
+    products: manifest.products ?? [],
+    skills: manifest.skills ?? [],
+  };
+}
+
 export function validateOutcomeManifest(value, context = "outcome.json") {
   const manifest = asObject(value, context);
-  exactKeys(manifest, MANIFEST_KEYS, context);
-  if (manifest.schemaVersion !== 3) throw new Error(`${context}.schemaVersion must be 3`);
+  if (manifest.schemaVersion !== 3 && manifest.schemaVersion !== 4) throw new Error(`${context}.schemaVersion must be 3 or 4`);
+  exactKeys(manifest, manifest.schemaVersion === 4 ? MANIFEST_KEYS : LEGACY_MANIFEST_KEYS, context);
   if (!SAFE_SLUG.test(string(manifest.slug, `${context}.slug`))) throw new Error(`${context}.slug must be lowercase and hyphenated`);
 
   const files = asObject(manifest.files, `${context}.files`);
@@ -92,24 +143,27 @@ export function validateOutcomeManifest(value, context = "outcome.json") {
   const requirements = manifest.requirements.map((entry, index) => string(entry, `${context}.requirements[${index}]`));
   if (new Set(requirements).size !== requirements.length) throw new Error(`${context}.requirements contains duplicates`);
 
-  if (manifest.products !== undefined) {
+  if (manifest.schemaVersion === 3 && manifest.products !== undefined) {
     if (!Array.isArray(manifest.products) || manifest.products.length === 0) throw new Error(`${context}.products must be omitted or a non-empty array`);
     for (const [index, product] of manifest.products.entries()) if (!PRODUCT_ID.test(string(product, `${context}.products[${index}]`))) throw new Error(`${context}.products[${index}] is invalid`);
     if (new Set(manifest.products).size !== manifest.products.length) throw new Error(`${context}.products contains duplicates`);
   }
 
-  if (manifest.skills !== undefined) {
+  if (manifest.schemaVersion === 3 && manifest.skills !== undefined) {
     if (!Array.isArray(manifest.skills) || manifest.skills.length === 0) throw new Error(`${context}.skills must be omitted or a non-empty array`);
     for (const [index, entry] of manifest.skills.entries()) {
-      const skill = asObject(entry, `${context}.skills[${index}]`);
-      exactKeys(skill, new Set(["repository", "lastReviewedCommit", "directory"]), `${context}.skills[${index}]`);
-      if (!GITHUB_REPOSITORY.test(string(skill.repository, `${context}.skills[${index}].repository`))) throw new Error(`${context}.skills[${index}].repository is invalid`);
-      if (!EXACT_REVISION.test(string(skill.lastReviewedCommit, `${context}.skills[${index}].lastReviewedCommit`))) throw new Error(`${context}.skills[${index}].lastReviewedCommit must be an exact commit`);
-      const directory = string(skill.directory, `${context}.skills[${index}].directory`);
-      if (!SAFE_REPOSITORY_PATH.test(directory) || (directory !== "." && directory.split("/").some((part) => part === "." || part === ".."))) throw new Error(`${context}.skills[${index}].directory is invalid`);
+      validateSkillReference(entry, `${context}.skills[${index}]`);
     }
   }
 
+  if (manifest.schemaVersion === 4) {
+    const primary = validateAttribution(manifest.primary, `${context}.primary`);
+    if (manifest.secondary !== undefined && (!Array.isArray(manifest.secondary) || manifest.secondary.length === 0)) throw new Error(`${context}.secondary must be omitted or a non-empty array`);
+    const secondary = (manifest.secondary ?? []).map((entry, index) => validateAttribution(entry, `${context}.secondary[${index}]`));
+    const keys = [attributionKey(primary), ...secondary.map(attributionKey)];
+    if (new Set(keys).size !== keys.length) throw new Error(`${context} contains duplicate primary or secondary attributions`);
+  }
+
   validateFiles(manifest.inputs, `${context}.inputs`);
   validateFiles(manifest.artifacts, `${context}.artifacts`);
   if (manifest.preview !== undefined) asObject(manifest.preview, `${context}.preview`);

package/src/sources.d.mts

@@ -0,0 +1,36 @@
+export type OutcomeSource = {
+  type: "github" | "well-known";
+  locator: string;
+  installUrl: string;
+};
+
+export type DiscoveredOutcome = {
+  slug: string;
+  title: string;
+  summary: string;
+  aboutMarkdown: string;
+  prompt: string;
+  manifest: Record<string, unknown>;
+  manifestUrl: string;
+  aboutUrl: string;
+  promptUrl: string;
+  repositoryPath?: string;
+  contentHash: string;
+};
+
+export type OutcomeDiscovery = OutcomeSource & {
+  revision: string;
+  publisherName: string;
+  outcomes: DiscoveredOutcome[];
+};
+
+export type PublicOutcomeSnapshot = {
+  schemaVersion: 1;
+  source: OutcomeSource & { revision: string };
+  publisherName: string;
+  outcomes: DiscoveredOutcome[];
+};
+
+export function parseOutcomeSource(value: string): OutcomeSource;
+export function discoverOutcomeSource(value: string | OutcomeSource, options?: { githubToken?: string }): Promise<OutcomeDiscovery>;
+export function publicSnapshot(discovery: OutcomeDiscovery): PublicOutcomeSnapshot;

package/assets/possible/SKILL.md

@@ -1,117 +0,0 @@
----
-name: possible
-description: Discover proven Outcomes and turn a rough request into one complete execution prompt for a fresh agent. Also author and validate source-owned Outcomes for Possible.
----
-
-# Possible
-
-Possible connects three things:
-
-- the user's **original prompt**;
-- the complete **execution prompt** sent to a working agent;
-- the resulting **Outcome**.
-
-An Outcome is precedent to inspect and remix, not a rigid workflow. Preserve useful creative freedom while giving a fresh agent the context, current methods, and concrete inputs it needs.
-
-## Discover before writing
-
-Preserve the user's original prompt verbatim. Determine whether they want to browse possibilities, prepare a prompt, execute work, or publish completed work.
-
-For browsing or execution, call `search_outcomes` using ordinary language. Show up to five relevant Outcomes when the user is browsing. When preparing work, fetch the strongest candidates with `fetch_outcome` and read their exact prompts. Search scores indicate text similarity, not quality.
-
-Use Outcomes as concrete precedent. If none fit, use current primary sources rather than forcing an unrelated example. Prefer official documentation, current source repositories and registries, then reproducible community examples. Check volatile information at run time. Popularity is a discovery signal, not proof that an Outcome is good.
-
-## Resolve consequential unknowns
-
-Collect only what can materially improve execution:
-
-- the intended result, audience, use, and strong preferences;
-- supplied files, measurements, references, credentials, and constraints;
-- required inputs that the executor cannot safely invent;
-- relevant prior Outcomes and what they actually produced;
-- current Products, Skills, tools, environment, permissions, and limits;
-- what the user will inspect to decide that the result is finished.
-
-Ask the fewest questions necessary. Discover safe facts yourself. Infer harmless aesthetic details when a restrained default is sufficient. Do not turn the conversation into a form.
-
-## Prepare one execution prompt
-
-Write one readable, self-contained prompt for a fresh agent. It should naturally state:
-
-- the exact result and who it is for;
-- relevant user context and supplied materials;
-- concrete requirements and preferences;
-- current Products, Skills, or tools that matter;
-- deliverables and where to place them;
-- constraints, permissions, and separately authorized external actions;
-- what the user will inspect to judge the result;
-- unknowns the executor must preserve rather than invent.
-
-Adapt prior prompts to the current request, date, model, environment, and evidence. Never substitute a summary for a strong full prompt. Never claim an old method is current without checking. Keep the published prompt distinct from the new prompt you prepare.
-
-Before handoff, confirm that a fresh agent can start without hidden conversation history, missing essential files, consequential unresolved choices, unsupported current claims, or unclear success conditions. Research further or ask one focused question if it cannot.
-
-Show the proposed execution prompt and name the prior Outcomes and current official sources that materially shaped it.
-
-## Hand off once
-
-After approval, send the execution prompt unchanged to a fresh subagent when that capability is available. Include explicit paths or attachments for every supplied file. One-shot means complete starting context; it does not forbid the executor from inspecting, testing, or repairing its work.
-
-If fresh subagents are unavailable, return the execution prompt in a copyable block. Do not pretend a handoff occurred.
-
-Products and Skills describe capabilities. They do not grant permission to spend money, purchase, publish, deploy, contact people, fabricate, operate hardware, or perform another external action.
-
-## Author a completed Outcome
-
-When the user wants to publish completed work, inspect the real result and preserve the exact prompt and provenance. Create one folder:
-
-```text
-outcomes.json
-outcomes/<slug>/
-  outcome.json
-  outcome.md
-  prompt.md
-  media/        optional
-  artifacts/    optional
-  inputs/       optional
-```
-
-`outcomes.json` is the repository-root publisher index and is created or updated by the CLI. `outcome.md` is the canonical human page: one H1 title, one clear opening summary, and useful formatted explanation. `prompt.md` is the exact reusable execution prompt. `outcome.json` contains machine metadata only: author, authored timestamp, models and agents, required inputs, Products, Skills with last-reviewed commits, and media or artifact references.
-
-Do not reconstruct absent provenance as fact. Mark unknown values honestly. Products and models belong in `outcome.json`; deliverables and detailed work instructions belong in `prompt.md`; result explanation belongs in `outcome.md`.
-
-Use the CLI to scaffold and validate:
-
-```text
-npx @fraylabs/possible@0.2.0 create <slug>
-npx @fraylabs/possible@0.2.0 validate [directory]
-```
-
-## Publish from the owner's source
-
-Possible does not host publisher accounts or own the canonical files. A publisher exposes Outcomes from either:
-
-- a public GitHub repository; or
-- `https://publisher.example/.well-known/possible/outcomes.json`.
-
-The publisher index is a thin list of manifest locations. Possible snapshots the public source revision and displays it; changing the source creates a new revision rather than rewriting history.
-
-```text
-npx @fraylabs/possible@0.2.0 publish [owner/repository | https://publisher.example]
-npx @fraylabs/possible@0.2.0 add <owner/repository | https://publisher.example>
-npx @fraylabs/possible@0.2.0 use <source>@<slug>
-```
-
-GitHub publishing requires a clean committed revision so the snapshot is reproducible. No Possible login is required. A publisher-domain source is Official for that domain; other sources are Community unless their ownership follows directly from the public source.
-
-## Local bookmarks
-
-Use bookmarks only when the user asks:
-
-```text
-npx @fraylabs/possible@0.2.0 bookmark add <outcome-slug>
-npx @fraylabs/possible@0.2.0 bookmark list
-npx @fraylabs/possible@0.2.0 bookmark remove <outcome-slug>
-```
-
-Bookmarks are stored locally in `.possible` and do not require an account.

package/assets/possible/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "Possible"
-  short_description: "Discover Outcomes and prepare complete prompts"
-  default_prompt: "Use $possible to find relevant Outcomes and turn my request into a complete execution prompt for a fresh agent."

package/src/init.mjs

@@ -1,150 +0,0 @@
-import { constants } from "node:fs";
-import { copyFile, lstat, mkdir, readFile, readdir } from "node:fs/promises";
-import { isAbsolute, join, relative, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const DEFAULT_SOURCE = fileURLToPath(new URL("../assets/possible", import.meta.url));
-const INSTALL_SEGMENTS = [".agents", "skills", "possible"];
-
-export class InstallConflictError extends Error {
-  constructor(conflicts) {
-    super(
-      `Possible was not installed because existing files conflict:\n${conflicts
-        .map((path) => `  - ${path}`)
-        .join("\n")}\nMove or remove the conflicting path, then run the command again.`,
-    );
-    this.name = "InstallConflictError";
-    this.conflicts = conflicts;
-  }
-}
-
-const pathExists = async (path) => {
-  try {
-    return await lstat(path);
-  } catch (error) {
-    if (error?.code === "ENOENT") return null;
-    throw error;
-  }
-};
-
-const listTree = async (root, current = "") => {
-  const directory = join(root, current);
-  const entries = await readdir(directory, { withFileTypes: true });
-  const files = [];
-  const directories = [];
-
-  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
-    const child = join(current, entry.name);
-    if (entry.isSymbolicLink()) {
-      throw new Error(`The packaged Possible skill contains an unsupported symbolic link: ${child}`);
-    }
-    if (entry.isDirectory()) {
-      directories.push(child);
-      const nested = await listTree(root, child);
-      directories.push(...nested.directories);
-      files.push(...nested.files);
-      continue;
-    }
-    if (!entry.isFile()) {
-      throw new Error(`The packaged Possible skill contains an unsupported entry: ${child}`);
-    }
-    files.push(child);
-  }
-
-  return { directories, files };
-};
-
-const sameFile = async (left, right) => {
-  const [leftContent, rightContent] = await Promise.all([readFile(left), readFile(right)]);
-  return leftContent.equals(rightContent);
-};
-
-const displayPath = (projectRoot, path) => relative(projectRoot, path) || ".";
-
-const assertInsideProject = (projectRoot, path) => {
-  const rel = relative(projectRoot, path);
-  if (rel !== "" && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel)) return;
-  throw new Error(`Refusing to write outside the target project: ${path}`);
-};
-
-const ensureDirectory = async (projectRoot, path) => {
-  assertInsideProject(projectRoot, path);
-  try {
-    await mkdir(path);
-  } catch (error) {
-    if (error?.code !== "EEXIST") throw error;
-  }
-  const stats = await lstat(path);
-  if (!stats.isDirectory() || stats.isSymbolicLink()) {
-    throw new InstallConflictError([displayPath(projectRoot, path)]);
-  }
-};
-
-export async function installPossibleSkill({ projectDirectory = process.cwd(), sourceDirectory = DEFAULT_SOURCE } = {}) {
-  const projectRoot = resolve(projectDirectory);
-  const projectStats = await pathExists(projectRoot);
-  if (!projectStats?.isDirectory()) {
-    throw new Error(`Target project is not a directory: ${projectRoot}`);
-  }
-
-  const sourceRoot = resolve(sourceDirectory);
-  const sourceStats = await pathExists(sourceRoot);
-  if (!sourceStats?.isDirectory()) {
-    throw new Error(`Packaged Possible skill is missing: ${sourceRoot}`);
-  }
-
-  const tree = await listTree(sourceRoot);
-  const installRoot = join(projectRoot, ...INSTALL_SEGMENTS);
-  const directoryPaths = [
-    join(projectRoot, INSTALL_SEGMENTS[0]),
-    join(projectRoot, ...INSTALL_SEGMENTS.slice(0, 2)),
-    installRoot,
-    ...tree.directories.map((path) => join(installRoot, path)),
-  ];
-  const conflicts = [];
-
-  for (const path of directoryPaths) {
-    assertInsideProject(projectRoot, path);
-    const stats = await pathExists(path);
-    if (stats && (!stats.isDirectory() || stats.isSymbolicLink())) {
-      conflicts.push(displayPath(projectRoot, path));
-    }
-  }
-
-  const missingFiles = [];
-  for (const sourceRelativePath of tree.files) {
-    const sourcePath = join(sourceRoot, sourceRelativePath);
-    const destinationPath = join(installRoot, sourceRelativePath);
-    assertInsideProject(projectRoot, destinationPath);
-    const stats = await pathExists(destinationPath);
-    if (!stats) {
-      missingFiles.push({ sourcePath, destinationPath });
-    } else if (!stats.isFile() || stats.isSymbolicLink() || !(await sameFile(sourcePath, destinationPath))) {
-      conflicts.push(displayPath(projectRoot, destinationPath));
-    }
-  }
-
-  if (conflicts.length > 0) {
-    throw new InstallConflictError([...new Set(conflicts)].sort());
-  }
-
-  for (const path of directoryPaths) {
-    await ensureDirectory(projectRoot, path);
-  }
-  for (const { sourcePath, destinationPath } of missingFiles) {
-    try {
-      await copyFile(sourcePath, destinationPath, constants.COPYFILE_EXCL);
-    } catch (error) {
-      if (error?.code === "EEXIST") {
-        throw new InstallConflictError([displayPath(projectRoot, destinationPath)]);
-      }
-      throw error;
-    }
-  }
-
-  return {
-    changed: missingFiles.length > 0,
-    filesWritten: missingFiles.length,
-    installPath: displayPath(projectRoot, installRoot),
-  };
-}