first-tree 0.0.2 → 0.0.3

package/skills/first-tree/tests/init.test.ts

@@ -0,0 +1,153 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { formatTaskList, writeProgress, runInit } from "#skill/engine/init.js";
+import { Repo } from "#skill/engine/repo.js";
+import {
+  FRAMEWORK_VERSION,
+  INSTALLED_PROGRESS,
+  LEGACY_PROGRESS,
+} from "#skill/engine/runtime/asset-loader.js";
+import {
+  useTmpDir,
+  makeFramework,
+  makeLegacyFramework,
+  makeSourceSkill,
+} from "./helpers.js";
+
+// --- formatTaskList ---
+
+describe("formatTaskList", () => {
+  it("produces markdown heading", () => {
+    const groups = [
+      { group: "Framework", order: 1, tasks: ["Install framework"] },
+    ];
+    const output = formatTaskList(groups);
+    expect(output).toMatch(/^# Context Tree Init/);
+  });
+
+  it("includes group heading", () => {
+    const groups = [
+      { group: "Framework", order: 1, tasks: ["Install framework"] },
+    ];
+    const output = formatTaskList(groups);
+    expect(output).toContain("## Framework");
+  });
+
+  it("includes task as checkbox", () => {
+    const groups = [
+      { group: "Root Node", order: 2, tasks: ["Fix title"] },
+    ];
+    const output = formatTaskList(groups);
+    expect(output).toContain("- [ ] Fix title");
+  });
+
+  it("handles multiple groups", () => {
+    const groups = [
+      { group: "A", order: 1, tasks: ["task-a1", "task-a2"] },
+      { group: "B", order: 2, tasks: ["task-b1"] },
+    ];
+    const output = formatTaskList(groups);
+    expect(output).toContain("## A");
+    expect(output).toContain("## B");
+    expect(output).toContain("- [ ] task-a1");
+    expect(output).toContain("- [ ] task-a2");
+    expect(output).toContain("- [ ] task-b1");
+  });
+
+  it("includes verification section", () => {
+    const groups = [{ group: "G", order: 1, tasks: ["t"] }];
+    const output = formatTaskList(groups);
+    expect(output).toContain("## Verification");
+    expect(output).toContain("context-tree verify");
+  });
+
+  it("handles empty groups", () => {
+    const output = formatTaskList([]);
+    expect(output).toContain("# Context Tree Init");
+    expect(output).toContain("## Verification");
+  });
+});
+
+// --- writeProgress ---
+
+describe("writeProgress", () => {
+  it("writes to correct path", () => {
+    const tmp = useTmpDir();
+    const repo = new Repo(tmp.path);
+    writeProgress(repo, "# hello\n");
+    const progress = join(tmp.path, INSTALLED_PROGRESS);
+    expect(readFileSync(progress, "utf-8")).toBe("# hello\n");
+  });
+
+  it("creates directory if missing", () => {
+    const tmp = useTmpDir();
+    const repo = new Repo(tmp.path);
+    writeProgress(repo, "content");
+    const progress = join(tmp.path, INSTALLED_PROGRESS);
+    expect(readFileSync(progress, "utf-8")).toBe("content");
+  });
+
+  it("overwrites existing file", () => {
+    const tmp = useTmpDir();
+    mkdirSync(join(tmp.path, "skills", "first-tree"), {
+      recursive: true,
+    });
+    writeFileSync(join(tmp.path, INSTALLED_PROGRESS), "old");
+    const repo = new Repo(tmp.path);
+    writeProgress(repo, "new");
+    expect(readFileSync(join(tmp.path, INSTALLED_PROGRESS), "utf-8")).toBe("new");
+  });
+
+  it("keeps using the legacy progress path for legacy repos", () => {
+    const tmp = useTmpDir();
+    makeLegacyFramework(tmp.path);
+    const repo = new Repo(tmp.path);
+    writeProgress(repo, "legacy");
+    expect(readFileSync(join(tmp.path, LEGACY_PROGRESS), "utf-8")).toBe("legacy");
+  });
+});
+
+// --- runInit — guard logic (no network) ---
+
+describe("runInit", () => {
+  it("errors when not a git repo", () => {
+    const tmp = useTmpDir();
+    const repo = new Repo(tmp.path);
+    const ret = runInit(repo);
+    expect(ret).toBe(1);
+  });
+
+  it("installs the bundled skill and scaffolding when framework is missing", () => {
+    const repoDir = useTmpDir();
+    const sourceDir = useTmpDir();
+    mkdirSync(join(repoDir.path, ".git"));
+    makeSourceSkill(sourceDir.path, "0.2.0");
+
+    const ret = runInit(new Repo(repoDir.path), { sourceRoot: sourceDir.path });
+
+    expect(ret).toBe(0);
+    expect(
+      existsSync(join(repoDir.path, "skills", "first-tree", "SKILL.md")),
+    ).toBe(true);
+    expect(readFileSync(join(repoDir.path, FRAMEWORK_VERSION), "utf-8").trim()).toBe("0.2.0");
+    expect(existsSync(join(repoDir.path, "NODE.md"))).toBe(true);
+    expect(existsSync(join(repoDir.path, "AGENT.md"))).toBe(true);
+    expect(existsSync(join(repoDir.path, "members", "NODE.md"))).toBe(true);
+    expect(existsSync(join(repoDir.path, INSTALLED_PROGRESS))).toBe(true);
+  });
+
+  it("skips reinstall when framework exists", () => {
+    const tmp = useTmpDir();
+    const sourceDir = useTmpDir();
+    mkdirSync(join(tmp.path, ".git"));
+    makeFramework(tmp.path, "0.1.0");
+    makeSourceSkill(sourceDir.path, "0.2.0");
+
+    const repo = new Repo(tmp.path);
+    const ret = runInit(repo, { sourceRoot: sourceDir.path });
+
+    expect(ret).toBe(0);
+    expect(readFileSync(join(tmp.path, FRAMEWORK_VERSION), "utf-8").trim()).toBe("0.1.0");
+  });
+});

package/skills/first-tree/tests/repo.test.ts

@@ -0,0 +1,362 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { Repo } from "#skill/engine/repo.js";
+import {
+  FRAMEWORK_VERSION,
+  INSTALLED_PROGRESS,
+  LEGACY_SKILL_PROGRESS,
+  LEGACY_SKILL_VERSION,
+  LEGACY_PROGRESS,
+  LEGACY_VERSION,
+} from "#skill/engine/runtime/asset-loader.js";
+import {
+  useTmpDir,
+  makeFramework,
+  makeLegacyFramework,
+  makeLegacyNamedFramework,
+} from "./helpers.js";
+
+// --- pathExists ---
+
+describe("pathExists", () => {
+  it("returns true for existing file", () => {
+    const tmp = useTmpDir();
+    writeFileSync(join(tmp.path, "file.txt"), "hello");
+    const repo = new Repo(tmp.path);
+    expect(repo.pathExists("file.txt")).toBe(true);
+  });
+
+  it("returns false for missing file", () => {
+    const tmp = useTmpDir();
+    const repo = new Repo(tmp.path);
+    expect(repo.pathExists("no-such-file.txt")).toBe(false);
+  });
+});
+
+// --- fileContains ---
+
+describe("fileContains", () => {
+  it("returns true when text is present", () => {
+    const tmp = useTmpDir();
+    writeFileSync(join(tmp.path, "f.md"), "hello world");
+    const repo = new Repo(tmp.path);
+    expect(repo.fileContains("f.md", "hello")).toBe(true);
+  });
+
+  it("returns false when text is missing", () => {
+    const tmp = useTmpDir();
+    writeFileSync(join(tmp.path, "f.md"), "hello world");
+    const repo = new Repo(tmp.path);
+    expect(repo.fileContains("f.md", "goodbye")).toBe(false);
+  });
+
+  it("returns false when file is missing", () => {
+    const tmp = useTmpDir();
+    const repo = new Repo(tmp.path);
+    expect(repo.fileContains("missing.md", "anything")).toBe(false);
+  });
+});
+
+// --- frontmatter ---
+
+describe("frontmatter", () => {
+  it("parses valid title and owners", () => {
+    const tmp = useTmpDir();
+    writeFileSync(
+      join(tmp.path, "NODE.md"),
+      "---\ntitle: My Tree\nowners: [alice, bob]\n---\n# Content\n",
+    );
+    const repo = new Repo(tmp.path);
+    const fm = repo.frontmatter("NODE.md");
+    expect(fm).not.toBeNull();
+    expect(fm!.title).toBe("My Tree");
+    expect(fm!.owners).toEqual(["alice", "bob"]);
+  });
+
+  it("returns null for missing frontmatter", () => {
+    const tmp = useTmpDir();
+    writeFileSync(
+      join(tmp.path, "NODE.md"),
+      "# Just a heading\nNo frontmatter here.\n",
+    );
+    const repo = new Repo(tmp.path);
+    expect(repo.frontmatter("NODE.md")).toBeNull();
+  });
+
+  it("handles partial — title only", () => {
+    const tmp = useTmpDir();
+    writeFileSync(join(tmp.path, "NODE.md"), "---\ntitle: Partial\n---\n");
+    const repo = new Repo(tmp.path);
+    const fm = repo.frontmatter("NODE.md");
+    expect(fm).not.toBeNull();
+    expect(fm!.title).toBe("Partial");
+    expect(fm!.owners).toBeUndefined();
+  });
+
+  it("handles partial — owners only", () => {
+    const tmp = useTmpDir();
+    writeFileSync(join(tmp.path, "NODE.md"), "---\nowners: [alice]\n---\n");
+    const repo = new Repo(tmp.path);
+    const fm = repo.frontmatter("NODE.md");
+    expect(fm).not.toBeNull();
+    expect(fm!.owners).toEqual(["alice"]);
+    expect(fm!.title).toBeUndefined();
+  });
+
+  it("returns null for missing file", () => {
+    const tmp = useTmpDir();
+    const repo = new Repo(tmp.path);
+    expect(repo.frontmatter("NODE.md")).toBeNull();
+  });
+});
+
+// --- anyAgentConfig ---
+
+describe("anyAgentConfig", () => {
+  it("returns true with claude settings", () => {
+    const tmp = useTmpDir();
+    mkdirSync(join(tmp.path, ".claude"));
+    writeFileSync(join(tmp.path, ".claude", "settings.json"), "{}");
+    const repo = new Repo(tmp.path);
+    expect(repo.anyAgentConfig()).toBe(true);
+  });
+
+  it("returns false without any config", () => {
+    const tmp = useTmpDir();
+    const repo = new Repo(tmp.path);
+    expect(repo.anyAgentConfig()).toBe(false);
+  });
+});
+
+// --- isGitRepo ---
+
+describe("isGitRepo", () => {
+  it("returns true with .git dir", () => {
+    const tmp = useTmpDir();
+    mkdirSync(join(tmp.path, ".git"));
+    const repo = new Repo(tmp.path);
+    expect(repo.isGitRepo()).toBe(true);
+  });
+
+  it("returns false without .git dir", () => {
+    const tmp = useTmpDir();
+    const repo = new Repo(tmp.path);
+    expect(repo.isGitRepo()).toBe(false);
+  });
+});
+
+// --- hasFramework ---
+
+describe("hasFramework", () => {
+  it("returns true with installed skill version file", () => {
+    const tmp = useTmpDir();
+    makeFramework(tmp.path);
+    const repo = new Repo(tmp.path);
+    expect(repo.hasFramework()).toBe(true);
+  });
+
+  it("returns true with legacy version file", () => {
+    const tmp = useTmpDir();
+    makeLegacyFramework(tmp.path);
+    const repo = new Repo(tmp.path);
+    expect(repo.hasFramework()).toBe(true);
+  });
+
+  it("returns true with the previous installed skill name", () => {
+    const tmp = useTmpDir();
+    makeLegacyNamedFramework(tmp.path);
+    const repo = new Repo(tmp.path);
+    expect(repo.hasFramework()).toBe(true);
+  });
+
+  it("returns false without VERSION file", () => {
+    const tmp = useTmpDir();
+    const repo = new Repo(tmp.path);
+    expect(repo.hasFramework()).toBe(false);
+  });
+});
+
+// --- readVersion ---
+
+describe("readVersion", () => {
+  it("reads the installed skill version", () => {
+    const tmp = useTmpDir();
+    makeFramework(tmp.path, "0.2.0");
+    const repo = new Repo(tmp.path);
+    expect(repo.readVersion()).toBe("0.2.0");
+  });
+
+  it("falls back to the legacy version", () => {
+    const tmp = useTmpDir();
+    makeLegacyFramework(tmp.path, "0.3.0");
+    const repo = new Repo(tmp.path);
+    expect(repo.readVersion()).toBe("0.3.0");
+  });
+
+  it("reads the previous installed skill version", () => {
+    const tmp = useTmpDir();
+    makeLegacyNamedFramework(tmp.path, "0.2.5");
+    const repo = new Repo(tmp.path);
+    expect(repo.readVersion()).toBe("0.2.5");
+  });
+
+  it("returns null when missing", () => {
+    const tmp = useTmpDir();
+    const repo = new Repo(tmp.path);
+    expect(repo.readVersion()).toBeNull();
+  });
+});
+
+// --- preferredProgressPath / frameworkVersionPath ---
+
+describe("path preferences", () => {
+  it("prefers the installed-skill paths by default", () => {
+    const tmp = useTmpDir();
+    const repo = new Repo(tmp.path);
+    expect(repo.preferredProgressPath()).toBe(INSTALLED_PROGRESS);
+    expect(repo.frameworkVersionPath()).toBe(FRAMEWORK_VERSION);
+  });
+
+  it("switches path preferences for legacy repos", () => {
+    const tmp = useTmpDir();
+    makeLegacyFramework(tmp.path);
+    const repo = new Repo(tmp.path);
+    expect(repo.preferredProgressPath()).toBe(LEGACY_PROGRESS);
+    expect(repo.frameworkVersionPath()).toBe(LEGACY_VERSION);
+  });
+
+  it("switches path preferences for repos using the previous skill name", () => {
+    const tmp = useTmpDir();
+    makeLegacyNamedFramework(tmp.path);
+    const repo = new Repo(tmp.path);
+    expect(repo.preferredProgressPath()).toBe(LEGACY_SKILL_PROGRESS);
+    expect(repo.frameworkVersionPath()).toBe(LEGACY_SKILL_VERSION);
+  });
+});
+
+// --- hasAgentMdMarkers ---
+
+describe("hasAgentMdMarkers", () => {
+  it("returns true with markers", () => {
+    const tmp = useTmpDir();
+    writeFileSync(
+      join(tmp.path, "AGENT.md"),
+      "<!-- BEGIN CONTEXT-TREE FRAMEWORK -->\nstuff\n<!-- END CONTEXT-TREE FRAMEWORK -->\n",
+    );
+    const repo = new Repo(tmp.path);
+    expect(repo.hasAgentMdMarkers()).toBe(true);
+  });
+
+  it("returns false without markers", () => {
+    const tmp = useTmpDir();
+    writeFileSync(
+      join(tmp.path, "AGENT.md"),
+      "# Agent instructions\nNo markers here.\n",
+    );
+    const repo = new Repo(tmp.path);
+    expect(repo.hasAgentMdMarkers()).toBe(false);
+  });
+
+  it("returns false when file is missing", () => {
+    const tmp = useTmpDir();
+    const repo = new Repo(tmp.path);
+    expect(repo.hasAgentMdMarkers()).toBe(false);
+  });
+});
+
+// --- hasMembers ---
+
+describe("hasMembers", () => {
+  it("returns true with members/NODE.md", () => {
+    const tmp = useTmpDir();
+    const members = join(tmp.path, "members");
+    mkdirSync(members);
+    writeFileSync(join(members, "NODE.md"), "---\ntitle: Members\n---\n");
+    const repo = new Repo(tmp.path);
+    expect(repo.hasMembers()).toBe(true);
+  });
+
+  it("returns false without members dir", () => {
+    const tmp = useTmpDir();
+    const repo = new Repo(tmp.path);
+    expect(repo.hasMembers()).toBe(false);
+  });
+
+  it("returns false with dir but no NODE.md", () => {
+    const tmp = useTmpDir();
+    mkdirSync(join(tmp.path, "members"));
+    const repo = new Repo(tmp.path);
+    expect(repo.hasMembers()).toBe(false);
+  });
+});
+
+// --- memberCount ---
+
+describe("memberCount", () => {
+  it("returns 0 with no members dir", () => {
+    const tmp = useTmpDir();
+    const repo = new Repo(tmp.path);
+    expect(repo.memberCount()).toBe(0);
+  });
+
+  it("counts one member", () => {
+    const tmp = useTmpDir();
+    const members = join(tmp.path, "members");
+    mkdirSync(members);
+    const alice = join(members, "alice");
+    mkdirSync(alice);
+    writeFileSync(join(alice, "NODE.md"), "---\ntitle: Alice\n---\n");
+    const repo = new Repo(tmp.path);
+    expect(repo.memberCount()).toBe(1);
+  });
+
+  it("counts two members", () => {
+    const tmp = useTmpDir();
+    const members = join(tmp.path, "members");
+    mkdirSync(members);
+    for (const name of ["alice", "bob"]) {
+      const d = join(members, name);
+      mkdirSync(d);
+      writeFileSync(join(d, "NODE.md"), `---\ntitle: ${name}\n---\n`);
+    }
+    const repo = new Repo(tmp.path);
+    expect(repo.memberCount()).toBe(2);
+  });
+
+  it("ignores dirs without NODE.md", () => {
+    const tmp = useTmpDir();
+    const members = join(tmp.path, "members");
+    mkdirSync(members);
+    mkdirSync(join(members, "alice")); // no NODE.md
+    const bob = join(members, "bob");
+    mkdirSync(bob);
+    writeFileSync(join(bob, "NODE.md"), "---\ntitle: Bob\n---\n");
+    const repo = new Repo(tmp.path);
+    expect(repo.memberCount()).toBe(1);
+  });
+});
+
+// --- hasPlaceholderNode ---
+
+describe("hasPlaceholderNode", () => {
+  it("returns true with placeholder", () => {
+    const tmp = useTmpDir();
+    writeFileSync(
+      join(tmp.path, "NODE.md"),
+      "---\ntitle: My Tree\n---\n<!-- PLACEHOLDER: fill in -->\n",
+    );
+    const repo = new Repo(tmp.path);
+    expect(repo.hasPlaceholderNode()).toBe(true);
+  });
+
+  it("returns false without placeholder", () => {
+    const tmp = useTmpDir();
+    writeFileSync(
+      join(tmp.path, "NODE.md"),
+      "---\ntitle: My Tree\n---\n# Real content\n",
+    );
+    const repo = new Repo(tmp.path);
+    expect(repo.hasPlaceholderNode()).toBe(false);
+  });
+});