nymor 1.0.1

package/tests/e2e/init-and-compile.test.ts

@@ -0,0 +1,227 @@
+import { execFileSync, spawnSync } from "child_process";
+import os from "os";
+import path from "path";
+import fs from "fs-extra";
+import { beforeAll, describe, expect, it } from "vitest";
+
+const repoRoot = path.resolve(__dirname, "..", "..");
+const cliPath = path.join(repoRoot, "dist", "index.js");
+
+describe("nymor CLI", () => {
+  beforeAll(() => {
+    execFileSync("npm", ["run", "build"], { cwd: repoRoot, stdio: "inherit" });
+  }, 60_000);
+
+  it("initializes empty local memory, compiles idempotently, and passes doctor", async () => {
+    const projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), "nymor-e2e-"));
+    await fs.writeJson(path.join(projectRoot, "package.json"), { name: "fixture", version: "1.0.0" });
+
+    runCli(["init"], projectRoot);
+
+    await expect(fs.readdir(path.join(projectRoot, ".nymor", "skills"))).resolves.toEqual([]);
+    await expect(fs.readJson(path.join(projectRoot, "nymor.json"))).resolves.toMatchObject({ local: [] });
+    await expect(fs.pathExists(path.join(projectRoot, ".nymor", "skills", "commit-conventions"))).resolves.toBe(false);
+
+    runCli(["compile"], projectRoot);
+    const before = await readTree(projectRoot);
+    runCli(["compile"], projectRoot);
+    const after = await readTree(projectRoot);
+
+    expect(after).toEqual(before);
+    runCli(["doctor"], projectRoot);
+  }, 60_000);
+
+  it("hides internal and removed commands from public help", () => {
+    const result = spawnSync(process.execPath, [cliPath, "--help"], {
+      cwd: repoRoot,
+      encoding: "utf8"
+    });
+
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain("nymor");
+    expect(result.stdout).toContain("init");
+    expect(result.stdout).not.toContain("learn");
+    expect(result.stdout).not.toContain("add");
+    expect(result.stdout).not.toContain("remove");
+    expect(result.stdout).not.toContain("update");
+  });
+
+  it("keeps the README focused on Nymor repo memory", async () => {
+    const readme = await fs.readFile(path.join(repoRoot, "README.md"), "utf8");
+
+    expect(readme).toContain("# Nymor");
+    expect(readme).toContain("/nymor-learn");
+    for (const forbidden of ["Cicada", "cicada", "registry", "draft", "approve", "starter skills", "nymor learn"]) {
+      expect(readme).not.toContain(forbidden);
+    }
+  });
+
+  it("keeps the hidden learn fallback working", async () => {
+    const projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), "nymor-learn-"));
+    await fs.writeJson(path.join(projectRoot, "nymor.json"), {
+      version: "1",
+      agents: [],
+      local: []
+    });
+
+    runCli(
+      [
+        "learn",
+        "Use Server Actions for all mutations",
+        "--id",
+        "server-actions-only",
+        "--name",
+        "Server Actions Only",
+        "--description",
+        "Use this when changing app mutations",
+        "--globs",
+        "app/**/*.ts,app/**/*.tsx",
+        "--why",
+        "Keeps mutations close to UI and simplifies auth.",
+        "--example",
+        "Prefer an exported 'use server' action over a new API route."
+      ],
+      projectRoot
+    );
+
+    const skillPath = path.join(projectRoot, ".nymor", "skills", "server-actions-only", "SKILL.md");
+    await expect(fs.readFile(skillPath, "utf8")).resolves.toContain("Keeps mutations close to UI and simplifies auth.");
+    await expect(fs.readJson(path.join(projectRoot, "nymor.json"))).resolves.toMatchObject({
+      local: ["server-actions-only"]
+    });
+  }, 60_000);
+
+  it("writes Nymor outputs for the common agent set", async () => {
+    const projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), "nymor-agents-"));
+    await fs.writeJson(path.join(projectRoot, "nymor.json"), {
+      version: "1",
+      agents: ["claude", "cursor", "copilot", "kiro", "agents-md", "gemini", "windsurf", "goose", "opencode"],
+      local: ["demo"]
+    });
+    await writeDemoSkill(projectRoot);
+
+    runCli(["compile"], projectRoot);
+
+    await expect(fs.pathExists(path.join(projectRoot, ".claude", "skills", "demo", "SKILL.md"))).resolves.toBe(true);
+    await expect(fs.pathExists(path.join(projectRoot, ".cursor", "rules", "nymor-demo.mdc"))).resolves.toBe(true);
+    await expect(fs.pathExists(path.join(projectRoot, ".github", "instructions", "nymor-demo.instructions.md"))).resolves.toBe(true);
+    await expect(fs.pathExists(path.join(projectRoot, ".github", "prompts", "nymor-learn.prompt.md"))).resolves.toBe(true);
+    await expect(fs.pathExists(path.join(projectRoot, ".kiro", "steering", "nymor-demo.md"))).resolves.toBe(true);
+    await expect(fs.pathExists(path.join(projectRoot, ".goose", "skills", "demo", "SKILL.md"))).resolves.toBe(true);
+    await expect(fs.pathExists(path.join(projectRoot, ".opencode", "skill", "demo", "SKILL.md"))).resolves.toBe(true);
+
+    await expect(fs.readFile(path.join(projectRoot, ".claude", "commands", "nymor-learn.md"), "utf8")).resolves.toContain(
+      "This looks like a reusable repo rule. Want me to capture it with /nymor-learn?"
+    );
+    await expect(fs.readFile(path.join(projectRoot, ".cursor", "commands", "nymor-learn.md"), "utf8")).resolves.toContain(
+      "Only create a skill after the user explicitly invokes /nymor-learn."
+    );
+    await expect(fs.readFile(path.join(projectRoot, ".github", "prompts", "nymor-learn.prompt.md"), "utf8")).resolves.toContain(
+      "Only create a skill after the user explicitly invokes /nymor-learn."
+    );
+    await expect(fs.readFile(path.join(projectRoot, "AGENTS.md"), "utf8")).resolves.toContain("<!-- nymor:start -->");
+    await expect(fs.readFile(path.join(projectRoot, "GEMINI.md"), "utf8")).resolves.toContain("/nymor-learn");
+    await expect(fs.readFile(path.join(projectRoot, ".windsurf", "rules", "nymor.md"), "utf8")).resolves.toContain(
+      ".nymor/skills/"
+    );
+  }, 60_000);
+
+  it("doctor flags broken globs", async () => {
+    const projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), "nymor-doctor-"));
+    await fs.writeJson(path.join(projectRoot, "nymor.json"), {
+      version: "1",
+      agents: [],
+      local: ["broken"]
+    });
+    await fs.outputFile(
+      path.join(projectRoot, ".nymor", "skills", "broken", "SKILL.md"),
+      [
+        "---",
+        "name: Broken Glob",
+        "globs:",
+        "  - nope/**/*.fake",
+        "alwaysApply: false",
+        "---",
+        "",
+        "## Rule",
+        "Use matching globs.",
+        "",
+        "## Why",
+        "Doctor should catch broken scope.",
+        "",
+        "## Example",
+        "nope"
+      ].join("\n"),
+      "utf8"
+    );
+
+    runCli(["compile"], projectRoot);
+    const result = spawnSync(process.execPath, [cliPath, "doctor"], {
+      cwd: projectRoot,
+      encoding: "utf8"
+    });
+
+    expect(result.status).toBe(1);
+    expect(`${result.stdout}${result.stderr}`).toContain("no matches: nope/**/*.fake");
+  }, 60_000);
+});
+
+function runCli(args: string[], cwd: string, env: Record<string, string> = {}): void {
+  execFileSync(process.execPath, [cliPath, ...args], {
+    cwd,
+    env: { ...process.env, ...env },
+    stdio: "pipe"
+  });
+}
+
+async function writeDemoSkill(projectRoot: string): Promise<void> {
+  await fs.outputFile(
+    path.join(projectRoot, ".nymor", "skills", "demo", "SKILL.md"),
+    [
+      "---",
+      "name: Demo",
+      "description: Demo skill",
+      "globs:",
+      "  - \"**/*\"",
+      "alwaysApply: true",
+      "---",
+      "",
+      "## Rule",
+      "Use demos.",
+      "",
+      "## Why",
+      "For tests.",
+      "",
+      "## Example",
+      "demo"
+    ].join("\n"),
+    "utf8"
+  );
+}
+
+async function readTree(root: string): Promise<Record<string, string>> {
+  const files = (await listFiles(root)).filter((file) => !file.includes(`${path.sep}.git${path.sep}`));
+  const output: Record<string, string> = {};
+
+  for (const file of files) {
+    output[path.relative(root, file)] = await fs.readFile(file, "utf8");
+  }
+
+  return output;
+}
+
+async function listFiles(root: string): Promise<string[]> {
+  const entries = await fs.readdir(root, { withFileTypes: true });
+  const files: string[] = [];
+
+  for (const entry of entries) {
+    const entryPath = path.join(root, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...(await listFiles(entryPath)));
+    } else {
+      files.push(entryPath);
+    }
+  }
+
+  return files.sort();
+}

