nymor 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mustafakmelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,237 @@
+```
+███╗   ██╗██╗   ██╗███╗   ███╗ ██████╗ ██████╗
+████╗  ██║╚██╗ ██╔╝████╗ ████║██╔═══██╗██╔══██╗
+██╔██╗ ██║ ╚████╔╝ ██╔████╔██║██║   ██║██████╔╝
+██║╚██╗██║  ╚██╔╝  ██║╚██╔╝██║██║   ██║██╔══██╗
+██║ ╚████║   ██║   ██║ ╚═╝ ██║╚██████╔╝██║  ██║
+╚═╝  ╚═══╝   ╚═╝   ╚═╝     ╚═╝ ╚═════╝ ╚═╝  ╚═╝
+```
+
+# Nymor
+
+<p align="center">
+  <strong>Teach your repo what your agents keep forgetting.</strong>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/nymor"><img src="https://img.shields.io/npm/v/nymor?color=blue&label=npm" alt="npm version" /></a>
+  <a href="https://github.com/mustafakmelli/nymor/blob/main/LICENSE"><img src="https://img.shields.io/github/license/mustafakmelli/nymor?color=black" alt="license" /></a>
+  <img src="https://img.shields.io/badge/zero-network_calls-green" alt="zero network" />
+  <img src="https://img.shields.io/badge/agents-10_supported-orange" alt="agents" />
+</p>
+
+---
+
+You correct your agent. It forgets.  
+You correct it again. It forgets again.  
+You write the rule in a comment. The next chat starts fresh.
+
+**Nymor stops that loop.**
+
+When a rule is worth keeping, `/nymor-learn` captures it as a skill — committed to your repo, compiled into every agent surface, loaded in every future chat. The agent stops forgetting because the memory lives in the code.
+
+---
+
+## How it feels
+
+```
+You:    "We don't use API routes here. Always use Server Actions."
+Agent:  "Got it. This looks like a durable repo rule —
+         want me to capture it with /nymor-learn?"
+You:    /nymor-learn "Use Server Actions for mutations, not API routes"
+Agent:  Writing .nymor/skills/server-actions-only/SKILL.md ...
+        Updating nymor.json ...
+        Running nymor compile ...
+        ✓ Skill saved and compiled to Claude, Cursor, Copilot, Kiro
+```
+
+Next chat. Same rule. Already known.
+
+---
+
+## Install
+
+```sh
+npm install -g nymor
+```
+
+Or run without installing:
+
+```sh
+npx nymor init
+```
+
+---
+
+## Quick start
+
+```sh
+# Initialize repo memory and agent guidance
+nymor init
+
+# Then inside your agent (Cursor, Claude, Copilot, Kiro):
+/nymor-learn "Use Server Actions for mutations, not API routes"
+
+# See what your repo has learned
+nymor list
+
+# Recompile after manual edits
+nymor compile
+```
+
+---
+
+## The only workflow that matters
+
+```
+Correct agent  ──→  /nymor-learn  ──→  .nymor/skills/<id>/SKILL.md
+                                              │
+                          ┌───────────────────┼───────────────────┐
+                          ↓                   ↓                   ↓
+                    .claude/skills/     .cursor/rules/    .github/instructions/
+                    CLAUDE.md           nymor.mdc         nymor-bootstrap.md
+                          ↓                   ↓                   ↓
+                    git commit ──────── git diff ──────── open PR
+```
+
+The agent writes the skill. Nymor compiles it. Git owns the history. Your team reviews it like any other change.
+
+---
+
+## Supported agents
+
+| Agent                                                  | Output                                         |
+| ------------------------------------------------------ | ---------------------------------------------- |
+| Claude Code                                            | `.claude/skills/`, `CLAUDE.md`                 |
+| Cursor                                                 | `.cursor/rules/nymor-*.mdc`                    |
+| GitHub Copilot                                         | `.github/instructions/nymor-*.instructions.md`, `.github/prompts/nymor-learn.prompt.md` |
+| Kiro                                                   | `.kiro/steering/nymor-*.md`                    |
+| Codex, OpenCode, Aider, Goose, Zed, Warp, Devin, Junie | `AGENTS.md`                                    |
+| Gemini CLI                                             | `GEMINI.md`                                    |
+| Windsurf                                               | `.windsurf/rules/nymor.md`                     |
+| Goose (native)                                         | `.goose/skills/`                               |
+| OpenCode (native)                                      | `.opencode/skill/`                             |
+
+---
+
+## Skill format
+
+Skills are plain Markdown. Human-readable, diffable, reviewable in a PR.
+
+```md
+---
+name: Server Actions Only
+description: Use this when changing application mutations.
+globs:
+  - "app/**/*.ts"
+  - "app/**/*.tsx"
+alwaysApply: false
+---
+
+# Skill: Server Actions Only
+
+## Rule
+
+Use Server Actions for mutations. Do not create API routes for app mutations.
+
+## Why
+
+Keeps mutation logic close to the UI and preserves the repo's auth pattern.
+
+## Example
+
+// WRONG
+export async function POST(req: Request) { ... } // app/api/users/route.ts
+
+// CORRECT
+'use server'
+export async function updateUser(data: UserData) { ... } // app/users/actions.ts
+```
+
+---
+
+## Commands
+
+```sh
+nymor init      # initialize repo memory, write /nymor-learn to all agents
+nymor compile   # regenerate indexes and all agent outputs
+nymor list      # list active repo skills
+nymor doctor    # check manifest, globs, and generated outputs
+nymor validate  # validate skill file structure
+```
+
+---
+
+## What Nymor does not do
+
+- **No central catalog.** Skills are yours. They live in your repo. There is nothing to install from the internet.
+- **No LLM calls.** Nymor compiles and validates. The agent writes the skill. You review it.
+- **No magic.** Every output is a plain file you can read, edit, delete, and commit.
+
+---
+
+## `nymor.json`
+
+```json
+{
+  "version": "1",
+  "agents": ["claude", "cursor", "copilot", "kiro", "agents-md"],
+  "local": ["server-actions-only", "commit-conventions"]
+}
+```
+
+---
+
+## Generated files
+
+```
+.nymor/
+  skills/
+    server-actions-only/
+      SKILL.md
+  index.md
+  index.json
+nymor.json
+
+CLAUDE.md                                          ← Claude bootstrap
+.claude/commands/nymor-learn.md                    ← Claude slash command
+.claude/skills/<id>/SKILL.md                       ← Claude native skills
+
+.cursor/rules/nymor.mdc                            ← Cursor bootstrap
+.cursor/rules/nymor-<id>.mdc                       ← Cursor per-skill
+.cursor/commands/nymor-learn.md                    ← Cursor slash command
+
+.github/instructions/nymor-bootstrap.instructions.md
+.github/instructions/nymor-<id>.instructions.md
+.github/prompts/nymor-learn.prompt.md                   ← Copilot slash command
+
+.kiro/steering/nymor.md
+.kiro/steering/nymor-<id>.md
+
+AGENTS.md                                          ← Codex, Aider, Goose, etc.
+GEMINI.md
+.windsurf/rules/nymor.md
+.goose/skills/<id>/SKILL.md
+.opencode/skill/<id>/SKILL.md
+```
+
+---
+
+## Development
+
+```sh
+npm run build
+npm test
+```
+
+---
+
+## Philosophy
+
+> The agent is smart. Your repo is the memory.
+
+Skills are not configuration. They are the accumulated knowledge of how your team works — decisions made, mistakes corrected, patterns established. Nymor makes that knowledge durable, reviewable, and portable across every agent your team uses.
+
+Every `/nymor-learn` is a conversation turned into institutional memory.
+
+Made for teams who want their agents to actually know how they work.

