oris-skills 2.0.0

package/scripts/flow/oris-flow-version-control.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import process from "node:process";
+import { applyOrisFlowVersionControl } from "./oris-gitignore.mjs";
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+function parseArgs(argv) {
+  const options = {
+    repositoryRoot: "",
+    mode: "",
+    dryRun: false,
+  };
+  const readValue = (index, raw) => {
+    if (raw.includes("=")) return [index, raw.slice(raw.indexOf("=") + 1)];
+    if (index + 1 >= argv.length) fail(`Missing value for ${raw}.`);
+    return [index + 1, argv[index + 1]];
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const raw = argv[i];
+    const key = raw.toLowerCase();
+    if (key === "--repository-root" || key.startsWith("--repository-root=")) [i, options.repositoryRoot] = readValue(i, raw);
+    else if (key === "--mode" || key.startsWith("--mode=")) [i, options.mode] = readValue(i, raw);
+    else if (key === "--dry-run") options.dryRun = true;
+    else fail(`Unknown argument: ${raw}`);
+  }
+  return options;
+}
+
+const options = parseArgs(process.argv.slice(2));
+if (!options.mode) fail("Pass --mode commit or --mode gitignore.");
+if (options.mode !== "commit" && options.mode !== "gitignore") {
+  fail(`Unsupported mode '${options.mode}'. Use commit or gitignore.`);
+}
+
+const root = options.repositoryRoot ? path.resolve(options.repositoryRoot) : process.cwd();
+const result = applyOrisFlowVersionControl(root, options.mode, options.dryRun);
+console.log(JSON.stringify({ repositoryRoot: root.replace(/\\/g, "/"), mode: options.mode, ...result }, null, 2));

package/scripts/flow/oris-gitignore.mjs

@@ -0,0 +1,79 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export const ORIS_FLOW_GITIGNORE_ENTRIES = [
+  ".oris-flow/manifest.json",
+  ".oris-flow/maps/",
+];
+
+export const ORIS_FLOW_RUNTIME_GITIGNORE_ENTRY = ".oris-flow/runtime/";
+export const ORIS_LOOP_GITIGNORE_ENTRY = ORIS_FLOW_RUNTIME_GITIGNORE_ENTRY;
+
+function normalizeGitignoreLines(text) {
+  return text.replace(/\r\n/g, "\n").split("\n");
+}
+
+function hasEntry(lines, entry) {
+  const trimmed = entry.trim();
+  return lines.some((line) => {
+    const value = line.trim();
+    if (!value || value.startsWith("#")) return false;
+    return value === trimmed || value.replace(/\/$/, "") === trimmed.replace(/\/$/, "");
+  });
+}
+
+export function readGitignore(repositoryRoot) {
+  const gitignorePath = path.join(repositoryRoot, ".gitignore");
+  if (!fs.existsSync(gitignorePath)) {
+    return { gitignorePath, text: "", lines: [] };
+  }
+  const text = fs.readFileSync(gitignorePath, "utf8");
+  return { gitignorePath, text, lines: normalizeGitignoreLines(text) };
+}
+
+export function ensureGitignoreEntries(repositoryRoot, entries, dryRun = false) {
+  const { gitignorePath, text, lines } = readGitignore(repositoryRoot);
+  const missing = entries.filter((entry) => !hasEntry(lines, entry));
+  if (missing.length === 0) {
+    return { action: "present", path: gitignorePath, entries: [] };
+  }
+  if (dryRun) {
+    return { action: "append", path: gitignorePath, entries: missing };
+  }
+  const next = text.trimEnd();
+  const suffix = missing.map((entry) => entry.trim()).join("\n");
+  fs.writeFileSync(gitignorePath, `${next ? `${next}\n` : ""}${suffix}\n`, "utf8");
+  return { action: next ? "appended" : "created", path: gitignorePath, entries: missing };
+}
+
+export function removeGitignoreEntries(repositoryRoot, entries, dryRun = false) {
+  const { gitignorePath, text, lines } = readGitignore(repositoryRoot);
+  const targets = new Set(entries.map((entry) => entry.trim().replace(/\/$/, "")));
+  const kept = lines.filter((line) => {
+    const value = line.trim();
+    if (!value || value.startsWith("#")) return true;
+    const normalized = value.replace(/\/$/, "");
+    return !targets.has(normalized);
+  });
+  if (kept.length === lines.length) {
+    return { action: "absent", path: gitignorePath, entries: [] };
+  }
+  if (dryRun) {
+    return { action: "remove", path: gitignorePath, entries: [...targets] };
+  }
+  fs.writeFileSync(gitignorePath, `${kept.join("\n").replace(/\n+$/, "")}\n`, "utf8");
+  return { action: "removed", path: gitignorePath, entries: [...targets] };
+}
+
+/**
+ * @param {"commit"|"gitignore"} mode
+ */
+export function applyOrisFlowVersionControl(repositoryRoot, mode, dryRun = false) {
+  if (mode === "gitignore") {
+    return ensureGitignoreEntries(repositoryRoot, ORIS_FLOW_GITIGNORE_ENTRIES, dryRun);
+  }
+  if (mode === "commit") {
+    return removeGitignoreEntries(repositoryRoot, ORIS_FLOW_GITIGNORE_ENTRIES, dryRun);
+  }
+  throw new Error(`Unsupported Oris Flow version control mode '${mode}'. Use commit or gitignore.`);
+}

