first-tree 0.0.2 → 0.0.4

package/skills/first-tree/tests/helpers.ts

@@ -0,0 +1,169 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { afterEach } from "vitest";
+import {
+  AGENT_INSTRUCTIONS_FILE,
+  AGENT_INSTRUCTIONS_TEMPLATE,
+  FRAMEWORK_VERSION,
+  LEGACY_AGENT_INSTRUCTIONS_FILE,
+  LEGACY_SKILL_VERSION,
+  LEGACY_VERSION,
+} from "#skill/engine/runtime/asset-loader.js";
+
+interface TmpDir {
+  path: string;
+}
+
+export function useTmpDir(): TmpDir {
+  const dir = mkdtempSync(join(tmpdir(), "ct-test-"));
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+  return { path: dir };
+}
+
+export function makeFramework(root: string, version = "0.1.0"): void {
+  mkdirSync(join(root, "skills", "first-tree", "assets", "framework"), {
+    recursive: true,
+  });
+  writeFileSync(join(root, FRAMEWORK_VERSION), `${version}\n`);
+}
+
+export function makeGitRepo(root: string): void {
+  mkdirSync(join(root, ".git"), { recursive: true });
+}
+
+export function makeSourceRepo(root: string): void {
+  makeGitRepo(root);
+  mkdirSync(join(root, "src"), { recursive: true });
+  writeFileSync(
+    join(root, "package.json"),
+    JSON.stringify({ name: "example-source-repo" }, null, 2),
+  );
+  writeFileSync(join(root, "src", "index.ts"), "export const ready = true;\n");
+}
+
+export function makeLegacyFramework(root: string, version = "0.1.0"): void {
+  const ct = join(root, ".context-tree");
+  mkdirSync(ct, { recursive: true });
+  writeFileSync(join(root, LEGACY_VERSION), `${version}\n`);
+}
+
+export function makeLegacyNamedFramework(
+  root: string,
+  version = "0.1.0",
+): void {
+  mkdirSync(
+    join(root, "skills", "first-tree-cli-framework", "assets", "framework"),
+    {
+      recursive: true,
+    },
+  );
+  writeFileSync(join(root, LEGACY_SKILL_VERSION), `${version}\n`);
+}
+
+export function makeSourceSkill(root: string, version = "0.2.0"): void {
+  const skillRoot = join(root, "skills", "first-tree");
+  mkdirSync(join(skillRoot, "agents"), { recursive: true });
+  mkdirSync(join(skillRoot, "assets", "framework", "templates"), {
+    recursive: true,
+  });
+
+  writeFileSync(
+    join(skillRoot, "SKILL.md"),
+    "---\nname: first-tree\ndescription: test\n---\n",
+  );
+  writeFileSync(
+    join(skillRoot, "agents", "openai.yaml"),
+    "display_name: First Tree\nshort_description: test\n",
+  );
+  writeFileSync(
+    join(skillRoot, "assets", "framework", "manifest.json"),
+    "{}\n",
+  );
+  writeFileSync(
+    join(skillRoot, "assets", "framework", "VERSION"),
+    `${version}\n`,
+  );
+  writeFileSync(
+    join(
+      skillRoot,
+      "assets",
+      "framework",
+      "templates",
+      "root-node.md.template",
+    ),
+    "---\ntitle: Example Tree\nowners: [alice]\n---\n# Example Tree\n",
+  );
+  writeFileSync(
+    join(
+      skillRoot,
+      "assets",
+      "framework",
+      "templates",
+      AGENT_INSTRUCTIONS_TEMPLATE,
+    ),
+    "<!-- BEGIN CONTEXT-TREE FRAMEWORK -->\nframework text\n<!-- END CONTEXT-TREE FRAMEWORK -->\n",
+  );
+  writeFileSync(
+    join(
+      skillRoot,
+      "assets",
+      "framework",
+      "templates",
+      "members-domain.md.template",
+    ),
+    "---\ntitle: Members\nowners: [alice]\n---\n# Members\n",
+  );
+}
+
+export function makeNode(
+  root: string,
+  opts?: { placeholder?: boolean },
+): void {
+  const body = opts?.placeholder
+    ? "<!-- PLACEHOLDER -->\n"
+    : "# Real content\n";
+  writeFileSync(
+    join(root, "NODE.md"),
+    `---\ntitle: My Org\nowners: [alice]\n---\n${body}`,
+  );
+}
+
+export function makeAgentsMd(
+  root: string,
+  opts?: { markers?: boolean; userContent?: boolean; legacyName?: boolean },
+): void {
+  const markers = opts?.markers ?? true;
+  const userContent = opts?.userContent ?? false;
+  const fileName = opts?.legacyName
+    ? LEGACY_AGENT_INSTRUCTIONS_FILE
+    : AGENT_INSTRUCTIONS_FILE;
+  const parts: string[] = [];
+  if (markers) {
+    parts.push(
+      "<!-- BEGIN CONTEXT-TREE FRAMEWORK -->\nframework stuff\n<!-- END CONTEXT-TREE FRAMEWORK -->",
+    );
+  } else {
+    parts.push("# Agent instructions\n");
+  }
+  if (userContent) {
+    parts.push("\n# Project-specific\nThis is real user content.\n");
+  }
+  writeFileSync(join(root, fileName), parts.join("\n"));
+}
+
+export function makeMembers(root: string, count = 1): void {
+  const membersDir = join(root, "members");
+  mkdirSync(membersDir, { recursive: true });
+  writeFileSync(
+    join(membersDir, "NODE.md"),
+    "---\ntitle: Members\n---\n",
+  );
+  for (let i = 0; i < count; i++) {
+    const d = join(membersDir, `member-${i}`);
+    mkdirSync(d);
+    writeFileSync(join(d, "NODE.md"), `---\ntitle: Member ${i}\nowners: [member-${i}]\ntype: human\nrole: Engineer\ndomains:\n  - engineering\n---\n`);
+  }
+}

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