package/dist/agents/targets.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_AGENT_TARGETS = exports.AGENT_TARGETS = void 0;
+exports.getAgentTargetDefinition = getAgentTargetDefinition;
+exports.isAgentTarget = isAgentTarget;
+const path_1 = __importDefault(require("path"));
+exports.AGENT_TARGETS = [
+    {
+        id: "claude",
+        label: "Claude Code",
+        short: "Claude",
+        description: "Claude skills, CLAUDE.md bootstrap, and /nymor-learn command",
+        detectPaths: [".claude", "CLAUDE.md"],
+        kind: "claude",
+        bootstrapFile: "CLAUDE.md",
+        commandFile: path_1.default.join(".claude", "commands", "nymor-learn.md")
+    },
+    {
+        id: "cursor",
+        label: "Cursor",
+        short: "Cursor",
+        description: "Cursor rules and /nymor-learn command",
+        detectPaths: [".cursor"],
+        kind: "cursor",
+        bootstrapFile: path_1.default.join(".cursor", "rules", "nymor.mdc"),
+        commandFile: path_1.default.join(".cursor", "commands", "nymor-learn.md")
+    },
+    {
+        id: "copilot",
+        label: "GitHub Copilot",
+        short: "Copilot",
+        description: "GitHub Copilot instructions and /nymor-learn prompt",
+        detectPaths: [
+            path_1.default.join(".github", "copilot-instructions.md"),
+            path_1.default.join(".github", "instructions"),
+            path_1.default.join(".github", "prompts")
+        ],
+        kind: "copilot",
+        bootstrapFile: path_1.default.join(".github", "instructions", "nymor-bootstrap.instructions.md"),
+        commandFile: path_1.default.join(".github", "prompts", "nymor-learn.prompt.md")
+    },
+    {
+        id: "kiro",
+        label: "Kiro",
+        short: "Kiro",
+        description: "Kiro steering files",
+        detectPaths: [".kiro"],
+        kind: "kiro",
+        bootstrapFile: path_1.default.join(".kiro", "steering", "nymor.md")
+    },
+    {
+        id: "agents-md",
+        label: "AGENTS.md",
+        short: "AGENTS.md",
+        description: "Shared AGENTS.md for Codex, OpenCode, Aider, Goose, Zed, Warp, Devin, and Junie",
+        detectPaths: ["AGENTS.md", ".codex", ".aider.conf.yml", ".zed", ".warp", ".junie", ".goose", ".opencode"],
+        kind: "shared-md",
+        bootstrapFile: "AGENTS.md",
+        sharedConsumers: ["Codex", "OpenCode", "Aider", "Goose", "Zed", "Warp", "Devin", "Junie"]
+    },
+    {
+        id: "gemini",
+        label: "Gemini CLI",
+        short: "Gemini",
+        description: "GEMINI.md managed block",
+        detectPaths: ["GEMINI.md", ".gemini"],
+        kind: "gemini",
+        bootstrapFile: "GEMINI.md"
+    },
+    {
+        id: "windsurf",
+        label: "Windsurf",
+        short: "Windsurf",
+        description: "Windsurf project rule file",
+        detectPaths: [".windsurf", ".windsurfrules"],
+        kind: "windsurf",
+        bootstrapFile: path_1.default.join(".windsurf", "rules", "nymor.md")
+    },
+    {
+        id: "goose",
+        label: "Goose",
+        short: "Goose",
+        description: "Goose native skills",
+        detectPaths: [".goose"],
+        kind: "native-skills",
+        nativeSkillDir: path_1.default.join(".goose", "skills")
+    },
+    {
+        id: "opencode",
+        label: "OpenCode",
+        short: "OpenCode",
+        description: "OpenCode native skills",
+        detectPaths: [".opencode", "opencode.json"],
+        kind: "native-skills",
+        nativeSkillDir: path_1.default.join(".opencode", "skill")
+    }
+];
+exports.DEFAULT_AGENT_TARGETS = exports.AGENT_TARGETS.map((target) => target.id);
+function getAgentTargetDefinition(id) {
+    const target = exports.AGENT_TARGETS.find((item) => item.id === id);
+    if (!target) {
+        throw new Error(`Unknown agent target: ${id}`);
+    }
+    return target;
+}
+function isAgentTarget(value) {
+    return exports.AGENT_TARGETS.some((target) => target.id === value);
+}