package/scripts/install/generate-agent-adapters.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+const sourceRoot = path.join(repoRoot, "agents");
+
+function readAgent(filePath) {
+  const text = fs.readFileSync(filePath, "utf8");
+  const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+  if (!match) throw new Error(`Agent file is missing front matter: ${filePath}`);
+  const frontMatter = Object.fromEntries(
+    match[1]
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => {
+        const index = line.indexOf(":");
+        if (index < 0) throw new Error(`Unsupported front matter line in ${filePath}: ${line}`);
+        return [line.slice(0, index).trim(), line.slice(index + 1).trim()];
+      }),
+  );
+  return { frontMatter, body: match[2].trim() };
+}
+
+function writeFile(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${content.trimEnd()}\n`, "utf8");
+}
+
+function renderMarkdownAgent(agent) {
+  return `---
+name: ${agent.frontMatter.name}
+description: ${agent.frontMatter.description}
+readonly: ${agent.frontMatter.readonly ?? "false"}
+---
+
+${agent.body}
+`;
+}
+
+function renderCodexAgent(agent) {
+  const name = JSON.stringify(agent.frontMatter.name);
+  const description = JSON.stringify(agent.frontMatter.description);
+  const instructions = JSON.stringify(agent.body);
+  return `name = ${name}
+description = ${description}
+developer_instructions = ${instructions}
+`;
+}
+
+export function generateAgentAdapters(root = repoRoot) {
+  const agents = fs.readdirSync(sourceRoot)
+    .filter((name) => name.endsWith(".md"))
+    .map((name) => ({ name, ...readAgent(path.join(sourceRoot, name)) }));
+
+  for (const agent of agents) {
+    writeFile(path.join(root, ".cursor", "agents", agent.name), renderMarkdownAgent(agent));
+    writeFile(path.join(root, ".claude", "agents", agent.name), renderMarkdownAgent(agent));
+    writeFile(path.join(root, ".codex", "agents", agent.name.replace(/\.md$/, ".toml")), renderCodexAgent(agent));
+  }
+
+  return agents.map((agent) => agent.frontMatter.name);
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url))) {
+  const rootArg = process.argv.find((arg) => arg.startsWith("--root="));
+  const root = rootArg ? path.resolve(rootArg.slice("--root=".length)) : repoRoot;
+  const generated = generateAgentAdapters(root);
+  console.log(JSON.stringify({ generated }, null, 2));
+}

package/scripts/install/install-user-skills.mjs

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+
+/**
+ * Multi-agent installer.
+ *
+ * One bundle, many agents:
+ * - bundle (scripts + skills + references): ~/.oris/oris-skills
+ * - Cursor skills:      ~/.cursor/skills/<name>/
+ * - Claude Code skills: ~/.claude/skills/<name>/
+ * - Codex prompts:      ~/.codex/prompts/<name>.md (pointer to the bundled SKILL.md)
+ *
+ * Agents are auto-detected from existing home directories; override with
+ * --agents cursor,claude,codex.
+ */
+
+import childProcess from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+const markerName = ".oris-skills-managed.json";
+const installManifestName = ".oris-skills-install.json";
+const nodeDownloadUrl = "https://nodejs.org/en/download";
+const KNOWN_AGENTS = ["cursor", "claude", "codex"];
+
+function fail(message) {
+  throw new Error(message);
+}
+
+function log(message) {
+  console.log(`[oris-skills] ${message}`);
+}
+
+function defaultPaths() {
+  const home = os.homedir();
+  return {
+    bundleRoot: path.join(home, ".oris", "oris-skills"),
+    settingsPath: path.join(home, ".oris", "settings.json"),
+    agentRoots: {
+      cursor: path.join(home, ".cursor"),
+      claude: path.join(home, ".claude"),
+      codex: path.join(home, ".codex"),
+    },
+  };
+}
+
+function parseArgs(argv) {
+  const paths = defaultPaths();
+  const options = {
+    dryRun: false,
+    force: false,
+    agents: [],
+    bundleRoot: paths.bundleRoot,
+    settingsPath: paths.settingsPath,
+    agentRoots: paths.agentRoots,
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const raw = argv[i];
+    const key = raw.toLowerCase();
+    const value = () => {
+      if (raw.includes("=")) return raw.slice(raw.indexOf("=") + 1);
+      if (i + 1 >= argv.length) fail(`Missing value for ${raw}.`);
+      i += 1;
+      return argv[i];
+    };
+    if (key === "--dry-run") options.dryRun = true;
+    else if (key === "--force") options.force = true;
+    else if (key === "--agents" || key.startsWith("--agents=")) {
+      options.agents = value().split(",").map((name) => name.trim().toLowerCase()).filter(Boolean);
+    } else if (key === "--bundle-root" || key.startsWith("--bundle-root=")) options.bundleRoot = value();
+    else if (key === "--settings" || key.startsWith("--settings=")) options.settingsPath = value();
+    else if (key === "--cursor-root" || key.startsWith("--cursor-root=")) options.agentRoots.cursor = value();
+    else if (key === "--claude-root" || key.startsWith("--claude-root=")) options.agentRoots.claude = value();
+    else if (key === "--codex-root" || key.startsWith("--codex-root=")) options.agentRoots.codex = value();
+    else fail(`Unknown argument: ${raw}`);
+  }
+  for (const agent of options.agents) {
+    if (!KNOWN_AGENTS.includes(agent)) fail(`Unknown agent '${agent}'. Known: ${KNOWN_AGENTS.join(", ")}.`);
+  }
+  return options;
+}
+
+function detectAgents(agentRoots) {
+  return KNOWN_AGENTS.filter((agent) => fs.existsSync(agentRoots[agent]));
+}
+
+function openNodeDownload() {
+  try {
+    const command = process.platform === "win32" ? "cmd" : process.platform === "darwin" ? "open" : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", "", nodeDownloadUrl] : [nodeDownloadUrl];
+    childProcess.spawn(command, args, { detached: true, stdio: "ignore" }).unref();
+  } catch {
+    // Best effort only.
+  }
+}
+
+function requireNode() {
+  const major = Number.parseInt(process.versions.node.split(".")[0], 10);
+  if (!Number.isFinite(major) || major < 20) {
+    openNodeDownload();
+    fail(`Node.js 20+ is required: ${nodeDownloadUrl}`);
+  }
+}
+
+function assertInsideHome(target) {
+  const home = path.resolve(os.homedir());
+  const relative = path.relative(home, path.resolve(target));
+  if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) {
+    fail(`Refusing to write outside ${home}: ${target}`);
+  }
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function copy(source, target) {
+  fs.cpSync(source, target, { recursive: true, force: true, errorOnExist: false });
+}
+
+function skillName(skillDir) {
+  const text = fs.readFileSync(path.join(skillDir, "SKILL.md"), "utf8");
+  const match = text.match(/^---\r?\n[\s\S]*?^name:\s*(.+?)\s*$/m);
+  if (!match) fail(`Skill is missing front matter name: ${skillDir}`);
+  return match[1].trim().replace(/^["']|["']$/g, "");
+}
+
+function skillDescription(skillDir) {
+  const text = fs.readFileSync(path.join(skillDir, "SKILL.md"), "utf8");
+  const match = text.match(/^---\r?\n[\s\S]*?^description:\s*(.+?)\s*$/m);
+  return match ? match[1].trim() : "";
+}
+
+function manifestSkills(manifest, repoRoot) {
+  if (!Array.isArray(manifest.skills)) fail("Plugin manifest must declare skills as an array.");
+  return manifest.skills.map((entry) => {
+    const relativePath = String(entry).replace(/^[.\\/]+/, "");
+    const sourceDir = path.join(repoRoot, relativePath);
+    if (!fs.existsSync(path.join(sourceDir, "SKILL.md"))) fail(`Missing skill: ${relativePath}`);
+    return { name: skillName(sourceDir), relativePath, sourceDir };
+  });
+}
+
+function defaultSettings() {
+  return {
+    version: 1,
+    orisFlow: {
+      uiLanguage: "en",
+      artifactLanguage: "en",
+    },
+    defaultProfiles: {
+      testing: "default",
+    },
+    profiles: {
+      default: {
+        environment: "local",
+        values: {},
+        secrets: {},
+        flags: {
+          allowDataMutation: false,
+        },
+      },
+    },
+  };
+}
+
+function installSkillDirs(skills, skillsRoot, manifest, bundleRoot, options) {
+  fs.mkdirSync(skillsRoot, { recursive: true });
+  for (const skill of skills) {
+    const target = path.join(skillsRoot, skill.name);
+    if (fs.existsSync(target) && !fs.existsSync(path.join(target, markerName)) && !options.force) {
+      fail(`Skill exists and is not managed by Oris: ${target}`);
+    }
+    fs.rmSync(target, { recursive: true, force: true });
+    copy(skill.sourceDir, target);
+    writeJson(path.join(target, markerName), {
+      package: manifest.name,
+      version: manifest.version,
+      sourcePath: skill.relativePath,
+      bundleRoot,
+      installedAt: new Date().toISOString(),
+    });
+  }
+}
+
+function installCodexPrompts(skills, codexRoot, bundleRoot) {
+  const promptsRoot = path.join(codexRoot, "prompts");
+  fs.mkdirSync(promptsRoot, { recursive: true });
+  for (const skill of skills) {
+    const bundledSkill = path.join(bundleRoot, skill.relativePath, "SKILL.md").replace(/\\/g, "/");
+    const description = skillDescription(skill.sourceDir);
+    fs.writeFileSync(path.join(promptsRoot, `${skill.name}.md`), `<!-- ${markerName} -->
+Read the Oris skill file at \`${bundledSkill}\` and follow it exactly.
+${description ? `Skill purpose: ${description}\n` : ""}
+User request: $ARGUMENTS
+`, "utf8");
+  }
+}
+
+function main() {
+  requireNode();
+  const options = parseArgs(process.argv.slice(2));
+  const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+  const manifest = readJson(path.join(repoRoot, ".cursor-plugin", "plugin.json"));
+  const skills = manifestSkills(manifest, repoRoot);
+  const agents = options.agents.length > 0 ? options.agents : detectAgents(options.agentRoots);
+  if (agents.length === 0) {
+    fail("No agent detected (~/.cursor, ~/.claude, ~/.codex). Pass --agents cursor,claude,codex explicitly.");
+  }
+
+  assertInsideHome(options.bundleRoot);
+  assertInsideHome(options.settingsPath);
+  for (const agent of agents) assertInsideHome(options.agentRoots[agent]);
+
+  if (options.dryRun) {
+    log(`Would install ${skills.length} skills from ${repoRoot}`);
+    log(`Would write bundle: ${options.bundleRoot}`);
+    for (const agent of agents) {
+      if (agent === "codex") log(`Would write Codex prompts: ${path.join(options.agentRoots.codex, "prompts")}`);
+      else log(`Would write ${agent} skills: ${path.join(options.agentRoots[agent], "skills")}`);
+    }
+    log(`Would create settings if missing: ${options.settingsPath}`);
+    return;
+  }
+
+  if (fs.existsSync(options.bundleRoot) && !options.force) {
+    fail(`Bundle already exists. Re-run with --force: ${options.bundleRoot}`);
+  }
+
+  fs.rmSync(options.bundleRoot, { recursive: true, force: true });
+  fs.mkdirSync(options.bundleRoot, { recursive: true });
+  for (const item of [".cursor-plugin", "skills", "references", "agents", "scripts", "docs", "package.json", "README.md", "LICENSE"]) {
+    const source = path.join(repoRoot, item);
+    if (fs.existsSync(source)) copy(source, path.join(options.bundleRoot, item));
+  }
+
+  for (const agent of agents) {
+    if (agent === "codex") {
+      installCodexPrompts(skills, options.agentRoots.codex, options.bundleRoot);
+      log(`Installed ${skills.length} Codex prompts`);
+    } else {
+      installSkillDirs(skills, path.join(options.agentRoots[agent], "skills"), manifest, options.bundleRoot, options);
+      log(`Installed ${skills.length} ${agent} skills`);
+    }
+  }
+
+  if (!fs.existsSync(options.settingsPath)) writeJson(options.settingsPath, defaultSettings());
+  writeJson(path.join(options.bundleRoot, installManifestName), {
+    package: manifest.name,
+    version: manifest.version,
+    agents,
+    skills: skills.map((skill) => skill.name),
+    installedAt: new Date().toISOString(),
+  });
+  log(`Done for agents: ${agents.join(", ")}. Reload your agent environment.`);
+  log("Next: type /oris-flow in your agent chat, or try the loop demo: oris-skills loop demo");
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(`[oris-skills] ERROR ${error.message}`);
+  process.exit(1);
+}

