@olorehq/olore 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli.js

@@ -0,0 +1,981 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { createRequire } from "module";
+import { Command } from "commander";
+import pc7 from "picocolors";
+
+// src/commands/init.ts
+import fs from "fs";
+import path from "path";
+import readline from "readline";
+import pc from "picocolors";
+async function prompt(question, defaultValue) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    const q = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
+    rl.question(q, (answer) => {
+      rl.close();
+      resolve(answer || defaultValue || "");
+    });
+  });
+}
+async function init(options) {
+  const cwd = process.cwd();
+  const folderName = path.basename(cwd);
+  if (fs.existsSync(path.join(cwd, "olore.config.json"))) {
+    throw new Error("olore.config.json already exists. This folder is already initialized.");
+  }
+  let name;
+  let version2;
+  let description;
+  if (options.yes) {
+    name = options.name || folderName;
+    version2 = options.version || "1.0.0";
+    description = `Documentation for ${name}`;
+  } else {
+    console.log(pc.bold("\nInitialize olore documentation package\n"));
+    name = await prompt("Package name", options.name || folderName);
+    version2 = await prompt("Version", options.version || "1.0.0");
+    description = await prompt("Description", `Documentation for ${name}`);
+  }
+  const fullName = `olore-${name}-${version2}`;
+  const configContent = {
+    name,
+    version: version2,
+    description,
+    contentPath: "./docs",
+    outputPath: "./olore-package",
+    extensions: [".md", ".mdx"],
+    exclude: []
+  };
+  fs.writeFileSync(
+    path.join(cwd, "olore.config.json"),
+    JSON.stringify(configContent, null, 2) + "\n"
+  );
+  const docsDir = path.join(cwd, "docs");
+  if (!fs.existsSync(docsDir)) {
+    fs.mkdirSync(docsDir);
+    fs.writeFileSync(
+      path.join(docsDir, "getting-started.md"),
+      `# Getting Started with ${name}
+
+Add your documentation content here.
+
+## Overview
+
+Describe what this documentation covers.
+
+## Topics
+
+- Topic 1
+- Topic 2
+`
+    );
+  }
+  console.log(pc.bold(`
+Initialized olore package: `) + pc.cyan(fullName));
+  console.log("");
+  console.log(pc.gray("Created:"));
+  console.log(pc.green("  \u2713 olore.config.json"));
+  console.log(pc.green("  \u2713 docs/") + pc.gray(" (add your documentation here)"));
+  console.log("");
+  console.log(pc.gray("Next steps:"));
+  console.log("  1. Add your .md files to the " + pc.cyan("docs/") + " folder");
+  console.log("  2. Run " + pc.cyan("/olore-docs-packager-1.0.0") + " in Claude Code to build");
+  console.log("  3. Run " + pc.cyan("olore install ./olore-package") + " to install");
+  console.log("");
+}
+
+// src/commands/install.ts
+import path5 from "path";
+import fs5 from "fs-extra";
+import ora from "ora";
+import pc2 from "picocolors";
+
+// src/core/download.ts
+import { createHash } from "crypto";
+import { createWriteStream } from "fs";
+import os from "os";
+import path2 from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+import fs2 from "fs-extra";
+import * as tar from "tar";
+
+// src/core/constants.ts
+var REGISTRY_URL = "https://olorehq.github.io/olore/registry";
+var DOWNLOAD_TIMEOUT = 6e4;
+var USER_AGENT = "olore-cli/0.1.0";
+
+// src/core/download.ts
+var DownloadError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "DownloadError";
+  }
+};
+async function downloadFile(url, dest) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), DOWNLOAD_TIMEOUT);
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        "User-Agent": USER_AGENT
+      }
+    });
+    if (!response.ok) {
+      throw new DownloadError(
+        `Download failed: ${response.status} ${response.statusText}`,
+        "NETWORK_ERROR"
+      );
+    }
+    if (!response.body) {
+      throw new DownloadError("No response body", "NETWORK_ERROR");
+    }
+    await fs2.ensureDir(path2.dirname(dest));
+    const nodeReadable = Readable.fromWeb(response.body);
+    const writeStream = createWriteStream(dest);
+    await pipeline(nodeReadable, writeStream);
+  } catch (error) {
+    if (error instanceof DownloadError) {
+      throw error;
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new DownloadError(`Download timed out after ${DOWNLOAD_TIMEOUT}ms`, "TIMEOUT");
+    }
+    throw new DownloadError(
+      `Download error: ${error instanceof Error ? error.message : "Unknown error"}`,
+      "NETWORK_ERROR"
+    );
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function calculateChecksum(filePath) {
+  const hash = createHash("sha256");
+  const stream = fs2.createReadStream(filePath);
+  return new Promise((resolve, reject) => {
+    stream.on("data", (data) => hash.update(data));
+    stream.on("end", () => resolve(`sha256-${hash.digest("base64")}`));
+    stream.on("error", reject);
+  });
+}
+async function verifyChecksum(filePath, expected) {
+  const actual = await calculateChecksum(filePath);
+  return actual === expected;
+}
+async function extractTarball(tarball, dest) {
+  await fs2.ensureDir(dest);
+  try {
+    await tar.extract({
+      file: tarball,
+      cwd: dest,
+      strip: 1
+      // Remove top-level directory from archive
+    });
+  } catch (error) {
+    throw new DownloadError(
+      `Failed to extract tarball: ${error instanceof Error ? error.message : "Unknown error"}`,
+      "EXTRACTION_FAILED"
+    );
+  }
+}
+async function downloadAndInstall(url, dest, integrity) {
+  const tempDir = await fs2.mkdtemp(path2.join(os.tmpdir(), "olore-"));
+  const tarballPath = path2.join(tempDir, "package.tar.gz");
+  try {
+    await downloadFile(url, tarballPath);
+    const checksumValid = await verifyChecksum(tarballPath, integrity);
+    if (!checksumValid) {
+      const actual = await calculateChecksum(tarballPath);
+      throw new DownloadError(
+        `Checksum verification failed.
+Expected: ${integrity}
+Actual: ${actual}`,
+        "CHECKSUM_MISMATCH"
+      );
+    }
+    await fs2.remove(dest);
+    await extractTarball(tarballPath, dest);
+    return dest;
+  } finally {
+    await fs2.remove(tempDir).catch(() => {
+    });
+  }
+}
+async function downloadAndExtractToTemp(url, integrity) {
+  const tempDir = await fs2.mkdtemp(path2.join(os.tmpdir(), "olore-"));
+  const tarballPath = path2.join(tempDir, "package.tar.gz");
+  const extractDir = path2.join(tempDir, "package");
+  try {
+    await downloadFile(url, tarballPath);
+    const checksumValid = await verifyChecksum(tarballPath, integrity);
+    if (!checksumValid) {
+      const actual = await calculateChecksum(tarballPath);
+      throw new DownloadError(
+        `Checksum verification failed.
+Expected: ${integrity}
+Actual: ${actual}`,
+        "CHECKSUM_MISMATCH"
+      );
+    }
+    await extractTarball(tarballPath, extractDir);
+    await fs2.remove(tarballPath);
+    return extractDir;
+  } catch (error) {
+    await fs2.remove(tempDir).catch(() => {
+    });
+    throw error;
+  }
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
+}
+
+// src/core/paths.ts
+import fs4 from "fs";
+import os3 from "os";
+import path4 from "path";
+import { fileURLToPath } from "url";
+
+// src/core/platform.ts
+import os2 from "os";
+import path3 from "path";
+import fs3 from "fs-extra";
+var isWindows = process.platform === "win32";
+async function linkOrCopy(source, target) {
+  if (isWindows) {
+    await fs3.copy(source, target);
+  } else {
+    await fs3.symlink(source, target, "dir");
+  }
+}
+function expandPath(p) {
+  if (p.startsWith("~")) {
+    return path3.join(os2.homedir(), p.slice(1));
+  }
+  return path3.resolve(p);
+}
+function isLocalPath(p) {
+  if (p.startsWith(".") || p.startsWith("/") || p.startsWith("~")) {
+    return true;
+  }
+  if (/^[A-Za-z]:/.test(p)) {
+    return true;
+  }
+  if (p.startsWith("\\\\")) {
+    return true;
+  }
+  return false;
+}
+function pathStartsWith(child, parent) {
+  if (isWindows) {
+    return child.toLowerCase().startsWith(parent.toLowerCase());
+  }
+  return child.startsWith(parent);
+}
+function getLinkActionText() {
+  return isWindows ? "Copying" : "Creating symlinks";
+}
+function getLinkTypeText() {
+  return isWindows ? "copied to" : "symlinked to";
+}
+
+// src/core/paths.ts
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path4.dirname(__filename2);
+function getOloreHome() {
+  return path4.join(os3.homedir(), ".olore");
+}
+function getOlorePackagePath(name, version2) {
+  return path4.join(getOloreHome(), "packages", name, version2);
+}
+function isInstalledPackage(symlinkPath) {
+  try {
+    const target = fs4.readlinkSync(symlinkPath);
+    const oloreHome = getOloreHome();
+    return pathStartsWith(target, oloreHome);
+  } catch {
+    return fs4.existsSync(symlinkPath) && fs4.statSync(symlinkPath).isDirectory();
+  }
+}
+function getSymlinkTarget(symlinkPath) {
+  try {
+    return fs4.readlinkSync(symlinkPath);
+  } catch {
+    return null;
+  }
+}
+function getAgentPaths() {
+  const home = os3.homedir();
+  return {
+    claude: path4.join(home, ".claude", "skills"),
+    codex: path4.join(home, ".codex", "skills"),
+    opencode: path4.join(home, ".config", "opencode", "skills")
+  };
+}
+function detectAgents() {
+  const agents = [];
+  const paths = getAgentPaths();
+  for (const [agent, agentPath] of Object.entries(paths)) {
+    const parentDir = path4.dirname(agentPath);
+    if (fs4.existsSync(parentDir)) {
+      agents.push(agent);
+    }
+  }
+  return agents;
+}
+async function getInstalledPackages() {
+  const agentPaths = getAgentPaths();
+  const packages = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [agent, skillsDir] of Object.entries(agentPaths)) {
+    if (!fs4.existsSync(skillsDir)) {
+      continue;
+    }
+    const entries = fs4.readdirSync(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const isValidEntry = entry.isDirectory() || entry.isSymbolicLink();
+      if (!isValidEntry || !entry.name.startsWith("olore-")) {
+        continue;
+      }
+      const pkgPath = path4.join(skillsDir, entry.name);
+      const lockPath = path4.join(pkgPath, "olore-lock.json");
+      if (!fs4.existsSync(lockPath)) {
+        continue;
+      }
+      const pkgName = entry.name;
+      if (seen.has(pkgName)) {
+        continue;
+      }
+      seen.add(pkgName);
+      try {
+        const lock = JSON.parse(fs4.readFileSync(lockPath, "utf-8"));
+        const stats = await getDirectoryStats(pkgPath);
+        const symlinkTarget = getSymlinkTarget(pkgPath);
+        let installType;
+        if (symlinkTarget) {
+          installType = isInstalledPackage(pkgPath) ? "installed" : "linked";
+        } else {
+          installType = "copied";
+        }
+        packages.push({
+          name: lock.name || pkgName.replace("olore-", ""),
+          version: lock.version || "unknown",
+          files: stats.files,
+          size: stats.size,
+          path: pkgPath,
+          agent,
+          installType,
+          symlinkTarget
+        });
+      } catch {
+      }
+    }
+  }
+  return packages.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function getDirectoryStats(dir) {
+  let files = 0;
+  let size = 0;
+  function walk(currentDir) {
+    const entries = fs4.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path4.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        files++;
+        size += fs4.statSync(fullPath).size;
+      }
+    }
+  }
+  walk(dir);
+  return { files, size };
+}
+
+// src/core/registry.ts
+var RegistryError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "RegistryError";
+  }
+};
+async function fetchWithTimeout(url, timeout = DOWNLOAD_TIMEOUT) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        "User-Agent": USER_AGENT
+      }
+    });
+    return response;
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new RegistryError(`Request timed out after ${timeout}ms`, "TIMEOUT");
+    }
+    throw new RegistryError(
+      `Network error: ${error instanceof Error ? error.message : "Unknown error"}`,
+      "NETWORK_ERROR"
+    );
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function fetchPackageVersions(name) {
+  const url = `${REGISTRY_URL}/packages/${name}.json`;
+  const response = await fetchWithTimeout(url);
+  if (response.status === 404) {
+    throw new RegistryError(`Package "${name}" not found in registry`, "NOT_FOUND");
+  }
+  if (!response.ok) {
+    throw new RegistryError(`Failed to fetch package info: ${response.status}`, "NETWORK_ERROR");
+  }
+  try {
+    const data = await response.json();
+    return data;
+  } catch {
+    throw new RegistryError("Invalid package response", "INVALID_RESPONSE");
+  }
+}
+async function resolveVersion(name, version2) {
+  const packageVersions = await fetchPackageVersions(name);
+  const targetVersion = version2 || "latest";
+  const versionInfo = packageVersions.versions[targetVersion];
+  if (!versionInfo) {
+    const availableVersions = Object.keys(packageVersions.versions).join(", ");
+    throw new RegistryError(
+      `Version "${targetVersion}" not found for package "${name}". Available: ${availableVersions}`,
+      "NOT_FOUND"
+    );
+  }
+  return versionInfo;
+}
+
+// src/commands/install.ts
+async function installFromLocal(localPath) {
+  const fullPath = expandPath(localPath);
+  if (!await fs5.pathExists(fullPath)) {
+    throw new Error(`Path not found: ${fullPath}`);
+  }
+  const stat = await fs5.stat(fullPath);
+  if (!stat.isDirectory()) {
+    throw new Error(`Not a directory: ${fullPath}`);
+  }
+  const lockPath = path5.join(fullPath, "olore-lock.json");
+  if (!await fs5.pathExists(lockPath)) {
+    throw new Error(`Missing olore-lock.json in ${fullPath}`);
+  }
+  const skillPath = path5.join(fullPath, "SKILL.md");
+  if (!await fs5.pathExists(skillPath)) {
+    throw new Error(`Missing SKILL.md in ${fullPath}. Run /generate-agent-skills first.`);
+  }
+  const lock = await fs5.readJson(lockPath);
+  const packageName = lock.name;
+  const packageVersion = lock.version;
+  if (!packageName) {
+    throw new Error(`Invalid olore-lock.json: missing "name" field`);
+  }
+  if (!packageVersion) {
+    throw new Error(`Invalid olore-lock.json: missing "version" field`);
+  }
+  const skillName = `olore-${packageName}-${packageVersion}`;
+  const skillContent = await fs5.readFile(skillPath, "utf-8");
+  const nameMatch = skillContent.match(/^name:\s*(.+)$/m);
+  const skillMdName = nameMatch ? nameMatch[1].trim() : null;
+  if (skillMdName !== skillName) {
+    console.log(pc2.yellow(`
+Warning: SKILL.md name mismatch`));
+    console.log(pc2.gray(`  Expected: ${skillName}`));
+    console.log(pc2.gray(`  Found:    ${skillMdName || "(none)"}`));
+    console.log(pc2.yellow(`  Updating SKILL.md to fix...`));
+    const updatedContent = skillMdName ? skillContent.replace(/^name:\s*.+$/m, `name: ${skillName}`) : skillContent.replace(/^---\n/, `---
+name: ${skillName}
+`);
+    await fs5.writeFile(skillPath, updatedContent);
+  }
+  console.log(pc2.bold(`
+Installing ${packageName}@${packageVersion} from local path...
+`));
+  const agents = detectAgents();
+  if (agents.length === 0) {
+    console.log(pc2.yellow("No agents detected. Creating directories anyway."));
+  }
+  const agentPaths = getAgentPaths();
+  if (isWindows) {
+    const spinner = ora("Copying to agent directories...").start();
+    const copied = [];
+    for (const [agent, skillsDir] of Object.entries(agentPaths)) {
+      const targetDir = path5.join(skillsDir, skillName);
+      await fs5.ensureDir(skillsDir);
+      await fs5.remove(targetDir);
+      await fs5.copy(fullPath, targetDir);
+      copied.push(`${pc2.green("\u2713")} ${agent} ${pc2.gray("\u2192")} ${pc2.gray(targetDir)}`);
+    }
+    spinner.stop();
+    copied.forEach((line) => console.log(`  ${line}`));
+    console.log(pc2.gray(`    \u2514\u2500 copied from ${fullPath}`));
+  } else {
+    const olorePath = getOlorePackagePath(packageName, packageVersion);
+    const spinner = ora("Copying to ~/.olore...").start();
+    await fs5.ensureDir(path5.dirname(olorePath));
+    await fs5.remove(olorePath);
+    await fs5.copy(fullPath, olorePath);
+    spinner.succeed(`Copied to ${pc2.gray(olorePath)}`);
+    const linkSpinner = ora("Creating symlinks...").start();
+    const linked = [];
+    for (const [agent, skillsDir] of Object.entries(agentPaths)) {
+      const targetDir = path5.join(skillsDir, skillName);
+      await fs5.ensureDir(skillsDir);
+      await fs5.remove(targetDir);
+      await linkOrCopy(olorePath, targetDir);
+      linked.push(`${pc2.green("\u2713")} ${agent} ${pc2.gray("\u2192")} ${pc2.gray(targetDir)}`);
+    }
+    linkSpinner.stop();
+    linked.forEach((line) => console.log(`  ${line}`));
+    console.log(pc2.gray(`    \u2514\u2500 all symlinked to ${olorePath}`));
+  }
+  console.log("");
+  console.log(pc2.green("Installation complete!"));
+  console.log("");
+  console.log(pc2.gray("Skill is now available as:"));
+  console.log(pc2.cyan(`  /${skillName}`) + pc2.gray(" (Claude Code)"));
+  console.log(pc2.cyan(`  $${skillName}`) + pc2.gray(" (Codex)"));
+  console.log(pc2.cyan(`  ${skillName}`) + pc2.gray(" (OpenCode)"));
+}
+async function install(pkg, options) {
+  if (options.force) {
+    console.log(pc2.cyan("\n\u2728 May the Skill be with you.\n"));
+  }
+  if (isLocalPath(pkg)) {
+    await installFromLocal(pkg);
+    return;
+  }
+  await installFromRemote(pkg, options.version);
+}
+function parsePackageSpec(spec) {
+  const atIndex = spec.lastIndexOf("@");
+  if (atIndex > 0) {
+    return {
+      name: spec.slice(0, atIndex),
+      version: spec.slice(atIndex + 1)
+    };
+  }
+  return { name: spec };
+}
+async function installFromRemote(pkg, optionsVersion) {
+  const { name, version: specVersion } = parsePackageSpec(pkg);
+  const requestedVersion = optionsVersion || specVersion || "latest";
+  console.log(pc2.bold(`
+Installing ${name}@${requestedVersion} from registry...
+`));
+  const spinner = ora("Fetching package info...").start();
+  let versionInfo;
+  try {
+    versionInfo = await resolveVersion(name, requestedVersion);
+    spinner.succeed(`Found ${name}@${versionInfo.version} (${formatBytes(versionInfo.size)})`);
+  } catch (error) {
+    spinner.fail("Failed to resolve package");
+    if (error instanceof RegistryError) {
+      if (error.code === "NOT_FOUND") {
+        console.log(pc2.yellow(`
+Package "${name}" not found in registry.`));
+        console.log(pc2.gray("\nFor local packages, use a path:"));
+        console.log(pc2.cyan(`  olore install ./vault/packages/${name}/<version>`));
+        console.log("");
+      } else if (error.code === "NETWORK_ERROR" || error.code === "TIMEOUT") {
+        console.log(pc2.red(`
+Network error: ${error.message}`));
+        console.log(pc2.gray("Please check your internet connection and try again."));
+      }
+    } else {
+      console.log(pc2.red(`
+Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    }
+    process.exit(1);
+  }
+  const skillName = `olore-${name}-${versionInfo.version}`;
+  const agents = detectAgents();
+  if (agents.length === 0) {
+    console.log(pc2.yellow("No agents detected. Creating directories anyway."));
+  }
+  const agentPaths = getAgentPaths();
+  if (isWindows) {
+    const downloadSpinner = ora("Downloading package...").start();
+    let tempDir;
+    try {
+      tempDir = await downloadAndExtractToTemp(versionInfo.downloadUrl, versionInfo.integrity);
+      downloadSpinner.succeed("Downloaded and verified");
+    } catch (error) {
+      downloadSpinner.fail("Download failed");
+      if (error instanceof DownloadError) {
+        if (error.code === "CHECKSUM_MISMATCH") {
+          console.log(pc2.red("\nChecksum verification failed!"));
+          console.log(pc2.gray("The downloaded package may be corrupted or tampered with."));
+        } else {
+          console.log(pc2.red(`
+Download error: ${error.message}`));
+        }
+      } else {
+        console.log(pc2.red(`
+Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+      }
+      process.exit(1);
+    }
+    try {
+      const copySpinner = ora("Copying to agent directories...").start();
+      const copied = [];
+      for (const [agent, skillsDir] of Object.entries(agentPaths)) {
+        const targetDir = path5.join(skillsDir, skillName);
+        await fs5.ensureDir(skillsDir);
+        await fs5.remove(targetDir);
+        await fs5.copy(tempDir, targetDir);
+        copied.push(`${pc2.green("\u2713")} ${agent} ${pc2.gray("\u2192")} ${pc2.gray(targetDir)}`);
+      }
+      copySpinner.stop();
+      copied.forEach((line) => console.log(`  ${line}`));
+    } finally {
+      await fs5.remove(path5.dirname(tempDir)).catch(() => {
+      });
+    }
+  } else {
+    const olorePath = getOlorePackagePath(name, versionInfo.version);
+    const downloadSpinner = ora("Downloading package...").start();
+    try {
+      await downloadAndInstall(versionInfo.downloadUrl, olorePath, versionInfo.integrity);
+      downloadSpinner.succeed(`Downloaded to ${pc2.gray(olorePath)}`);
+    } catch (error) {
+      downloadSpinner.fail("Download failed");
+      if (error instanceof DownloadError) {
+        if (error.code === "CHECKSUM_MISMATCH") {
+          console.log(pc2.red("\nChecksum verification failed!"));
+          console.log(pc2.gray("The downloaded package may be corrupted or tampered with."));
+        } else {
+          console.log(pc2.red(`
+Download error: ${error.message}`));
+        }
+      } else {
+        console.log(pc2.red(`
+Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+      }
+      process.exit(1);
+    }
+    const linkSpinner = ora("Creating symlinks...").start();
+    const linked = [];
+    for (const [agent, skillsDir] of Object.entries(agentPaths)) {
+      const targetDir = path5.join(skillsDir, skillName);
+      await fs5.ensureDir(skillsDir);
+      await fs5.remove(targetDir);
+      await linkOrCopy(olorePath, targetDir);
+      linked.push(`${pc2.green("\u2713")} ${agent} ${pc2.gray("\u2192")} ${pc2.gray(targetDir)}`);
+    }
+    linkSpinner.stop();
+    linked.forEach((line) => console.log(`  ${line}`));
+    console.log(pc2.gray(`    \u2514\u2500 all symlinked to ${olorePath}`));
+  }
+  console.log("");
+  console.log(pc2.green("Installation complete!"));
+  console.log("");
+  console.log(pc2.gray("Skill is now available as:"));
+  console.log(pc2.cyan(`  /${skillName}`) + pc2.gray(" (Claude Code)"));
+  console.log(pc2.cyan(`  $${skillName}`) + pc2.gray(" (Codex)"));
+  console.log(pc2.cyan(`  ${skillName}`) + pc2.gray(" (OpenCode)"));
+}
+
+// src/commands/link.ts
+import path6 from "path";
+import fs6 from "fs-extra";
+import ora2 from "ora";
+import pc3 from "picocolors";
+async function link(localPath) {
+  const fullPath = expandPath(localPath);
+  if (!await fs6.pathExists(fullPath)) {
+    throw new Error(`Path not found: ${fullPath}`);
+  }
+  const stat = await fs6.stat(fullPath);
+  if (!stat.isDirectory()) {
+    throw new Error(`Not a directory: ${fullPath}`);
+  }
+  const lockPath = path6.join(fullPath, "olore-lock.json");
+  if (!await fs6.pathExists(lockPath)) {
+    throw new Error(`Missing olore-lock.json in ${fullPath}`);
+  }
+  const skillPath = path6.join(fullPath, "SKILL.md");
+  if (!await fs6.pathExists(skillPath)) {
+    throw new Error(`Missing SKILL.md in ${fullPath}. Run /build-docs first.`);
+  }
+  const lock = await fs6.readJson(lockPath);
+  const packageName = lock.name;
+  const packageVersion = lock.version;
+  if (!packageName) {
+    throw new Error(`Invalid olore-lock.json: missing "name" field`);
+  }
+  if (!packageVersion) {
+    throw new Error(`Invalid olore-lock.json: missing "version" field`);
+  }
+  const skillName = `olore-${packageName}-${packageVersion}`;
+  const skillContent = await fs6.readFile(skillPath, "utf-8");
+  const nameMatch = skillContent.match(/^name:\s*(.+)$/m);
+  const skillMdName = nameMatch ? nameMatch[1].trim() : null;
+  if (skillMdName !== skillName) {
+    console.log(pc3.yellow(`
+Warning: SKILL.md name mismatch`));
+    console.log(pc3.gray(`  Expected: ${skillName}`));
+    console.log(pc3.gray(`  Found:    ${skillMdName || "(none)"}`));
+    console.log(pc3.yellow(`  Updating SKILL.md to fix...`));
+    const updatedContent = skillMdName ? skillContent.replace(/^name:\s*.+$/m, `name: ${skillName}`) : skillContent.replace(/^---\n/, `---
+name: ${skillName}
+`);
+    await fs6.writeFile(skillPath, updatedContent);
+  }
+  console.log(pc3.bold(`
+Linking ${packageName}@${packageVersion}...
+`));
+  const agents = detectAgents();
+  if (agents.length === 0) {
+    console.log(pc3.yellow("No agents detected. Creating directories anyway."));
+  }
+  const agentPaths = getAgentPaths();
+  const spinner = ora2(`${getLinkActionText()}...`).start();
+  const linked = [];
+  for (const [agent, skillsDir] of Object.entries(agentPaths)) {
+    const targetDir = path6.join(skillsDir, skillName);
+    await fs6.ensureDir(skillsDir);
+    await fs6.remove(targetDir);
+    await linkOrCopy(fullPath, targetDir);
+    linked.push(`${pc3.blue("\u26D3")} ${agent} ${pc3.gray("\u2192")} ${pc3.gray(targetDir)}`);
+  }
+  spinner.stop();
+  linked.forEach((line) => console.log(`  ${line}`));
+  console.log(pc3.gray(`    \u2514\u2500 ${getLinkTypeText()} ${fullPath}`));
+  console.log("");
+  console.log(pc3.blue("Link complete!"));
+  console.log("");
+  console.log(pc3.gray("Skill is now available as:"));
+  console.log(pc3.cyan(`  /${skillName}`) + pc3.gray(" (Claude Code)"));
+  console.log(pc3.cyan(`  $${skillName}`) + pc3.gray(" (Codex)"));
+  console.log(pc3.cyan(`  ${skillName}`) + pc3.gray(" (OpenCode)"));
+  console.log("");
+  console.log(pc3.gray(`Development mode: ${getLinkTypeText()} source (bypasses ~/.olore).`));
+  console.log(pc3.gray("On Unix, changes to source are immediately visible."));
+  console.log(pc3.gray("On Windows, re-run link after changes."));
+  console.log(
+    pc3.gray("Use ") + pc3.cyan("olore install") + pc3.gray(" for a stable copy in ~/.olore.")
+  );
+}
+
+// src/commands/list.ts
+import pc4 from "picocolors";
+async function list(options) {
+  const packages = await getInstalledPackages();
+  if (packages.length === 0) {
+    console.log(pc4.yellow("\nI find your lack of skills disturbing.\n"));
+    console.log(pc4.gray("No packages installed."));
+    console.log(`Run ${pc4.cyan("olore install <package>")} to install documentation.`);
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(packages, null, 2));
+    return;
+  }
+  console.log(pc4.bold("\nInstalled packages:\n"));
+  console.log(
+    pc4.gray(
+      "PACKAGE".padEnd(25) + "VERSION".padEnd(12) + "TYPE".padEnd(10) + "FILES".padStart(8) + "SIZE".padStart(12)
+    )
+  );
+  console.log(pc4.gray("-".repeat(67)));
+  for (const pkg of packages) {
+    const typeLabel = pkg.installType === "linked" ? pc4.blue("linked") : pkg.installType;
+    console.log(
+      pkg.name.padEnd(25) + pkg.version.padEnd(12) + typeLabel.padEnd(10) + String(pkg.files).padStart(8) + formatSize(pkg.size).padStart(12)
+    );
+  }
+  console.log(pc4.gray("-".repeat(67)));
+  console.log(pc4.gray(`Total: ${packages.length} packages`));
+  console.log("");
+  console.log(pc4.gray("Types: installed = in ~/.olore, linked = dev symlink, copied = legacy"));
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// src/commands/order66.ts
+import path7 from "path";
+import fs7 from "fs-extra";
+import ora3 from "ora";
+import pc5 from "picocolors";
+async function order66() {
+  console.log(pc5.red("\n\u26A0\uFE0F  Execute Order 66?\n"));
+  console.log(pc5.yellow("This will remove ALL installed documentation packages."));
+  const packages = await getInstalledPackages();
+  if (packages.length === 0) {
+    console.log(pc5.gray("\nNo packages to remove. The Jedi are already gone."));
+    return;
+  }
+  console.log(pc5.gray(`
+Packages to be removed: ${packages.length}`));
+  for (const pkg of packages) {
+    console.log(pc5.gray(`  - ${pkg.name}@${pkg.version}`));
+  }
+  console.log(pc5.red('\n"It will be done, my lord."\n'));
+  const spinner = ora3("Executing Order 66...").start();
+  let removedCount = 0;
+  const agentPaths = getAgentPaths();
+  for (const pkg of packages) {
+    const skillName = `olore-${pkg.name}-${pkg.version}`;
+    for (const [, basePath] of Object.entries(agentPaths)) {
+      const skillPath = path7.join(basePath, skillName);
+      if (await fs7.pathExists(skillPath)) {
+        await fs7.remove(skillPath);
+      }
+    }
+    if (pkg.installType === "installed") {
+      const olorePath = getOlorePackagePath(pkg.name, pkg.version);
+      if (await fs7.pathExists(olorePath)) {
+        await fs7.remove(olorePath);
+      }
+    }
+    removedCount++;
+  }
+  spinner.succeed(`Removed ${removedCount} packages`);
+  console.log(pc5.gray("\nThe Jedi have been eliminated."));
+}
+
+// src/commands/remove.ts
+import path8 from "path";
+import fs8 from "fs-extra";
+import ora4 from "ora";
+import pc6 from "picocolors";
+async function remove(pkg) {
+  console.log(pc6.bold(`
+Removing ${pkg}...
+`));
+  const packages = await getInstalledPackages();
+  let name = pkg;
+  let version2;
+  if (pkg.includes("@")) {
+    [name, version2] = pkg.split("@");
+  }
+  const matches = packages.filter((p) => {
+    if (version2) {
+      return p.name === name && p.version === version2;
+    }
+    return p.name === name;
+  });
+  if (matches.length === 0) {
+    console.error(pc6.red(`Package not found: ${pkg}`));
+    console.log("\nInstalled packages:");
+    for (const p of packages) {
+      console.log(`  ${pc6.cyan(p.name)}@${p.version}`);
+    }
+    process.exit(1);
+  }
+  if (matches.length > 1 && !version2) {
+    console.error(pc6.red(`Multiple versions found for ${name}:`));
+    for (const p of matches) {
+      console.log(`  ${pc6.cyan(p.name)}@${p.version} (${p.installType})`);
+    }
+    console.log(`
+Specify version: ${pc6.cyan(`olore remove ${name}@<version>`)}`);
+    process.exit(1);
+  }
+  const found = matches[0];
+  const skillName = `olore-${found.name}-${found.version}`;
+  const spinner = ora4("Removing package...").start();
+  const removed = [];
+  const agentPaths = getAgentPaths();
+  for (const [agent, basePath] of Object.entries(agentPaths)) {
+    const skillPath = path8.join(basePath, skillName);
+    if (await fs8.pathExists(skillPath)) {
+      await fs8.remove(skillPath);
+      removed.push(`${pc6.green("\u2713")} ${agent}`);
+    }
+  }
+  if (found.installType === "installed") {
+    const olorePath = getOlorePackagePath(found.name, found.version);
+    if (await fs8.pathExists(olorePath)) {
+      await fs8.remove(olorePath);
+      removed.push(`${pc6.green("\u2713")} ~/.olore`);
+    }
+  }
+  spinner.stop();
+  if (removed.length === 0) {
+    console.log(pc6.yellow("No files found to remove."));
+  } else {
+    removed.forEach((line) => console.log(`  ${line}`));
+    console.log("");
+    console.log(pc6.green(`Removed ${found.name}@${found.version}`));
+  }
+}
+
+// src/cli.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var program = new Command();
+program.name("olore").description("Universal documentation for any AI coding agent").version(version).addHelpText("after", `
+${pc7.gray("May the Skill be with you.")}`);
+program.command("init").description("Initialize a documentation package in the current directory").option("-n, --name <name>", "Package name (default: folder name)").option("-v, --version <version>", "Package version (default: latest)").option("-y, --yes", "Skip prompts, use defaults").action(async (options) => {
+  try {
+    await init(options);
+  } catch (error) {
+    console.error(pc7.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+});
+program.command("install <package>").alias("i").description("Install a documentation package from the registry").option("-v, --version <version>", "Install specific version").option("--keep", "Keep previous version active (for migrations)").option("--force", "Force installation").action(async (pkg, options) => {
+  try {
+    await install(pkg, options);
+  } catch (error) {
+    console.error(pc7.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+});
+program.command("link <path>").description("Link a local package for development (creates symlink)").action(async (localPath) => {
+  try {
+    await link(localPath);
+  } catch (error) {
+    console.error(pc7.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+});
+program.command("list").alias("ls").description("List installed documentation packages").option("--json", "Output as JSON").action(async (options) => {
+  try {
+    await list(options);
+  } catch (error) {
+    console.error(pc7.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+});
+program.command("remove <package>").alias("rm").description("Remove an installed documentation package").action(async (pkg) => {
+  try {
+    await remove(pkg);
+  } catch (error) {
+    console.error(pc7.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+});
+program.command("order66").description(false).action(async () => {
+  try {
+    await order66();
+  } catch (error) {
+    console.error(pc7.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+});
+program.parse();

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@olorehq/olore",
+  "version": "0.1.0",
+  "description": "Universal documentation for any AI coding agent",
+  "keywords": [
+    "ai",
+    "documentation",
+    "claude",
+    "codex",
+    "coding-assistant",
+    "context",
+    "llm"
+  ],
+  "license": "AGPL-3.0",
+  "author": "olorehq",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/olorehq/olore.git",
+    "directory": "cli"
+  },
+  "homepage": "https://github.com/olorehq/olore",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "olore": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "build:bin": "bun build src/cli.ts --compile --outfile dist/olore",
+    "build:bin:all": "npm run build:bin:darwin-arm64 && npm run build:bin:darwin-x64 && npm run build:bin:linux-x64 && npm run build:bin:linux-arm64",
+    "build:bin:darwin-arm64": "bun build src/cli.ts --compile --target=bun-darwin-arm64 --outfile dist/olore-darwin-arm64",
+    "build:bin:darwin-x64": "bun build src/cli.ts --compile --target=bun-darwin-x64 --outfile dist/olore-darwin-x64",
+    "build:bin:linux-arm64": "bun build src/cli.ts --compile --target=bun-linux-arm64 --outfile dist/olore-linux-arm64",
+    "build:bin:linux-x64": "bun build src/cli.ts --compile --target=bun-linux-x64 --outfile dist/olore-linux-x64",
+    "dev": "tsup --watch",
+    "format": "prettier --write src/",
+    "format:check": "prettier --check src/",
+    "lint": "eslint src/",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit",
+    "generate-registry": "npx tsx scripts/generate-registry.ts"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "fs-extra": "^11.3.3",
+    "ora": "^9.0.0",
+    "picocolors": "^1.1.1",
+    "tar": "^7.4.3"
+  },
+  "devDependencies": {
+    "@ianvs/prettier-plugin-sort-imports": "^4.7.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.10.7",
+    "prettier": "^3.8.0",
+    "prettier-plugin-packagejson": "^2.5.22",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.8"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}