package/dist/commands/add.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCommand = addCommand;
+exports.installRegistrySkill = installRegistrySkill;
+exports.parseRegistrySkill = parseRegistrySkill;
+exports.createEmptyLockfile = createEmptyLockfile;
+exports.computeTarballIntegrity = computeTarballIntegrity;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const compile_1 = require("./compile");
+const client_1 = require("../registry/client");
+const cache_1 = require("../registry/cache");
+const resolver_1 = require("../registry/resolver");
+const manifest_1 = require("../utils/manifest");
+const paths_1 = require("../utils/paths");
+const INDEX_TTL_MS = 60 * 60 * 1000;
+async function addCommand(skill, options = {}) {
+    const projectRoot = process.cwd();
+    const parsed = parseRegistrySkill(skill);
+    const manifest = await (0, manifest_1.readManifest)(projectRoot);
+    if (manifest.skills[parsed.packageName]) {
+        console.log(picocolors_1.default.yellow(`Skill ${parsed.packageName} is already in cicada.json; reinstalling.`));
+    }
+    const requestedRange = options.version ?? "latest";
+    const result = await installRegistrySkill(projectRoot, parsed, requestedRange, Boolean(options.offline));
+    manifest.skills[parsed.packageName] = requestedRange;
+    await (0, manifest_1.writeManifest)(projectRoot, manifest);
+    const lockfile = (await (0, manifest_1.readLockfile)(projectRoot)) ?? createEmptyLockfile();
+    lockfile.skills[parsed.packageName] = {
+        version: result.version,
+        integrity: result.integrity,
+        resolved: result.resolved
+    };
+    await (0, manifest_1.writeLockfile)(projectRoot, lockfile);
+    await (0, compile_1.compileCommand)();
+    console.log("");
+    console.log(`${picocolors_1.default.green("✓")} Installed ${result.packageName}@${result.version}`);
+    console.log(`  ${result.destinationDir}`);
+}
+async function installRegistrySkill(projectRoot, parsed, range, offline) {
+    const index = await getSkillIndex(parsed, offline);
+    const version = (0, resolver_1.resolveVersion)(range, Object.keys(index.versions));
+    const registryVersion = index.versions[version];
+    if (!registryVersion) {
+        throw new Error(`Registry index for ${parsed.packageName} does not include ${version}`);
+    }
+    const { tarball, integrity } = await getTarball(parsed, version, registryVersion.integrity, offline);
+    const destinationDir = path_1.default.join((0, paths_1.getSkillsDir)(projectRoot), parsed.folderName);
+    await fs_extra_1.default.emptyDir(destinationDir);
+    await (0, client_1.extractSkillTarball)(tarball, destinationDir);
+    const skillPath = path_1.default.join(destinationDir, "SKILL.md");
+    if (!(await fs_extra_1.default.pathExists(skillPath))) {
+        throw new Error(`Installed tarball for ${parsed.packageName}@${version} did not contain SKILL.md`);
+    }
+    return {
+        packageName: parsed.packageName,
+        version,
+        integrity,
+        resolved: (0, client_1.getSkillTarballUrl)(parsed.scope, parsed.name, version),
+        destinationDir
+    };
+}
+function parseRegistrySkill(value) {
+    const match = /^(@[^/\s]+)\/([^/\s]+)$/.exec(value);
+    if (!match) {
+        throw new Error(`Invalid skill "${value}". Expected a scoped package like @cicada/commit-conventions.`);
+    }
+    const [, scope, name] = match;
+    return {
+        packageName: `${scope}/${name}`,
+        scope,
+        name,
+        folderName: `${scope}__${name}`
+    };
+}
+function createEmptyLockfile() {
+    return {
+        lockfileVersion: 1,
+        skills: {}
+    };
+}
+function computeTarballIntegrity(tarball) {
+    return `sha256-${crypto_1.default.createHash("sha256").update(tarball).digest("base64")}`;
+}
+async function getSkillIndex(parsed, offline) {
+    const cacheKey = parsed.folderName;
+    const cached = await (0, cache_1.getCachedIndex)(cacheKey, offline ? Number.POSITIVE_INFINITY : INDEX_TTL_MS);
+    if (cached) {
+        return cached;
+    }
+    if (offline) {
+        throw new Error(`No cached registry index for ${parsed.packageName}; cannot add in offline mode.`);
+    }
+    const index = await (0, client_1.fetchSkillIndex)(parsed.scope, parsed.name);
+    await (0, cache_1.putCachedIndex)(cacheKey, index);
+    return index;
+}
+async function getTarball(parsed, version, expectedIntegrity, offline) {
+    const cached = await (0, cache_1.getCachedTarball)(parsed.scope, parsed.name, version);
+    if (cached) {
+        const cachedIntegrity = computeTarballIntegrity(cached);
+        if (cachedIntegrity !== expectedIntegrity) {
+            throw new Error(`Cached tarball integrity mismatch for ${parsed.packageName}@${version}: expected ${expectedIntegrity}, got ${cachedIntegrity}`);
+        }
+        return { tarball: cached, integrity: cachedIntegrity };
+    }
+    if (offline) {
+        throw new Error(`No cached tarball for ${parsed.packageName}@${version}; cannot add in offline mode.`);
+    }
+    const fetched = await (0, client_1.fetchSkillTarball)(parsed.scope, parsed.name, version);
+    if (fetched.integrity !== expectedIntegrity) {
+        throw new Error(`Registry integrity mismatch for ${parsed.packageName}@${version}: index has ${expectedIntegrity}, integrity.txt has ${fetched.integrity}`);
+    }
+    await (0, cache_1.putCachedTarball)(parsed.scope, parsed.name, version, fetched.tarball, fetched.integrity);
+    return fetched;
+}