package/tests/fixtures/skills/scoped/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: Scoped Skill
+description: Applies to TypeScript source files.
+globs:
+  - "src/**/*.ts"
+alwaysApply: false
+---
+
+# Skill: Scoped Skill
+
+## Rule
+Use explicit return types on exported functions.
+
+## Why
+Exported APIs should be clear at the boundary.
+
+## Example
+export function run(): void {}

package/tests/fixtures/skills/simple/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: Simple Skill
+description: Applies everywhere.
+alwaysApply: true
+---
+
+# Skill: Simple Skill
+
+## Rule
+Always keep the code readable.
+
+## Why
+Readable code is easier to review and maintain.
+
+## Example
+Prefer a named helper over a dense inline expression.

package/tests/fixtures/skills/with-examples/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: With Examples
+description: Includes extra example files.
+globs:
+  - "src/**/*.ts"
+alwaysApply: false
+---
+
+# Skill: With Examples
+
+## Rule
+Keep examples near the skill.
+
+## Why
+Examples make a convention concrete.
+
+## Example
+See examples/example.md.

package/tests/fixtures/skills/with-examples/examples/example.md

@@ -0,0 +1,3 @@
+# Example
+
+Use a small fixture alongside the skill.

package/tests/fixtures/stacks/django/manage.py