@@ -0,0 +1,250 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+  formatTaskList,
+  parseInitArgs,
+  writeProgress,
+  runInit,
+} from "#skill/engine/init.js";
+import { Repo } from "#skill/engine/repo.js";
+import {
+  AGENT_INSTRUCTIONS_FILE,
+  FRAMEWORK_VERSION,
+  INSTALLED_PROGRESS,
+  LEGACY_AGENT_INSTRUCTIONS_FILE,
+  LEGACY_PROGRESS,
+} from "#skill/engine/runtime/asset-loader.js";
+import {
+  makeGitRepo,
+  useTmpDir,
+  makeAgentsMd,
+  makeFramework,
+  makeLegacyFramework,
+  makeSourceRepo,
+  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) ---
+
+const fakeGitInitializer = (root: string): void => {
+  makeGitRepo(root);
+};
+
+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();
+    makeGitRepo(repoDir.path);
+    makeSourceSkill(sourceDir.path, "0.2.0");
+
+    const ret = runInit(new Repo(repoDir.path), {
+      sourceRoot: sourceDir.path,
+      gitInitializer: fakeGitInitializer,
+    });
+
+    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_INSTRUCTIONS_FILE))).toBe(true);
+    expect(existsSync(join(repoDir.path, "members", "NODE.md"))).toBe(true);
+    expect(existsSync(join(repoDir.path, INSTALLED_PROGRESS))).toBe(true);
+  });
+
+  it("does not scaffold AGENTS.md when legacy AGENT.md already exists", () => {
+    const repoDir = useTmpDir();
+    const sourceDir = useTmpDir();
+    mkdirSync(join(repoDir.path, ".git"));
+    makeAgentsMd(repoDir.path, { legacyName: true, markers: true, userContent: true });
+    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, LEGACY_AGENT_INSTRUCTIONS_FILE))).toBe(true);
+    expect(existsSync(join(repoDir.path, AGENT_INSTRUCTIONS_FILE))).toBe(false);
+    expect(readFileSync(join(repoDir.path, INSTALLED_PROGRESS), "utf-8")).toContain(
+      "Rename `AGENT.md` to `AGENTS.md`",
+    );
+  });
+
+  it("skips reinstall when framework exists", () => {
+    const tmp = useTmpDir();
+    const sourceDir = useTmpDir();
+    makeGitRepo(tmp.path);
+    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");
+  });
+
+  it("creates a sibling tree repo by default when invoked from a source repo", () => {
+    const sourceRepoDir = useTmpDir();
+    const sourceSkillDir = useTmpDir();
+    makeSourceRepo(sourceRepoDir.path);
+    makeSourceSkill(sourceSkillDir.path, "0.2.0");
+
+    const ret = runInit(new Repo(sourceRepoDir.path), {
+      sourceRoot: sourceSkillDir.path,
+      gitInitializer: fakeGitInitializer,
+    });
+
+    const treeRepo = join(
+      dirname(sourceRepoDir.path),
+      `${basename(sourceRepoDir.path)}-context`,
+    );
+
+    expect(ret).toBe(0);
+    expect(existsSync(join(treeRepo, "skills", "first-tree", "SKILL.md"))).toBe(true);
+    expect(existsSync(join(treeRepo, "NODE.md"))).toBe(true);
+    expect(existsSync(join(treeRepo, AGENT_INSTRUCTIONS_FILE))).toBe(true);
+    expect(existsSync(join(treeRepo, "members", "NODE.md"))).toBe(true);
+    expect(existsSync(join(treeRepo, INSTALLED_PROGRESS))).toBe(true);
+    expect(existsSync(join(sourceRepoDir.path, "NODE.md"))).toBe(false);
+    expect(existsSync(join(sourceRepoDir.path, "members", "NODE.md"))).toBe(false);
+    expect(existsSync(join(sourceRepoDir.path, INSTALLED_PROGRESS))).toBe(false);
+  });
+
+  it("keeps supporting in-place init with --here", () => {
+    const sourceRepoDir = useTmpDir();
+    const sourceSkillDir = useTmpDir();
+    makeSourceRepo(sourceRepoDir.path);
+    makeSourceSkill(sourceSkillDir.path, "0.2.0");
+
+    const ret = runInit(new Repo(sourceRepoDir.path), {
+      here: true,
+      sourceRoot: sourceSkillDir.path,
+      gitInitializer: fakeGitInitializer,
+    });
+
+    expect(ret).toBe(0);
+    expect(existsSync(join(sourceRepoDir.path, "NODE.md"))).toBe(true);
+    expect(existsSync(join(sourceRepoDir.path, AGENT_INSTRUCTIONS_FILE))).toBe(true);
+    expect(existsSync(join(sourceRepoDir.path, "members", "NODE.md"))).toBe(true);
+    expect(existsSync(join(sourceRepoDir.path, INSTALLED_PROGRESS))).toBe(true);
+  });
+});
+
+describe("parseInitArgs", () => {
+  it("parses dedicated repo options", () => {
+    expect(parseInitArgs(["--tree-name", "acme-context"])).toEqual({
+      treeName: "acme-context",
+    });
+    expect(parseInitArgs(["--tree-path", "../acme-context"])).toEqual({
+      treePath: "../acme-context",
+    });
+  });
+
+  it("rejects incompatible init options", () => {
+    expect(parseInitArgs(["--here", "--tree-name", "acme-context"])).toEqual({
+      error: "Cannot combine --here with --tree-name",
+    });
+  });
+});