package/dist/commands/compile.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileCommand = compileCommand;
+exports.planCompileOutputs = planCompileOutputs;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const targets_1 = require("../agents/targets");
+const copilot_1 = require("../compiler/copilot");
+const cursor_1 = require("../compiler/cursor");
+const kiro_1 = require("../compiler/kiro");
+const block_1 = require("../compiler/block");
+const bootstrap_1 = require("../templates/bootstrap");
+const skills_1 = require("../utils/skills");
+const manifest_1 = require("../utils/manifest");
+const paths_1 = require("../utils/paths");
+async function compileCommand() {
+    const projectRoot = process.cwd();
+    const skillsDir = (0, paths_1.getSkillsDir)(projectRoot);
+    if (!(await fs_extra_1.default.pathExists(skillsDir))) {
+        console.log("No skills found. Run nymor init first.");
+        process.exitCode = 1;
+        return;
+    }
+    const skills = await (0, skills_1.loadSkills)(skillsDir);
+    const { markdown, json } = (0, skills_1.buildSkillIndex)(skills);
+    await fs_extra_1.default.ensureDir((0, paths_1.getNymorDir)(projectRoot));
+    await fs_extra_1.default.writeFile((0, paths_1.getIndexMarkdownPath)(projectRoot), markdown, "utf8");
+    await fs_extra_1.default.writeFile((0, paths_1.getIndexJsonPath)(projectRoot), json, "utf8");
+    const manifest = await (0, manifest_1.readManifest)(projectRoot);
+    const agentSet = new Set(manifest.agents);
+    for (const target of targets_1.AGENT_TARGETS) {
+        if (agentSet.has(target.id)) {
+            await writeTargetOutputs(projectRoot, target, skills);
+        }
+    }
+    console.log(`Compiled ${skills.length} skills.`);
+}
+async function planCompileOutputs(projectRoot) {
+    const skillsDir = (0, paths_1.getSkillsDir)(projectRoot);
+    const skills = await (0, skills_1.loadSkills)(skillsDir);
+    const { markdown, json } = (0, skills_1.buildSkillIndex)(skills);
+    const manifest = await (0, manifest_1.readManifest)(projectRoot);
+    const agentSet = new Set(manifest.agents);
+    const files = [
+        textFile((0, paths_1.getIndexMarkdownPath)(projectRoot), markdown),
+        textFile((0, paths_1.getIndexJsonPath)(projectRoot), json)
+    ];
+    for (const target of targets_1.AGENT_TARGETS) {
+        if (agentSet.has(target.id)) {
+            files.push(...(await planTargetOutputs(projectRoot, target, skills)));
+        }
+    }
+    return files;
+}
+async function writeTargetOutputs(projectRoot, target, skills) {
+    for (const file of await planTargetOutputs(projectRoot, target, skills)) {
+        await fs_extra_1.default.ensureDir(path_1.default.dirname(file.path));
+        await fs_extra_1.default.writeFile(file.path, file.content);
+    }
+}
+async function planTargetOutputs(projectRoot, target, skills) {
+    const files = [];
+    if (target.bootstrapFile) {
+        files.push(await planBootstrap(projectRoot, target, skills));
+    }
+    if (target.commandFile) {
+        files.push(textFile(path_1.default.join(projectRoot, target.commandFile), `${(0, bootstrap_1.renderLearnCommand)(target)}\n`));
+    }
+    switch (target.kind) {
+        case "claude":
+            files.push(...(await planClaudeOutputs(skills, projectRoot)));
+            break;
+        case "cursor":
+            for (const skill of skills) {
+                files.push(textFile(path_1.default.join(projectRoot, ".cursor", "rules", `nymor-${skill.id}.mdc`), (0, cursor_1.renderCursorRule)(skill)));
+            }
+            break;
+        case "copilot":
+            for (const skill of skills) {
+                files.push(textFile(path_1.default.join(projectRoot, ".github", "instructions", `nymor-${skill.id}.instructions.md`), (0, copilot_1.renderCopilotInstructions)(skill)));
+            }
+            break;
+        case "kiro":
+            for (const skill of skills) {
+                files.push(textFile(path_1.default.join(projectRoot, ".kiro", "steering", `nymor-${skill.id}.md`), (0, kiro_1.renderKiroSteering)(skill)));
+            }
+            break;
+        case "native-skills":
+            if (target.nativeSkillDir) {
+                files.push(...(await planNativeSkillOutputs(projectRoot, target, skills)));
+            }
+            break;
+        case "shared-md":
+        case "gemini":
+        case "windsurf":
+            break;
+    }
+    return files;
+}
+async function planBootstrap(projectRoot, target, skills) {
+    const targetPath = path_1.default.join(projectRoot, target.bootstrapFile);
+    const content = (0, bootstrap_1.renderBootstrap)(target, skills);
+    if (target.id === "claude" || target.id === "agents-md" || target.id === "gemini") {
+        const existing = (await fs_extra_1.default.pathExists(targetPath)) ? await fs_extra_1.default.readFile(targetPath, "utf8") : null;
+        return textFile(targetPath, (0, block_1.upsertManagedBlock)(existing, content));
+    }
+    return textFile(targetPath, `${content.trimEnd()}\n`);
+}
+async function planClaudeOutputs(skills, projectRoot) {
+    const outputRoot = path_1.default.join(projectRoot, ".claude", "skills");
+    const files = [];
+    for (const skill of skills) {
+        const sourceFiles = await listFilesRecursive(skill.dirPath);
+        for (const sourcePath of sourceFiles) {
+            const relative = path_1.default.relative(skill.dirPath, sourcePath);
+            files.push({
+                path: path_1.default.join(outputRoot, skill.id, relative),
+                content: await fs_extra_1.default.readFile(sourcePath)
+            });
+        }
+    }
+    return files;
+}
+async function planNativeSkillOutputs(projectRoot, target, skills) {
+    const files = [
+        textFile(path_1.default.join(projectRoot, target.nativeSkillDir, "nymor-learn", "SKILL.md"), `${(0, bootstrap_1.renderLearnSkill)(target)}\n`)
+    ];
+    for (const skill of skills) {
+        const sourceFiles = await listFilesRecursive(skill.dirPath);
+        for (const sourcePath of sourceFiles) {
+            const relative = path_1.default.relative(skill.dirPath, sourcePath);
+            files.push({
+                path: path_1.default.join(projectRoot, target.nativeSkillDir, skill.id, relative),
+                content: await fs_extra_1.default.readFile(sourcePath)
+            });
+        }
+    }
+    return files;
+}
+async function listFilesRecursive(root) {
+    const entries = await fs_extra_1.default.readdir(root, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const entryPath = path_1.default.join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await listFilesRecursive(entryPath)));
+        }
+        else if (entry.isFile()) {
+            files.push(entryPath);
+        }
+    }
+    return files.sort();
+}
+function textFile(filePath, content) {
+    return { path: filePath, content: Buffer.from(content, "utf8") };
+}