@@ -0,0 +1,2 @@
+#!/usr/bin/env python
+print("django")

package/tests/fixtures/stacks/django/requirements.txt

@@ -0,0 +1 @@
+django==5.0.0

package/tests/fixtures/stacks/fastapi/requirements.txt

@@ -0,0 +1 @@
+fastapi==0.110.0

package/tests/fixtures/stacks/go/go.mod

@@ -0,0 +1,3 @@
+module example.com/fixture
+
+go 1.22

package/tests/fixtures/stacks/nodejs/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "express": "^4.18.0"
+  }
+}

package/tests/fixtures/stacks/react/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "react": "^18.2.0"
+  }
+}

package/tests/fixtures/stacks/rust/Cargo.toml

@@ -0,0 +1,4 @@
+[package]
+name = "fixture"
+version = "0.1.0"
+edition = "2021"

package/tests/fixtures/stacks/vue/package.json

@@ -0,0 +1,8 @@
+{
+  "dependencies": {
+    "vue": "^3.4.0"
+  },
+  "devDependencies": {
+    "vite": "^5.0.0"
+  }
+}

package/tests/fixtures/stacks/vue/vite.config.ts

@@ -0,0 +1,5 @@
+import vue from "@vitejs/plugin-vue";
+
+export default {
+  plugins: [vue()]
+};

package/tests/utils/manifest.test.ts