package/scripts/install/uninstall-user-skills.mjs

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+
+/** Multi-agent uninstaller: removes Oris-owned assets for Cursor, Claude Code, and Codex. */
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+const markerName = ".oris-skills-managed.json";
+const installManifestName = ".oris-skills-install.json";
+
+function fail(message) {
+  throw new Error(message);
+}
+
+function log(message) {
+  console.log(`[oris-skills] ${message}`);
+}
+
+function parseArgs(argv) {
+  const home = os.homedir();
+  const options = {
+    dryRun: false,
+    bundleRoot: path.join(home, ".oris", "oris-skills"),
+    settingsPath: path.join(home, ".oris", "settings.json"),
+    cursorRoot: path.join(home, ".cursor"),
+    claudeRoot: path.join(home, ".claude"),
+    codexRoot: path.join(home, ".codex"),
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const raw = argv[i];
+    const key = raw.toLowerCase();
+    const value = () => {
+      if (raw.includes("=")) return raw.slice(raw.indexOf("=") + 1);
+      if (i + 1 >= argv.length) fail(`Missing value for ${raw}.`);
+      i += 1;
+      return argv[i];
+    };
+    if (key === "--dry-run") options.dryRun = true;
+    else if (key === "--bundle-root" || key.startsWith("--bundle-root=")) options.bundleRoot = value();
+    else if (key === "--settings" || key.startsWith("--settings=")) options.settingsPath = value();
+    else if (key === "--cursor-root" || key.startsWith("--cursor-root=")) options.cursorRoot = value();
+    else if (key === "--claude-root" || key.startsWith("--claude-root=")) options.claudeRoot = value();
+    else if (key === "--codex-root" || key.startsWith("--codex-root=")) options.codexRoot = value();
+    else fail(`Unknown argument: ${raw}`);
+  }
+  return options;
+}
+
+function assertInsideHome(target) {
+  const home = path.resolve(os.homedir());
+  const relative = path.relative(home, path.resolve(target));
+  if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) {
+    fail(`Refusing to remove outside ${home}: ${target}`);
+  }
+}
+
+function safeOrisPath(target) {
+  const name = path.basename(target).toLowerCase();
+  return name.includes("oris") || name.includes("cursor-plugin-install-backups");
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function managedSkillDirs(skillsRoot) {
+  if (!fs.existsSync(skillsRoot)) return [];
+  return fs.readdirSync(skillsRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(skillsRoot, entry.name))
+    .filter((skillDir) => {
+      const markerPath = path.join(skillDir, markerName);
+      if (fs.existsSync(markerPath)) return true;
+      return path.basename(skillDir).toLowerCase().startsWith("oris-");
+    });
+}
+
+function managedCodexPrompts(codexRoot) {
+  const promptsRoot = path.join(codexRoot, "prompts");
+  if (!fs.existsSync(promptsRoot)) return [];
+  return fs.readdirSync(promptsRoot, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && entry.name.toLowerCase().startsWith("oris-") && entry.name.endsWith(".md"))
+    .map((entry) => path.join(promptsRoot, entry.name));
+}
+
+function legacyOrisPaths(options) {
+  return [
+    path.join(options.cursorRoot, "oris-skills"),
+    path.join(options.cursorRoot, "oris-flow"),
+    path.join(options.cursorRoot, "oris-loop"),
+    path.join(options.cursorRoot, "oris-skills.settings.json"),
+    path.join(options.cursorRoot, ".cursor-plugin-install-backups"),
+    path.join(options.cursorRoot, "plugins", "oris-skills"),
+    options.settingsPath,
+  ];
+}
+
+function plannedRemovals(options) {
+  const paths = new Set([
+    options.bundleRoot,
+    ...managedSkillDirs(path.join(options.cursorRoot, "skills")),
+    ...managedSkillDirs(path.join(options.claudeRoot, "skills")),
+    ...managedCodexPrompts(options.codexRoot),
+    ...legacyOrisPaths(options),
+  ]);
+  return [...paths].map((target) => path.resolve(target)).filter(safeOrisPath).sort();
+}
+
+function removeOrisMcpServers(userMcpPath, dryRun) {
+  if (!fs.existsSync(userMcpPath)) return { changed: false, path: userMcpPath };
+  const mcp = readJson(userMcpPath);
+  const servers = mcp.mcpServers ?? {};
+  const nextServers = Object.fromEntries(
+    Object.entries(servers).filter(([name]) => !name.toLowerCase().includes("oris")),
+  );
+  const changed = Object.keys(nextServers).length !== Object.keys(servers).length;
+  if (changed && !dryRun) {
+    fs.writeFileSync(userMcpPath, `${JSON.stringify({ ...mcp, mcpServers: nextServers }, null, 2)}\n`, "utf8");
+  }
+  return { changed, path: userMcpPath };
+}
+
+export function uninstallUserSkills(rawArgs = []) {
+  const options = parseArgs(rawArgs);
+  for (const target of [options.bundleRoot, options.settingsPath, options.cursorRoot, options.claudeRoot, options.codexRoot]) {
+    assertInsideHome(target);
+  }
+
+  const removals = plannedRemovals(options);
+  log(options.dryRun ? "Dry run uninstall plan:" : "Uninstalling Oris-owned assets:");
+  for (const target of removals) log(`${options.dryRun ? "Would remove" : "Remove"} ${target}`);
+
+  // Legacy cleanup: older releases merged an Oris MCP server into Cursor's user config.
+  const mcpResult = removeOrisMcpServers(path.join(options.cursorRoot, "mcp.json"), options.dryRun);
+  if (mcpResult.changed) log(`${options.dryRun ? "Would update" : "Updated"} ${mcpResult.path}`);
+
+  if (!options.dryRun) {
+    for (const target of removals) {
+      if (!safeOrisPath(target)) fail(`Refusing non-Oris path: ${target}`);
+      fs.rmSync(target, { recursive: true, force: true });
+    }
+  }
+
+  return {
+    dryRun: options.dryRun,
+    removals,
+    mcpChanged: mcpResult.changed,
+  };
+}
+
+if (path.resolve(fileURLToPath(import.meta.url)) === path.resolve(process.argv[1])) {
+  try {
+    uninstallUserSkills(process.argv.slice(2));
+  } catch (error) {
+    console.error(`[oris-skills] ERROR ${error.message}`);
+    process.exit(1);
+  }
+}
+
+export { installManifestName, markerName };