@@ -0,0 +1,31 @@
+import os from "os";
+import path from "path";
+import fs from "fs-extra";
+import { describe, expect, it } from "vitest";
+import { DEFAULT_AGENT_TARGETS } from "../../src/agents/targets";
+import { readManifest, writeManifest } from "../../src/utils/manifest";
+
+describe("manifest utilities", () => {
+  it("returns defaults when nymor.json is missing", async () => {
+    const projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), "nymor-manifest-"));
+
+    await expect(readManifest(projectRoot)).resolves.toMatchObject({
+      version: "1",
+      agents: DEFAULT_AGENT_TARGETS,
+      local: []
+    });
+  });
+
+  it("roundtrips manifest JSON", async () => {
+    const projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), "nymor-manifest-"));
+    const manifest = {
+      version: "1",
+      agents: ["claude" as const],
+      local: ["local-demo"]
+    };
+
+    await writeManifest(projectRoot, manifest);
+
+    await expect(readManifest(projectRoot)).resolves.toEqual(manifest);
+  });
+});

package/tests/utils/paths.test.ts

@@ -0,0 +1,23 @@
+import path from "path";
+import { describe, expect, it } from "vitest";
+import {
+  getIndexJsonPath,
+  getIndexMarkdownPath,
+  getManifestPath,
+  getNymorDir,
+  getRepoRoot,
+  getSkillsDir
+} from "../../src/utils/paths";
+
+describe("path utilities", () => {
+  it("derives project paths from a root", () => {
+    const root = path.join(path.sep, "tmp", "project");
+
+    expect(getRepoRoot(root)).toBe(root);
+    expect(getNymorDir(root)).toBe(path.join(root, ".nymor"));
+    expect(getSkillsDir(root)).toBe(path.join(root, ".nymor", "skills"));
+    expect(getIndexMarkdownPath(root)).toBe(path.join(root, ".nymor", "index.md"));
+    expect(getIndexJsonPath(root)).toBe(path.join(root, ".nymor", "index.json"));
+    expect(getManifestPath(root)).toBe(path.join(root, "nymor.json"));
+  });
+});

package/tests/utils/skills.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+import { buildSkillIndex, parseSkillContent } from "../../src/utils/skills";
+
+describe("parseSkillContent", () => {
+  it("normalizes valid frontmatter", () => {
+    const parsed = parseSkillContent(
+      ["---", "name: Demo", "globs:", "  - src/**/*.ts", "alwaysApply: true", "---", "", "## Rule", "Use demos."].join("\n"),
+      "demo"
+    );
+
+    expect(parsed.frontmatter).toEqual({
+      name: "Demo",
+      description: "",
+      globs: ["src/**/*.ts"],
+      alwaysApply: true
+    });
+    expect(parsed.body).toContain("## Rule");
+  });
+
+  it("throws when frontmatter is missing", () => {
+    expect(() => parseSkillContent("## Rule", "missing")).toThrow("missing frontmatter");
+  });
+
+  it("throws when frontmatter is malformed", () => {
+    expect(() => parseSkillContent(["---", "name: [", "---"].join("\n"), "bad")).toThrow();
+  });
+
+  it("throws when name is missing", () => {
+    expect(() => parseSkillContent(["---", "description: nope", "---"].join("\n"), "bad")).toThrow("missing a name");
+  });
+});
+
+describe("buildSkillIndex", () => {
+  it("renders markdown and json entries", () => {
+    const index = buildSkillIndex([
+      {
+        id: "demo",
+        dirPath: "/tmp/demo",
+        skillPath: "/tmp/demo/SKILL.md",
+        frontmatter: { name: "Demo", description: "Desc", globs: ["src/**/*.ts"], alwaysApply: false },
+        body: "body",
+        raw: "raw"
+      }
+    ]);
+
+    expect(index.markdown).toContain("| Demo | demo | Desc | src/**/*.ts | no |");
+    expect(JSON.parse(index.json).skills[0].id).toBe("demo");
+  });
+});

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    clearMocks: true,
+    restoreMocks: true
+  }
+});