first-tree 0.0.2 → 0.0.3

package/skills/first-tree/tests/validate-nodes.test.ts

@@ -0,0 +1,198 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  Findings,
+  parseFrontmatter,
+  parseSoftLinks,
+  validateOwners,
+  validateFolders,
+  validateEmptyNodes,
+  validateTitleMismatch,
+  setTreeRoot,
+} from "#skill/engine/validators/nodes.js";
+import { useTmpDir } from "./helpers.js";
+
+function write(root: string, relPath: string, content: string): string {
+  const p = join(root, relPath);
+  mkdirSync(join(p, ".."), { recursive: true });
+  writeFileSync(p, content);
+  return p;
+}
+
+function setup(tmp: { path: string }): string {
+  setTreeRoot(tmp.path);
+  return tmp.path;
+}
+
+// --- parseFrontmatter ---
+
+describe("parseFrontmatter", () => {
+  it("parses valid frontmatter", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\ntitle: Hello\nowners: [alice]\n---\n# Hello\n");
+    const fm = parseFrontmatter(p);
+    expect(fm).not.toBeNull();
+    expect(fm).toContain("title: Hello");
+  });
+
+  it("returns null for missing frontmatter", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "# No frontmatter here\n");
+    expect(parseFrontmatter(p)).toBeNull();
+  });
+
+  it("returns null for malformed frontmatter", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\ntitle: Oops\nNo closing fence\n");
+    expect(parseFrontmatter(p)).toBeNull();
+  });
+});
+
+// --- parseSoftLinks ---
+
+describe("parseSoftLinks", () => {
+  it("parses inline format", () => {
+    expect(parseSoftLinks("owners: [alice]\nsoft_links: [/a, /b]")).toEqual(["/a", "/b"]);
+  });
+
+  it("parses block format", () => {
+    expect(parseSoftLinks("owners: [alice]\nsoft_links:\n  - /x\n  - /y\n")).toEqual(["/x", "/y"]);
+  });
+
+  it("handles empty inline", () => {
+    expect(parseSoftLinks("owners: [alice]\nsoft_links: []")).toEqual([]);
+  });
+
+  it("returns null when missing", () => {
+    expect(parseSoftLinks("owners: [alice]")).toBeNull();
+  });
+});
+
+// --- validateOwners ---
+
+describe("validateOwners", () => {
+  it("accepts valid owners", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\nowners: [alice, bob]\n---\n");
+    const fm = parseFrontmatter(p)!;
+    const f = new Findings();
+    validateOwners(fm, p, f);
+    expect(f.errors).toEqual([]);
+  });
+
+  it("accepts wildcard", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\nowners: [*]\n---\n");
+    const fm = parseFrontmatter(p)!;
+    const f = new Findings();
+    validateOwners(fm, p, f);
+    expect(f.errors).toEqual([]);
+  });
+
+  it("accepts empty inheritance", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\nowners: []\n---\n");
+    const fm = parseFrontmatter(p)!;
+    const f = new Findings();
+    validateOwners(fm, p, f);
+    expect(f.errors).toEqual([]);
+  });
+
+  it("rejects invalid username", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\nowners: [not valid!]\n---\n");
+    const fm = parseFrontmatter(p)!;
+    const f = new Findings();
+    validateOwners(fm, p, f);
+    expect(f.errors).toHaveLength(1);
+    expect(f.errors[0]).toContain("invalid owner");
+  });
+
+  it("rejects mixed wildcard", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\nowners: [alice, *]\n---\n");
+    const fm = parseFrontmatter(p)!;
+    const f = new Findings();
+    validateOwners(fm, p, f);
+    expect(f.errors).toHaveLength(1);
+    expect(f.errors[0]).toContain("wildcard");
+  });
+});
+
+// --- validateFolders ---
+
+describe("validateFolders", () => {
+  it("reports missing NODE.md", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    mkdirSync(join(root, "domain"));
+    const f = new Findings();
+    validateFolders(f);
+    expect(f.errors.some((e) => e.includes("missing NODE.md"))).toBe(true);
+  });
+
+  it("passes with valid folder", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    mkdirSync(join(root, "domain"));
+    writeFileSync(join(root, "domain", "NODE.md"), "---\nowners: [a]\n---\n# D\n");
+    const f = new Findings();
+    validateFolders(f);
+    expect(f.errors).toEqual([]);
+  });
+});
+
+// --- validateEmptyNodes ---
+
+describe("validateEmptyNodes", () => {
+  it("flags short body", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\nowners: [a]\n---\n\n");
+    const f = new Findings();
+    validateEmptyNodes([p], f);
+    expect(f.warnings.some((w) => w.includes("little or no body content"))).toBe(true);
+  });
+
+  it("passes with adequate body", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const body = "This is a meaningful body with enough content to pass the threshold easily.";
+    const p = write(root, "NODE.md", `---\nowners: [a]\n---\n${body}\n`);
+    const f = new Findings();
+    validateEmptyNodes([p], f);
+    expect(f.warnings).toEqual([]);
+  });
+});
+
+// --- validateTitleMismatch ---
+
+describe("validateTitleMismatch", () => {
+  it("passes with matching title", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\ntitle: Hello World\nowners: [a]\n---\n# Hello World\n");
+    const f = new Findings();
+    validateTitleMismatch([p], f);
+    expect(f.warnings).toEqual([]);
+  });
+
+  it("flags mismatched title", () => {
+    const tmp = useTmpDir();
+    const root = setup(tmp);
+    const p = write(root, "NODE.md", "---\ntitle: Hello\nowners: [a]\n---\n# Goodbye\n");
+    const f = new Findings();
+    validateTitleMismatch([p], f);
+    expect(f.warnings).toHaveLength(1);
+    expect(f.warnings[0]).toContain("differs from");
+  });
+});

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

@@ -0,0 +1,142 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { check, checkProgress, runVerify } from "#skill/engine/verify.js";
+import { Repo } from "#skill/engine/repo.js";
+import {
+  INSTALLED_PROGRESS,
+  LEGACY_PROGRESS,
+} from "#skill/engine/runtime/asset-loader.js";
+import {
+  useTmpDir,
+  makeFramework,
+  makeLegacyFramework,
+  makeNode,
+  makeAgentMd,
+  makeMembers,
+} from "./helpers.js";
+
+// --- check ---
+
+describe("check", () => {
+  it("returns true on pass", () => {
+    expect(check("my check", true)).toBe(true);
+  });
+
+  it("returns false on fail", () => {
+    expect(check("my check", false)).toBe(false);
+  });
+});
+
+// --- checkProgress ---
+
+describe("checkProgress", () => {
+  it("returns empty for no progress file", () => {
+    const tmp = useTmpDir();
+    const repo = new Repo(tmp.path);
+    expect(checkProgress(repo)).toEqual([]);
+  });
+
+  it("returns empty when all checked", () => {
+    const tmp = useTmpDir();
+    mkdirSync(join(tmp.path, "skills", "first-tree"), { recursive: true });
+    writeFileSync(
+      join(tmp.path, INSTALLED_PROGRESS),
+      "# Progress\n- [x] Task one\n- [x] Task two\n",
+    );
+    const repo = new Repo(tmp.path);
+    expect(checkProgress(repo)).toEqual([]);
+  });
+
+  it("returns unchecked items", () => {
+    const tmp = useTmpDir();
+    mkdirSync(join(tmp.path, "skills", "first-tree"), { recursive: true });
+    writeFileSync(
+      join(tmp.path, INSTALLED_PROGRESS),
+      "# Progress\n- [x] Done task\n- [ ] Pending task\n- [ ] Another pending\n",
+    );
+    const repo = new Repo(tmp.path);
+    expect(checkProgress(repo)).toEqual(["Pending task", "Another pending"]);
+  });
+
+  it("returns empty for empty progress", () => {
+    const tmp = useTmpDir();
+    mkdirSync(join(tmp.path, "skills", "first-tree"), { recursive: true });
+    writeFileSync(join(tmp.path, INSTALLED_PROGRESS), "");
+    const repo = new Repo(tmp.path);
+    expect(checkProgress(repo)).toEqual([]);
+  });
+
+  it("falls back to the legacy progress file", () => {
+    const tmp = useTmpDir();
+    makeLegacyFramework(tmp.path);
+    writeFileSync(
+      join(tmp.path, LEGACY_PROGRESS),
+      "# Progress\n- [ ] Legacy task\n",
+    );
+    const repo = new Repo(tmp.path);
+    expect(checkProgress(repo)).toEqual(["Legacy task"]);
+  });
+});
+
+// --- helpers for building a full repo ---
+
+function buildFullRepo(root: string): void {
+  mkdirSync(join(root, ".git"));
+  makeFramework(root);
+  writeFileSync(
+    join(root, "NODE.md"),
+    "---\ntitle: My Org\nowners: [alice]\n---\n# Content\n",
+  );
+  writeFileSync(
+    join(root, "AGENT.md"),
+    "<!-- BEGIN CONTEXT-TREE FRAMEWORK -->\nstuff\n<!-- END CONTEXT-TREE FRAMEWORK -->\n",
+  );
+  makeMembers(root, 1);
+}
+
+const passValidator = () => ({ exitCode: 0 });
+const failValidator = () => ({ exitCode: 1 });
+
+// --- runVerify — all passing ---
+
+describe("runVerify all passing", () => {
+  it("returns 0 when all checks pass", () => {
+    const tmp = useTmpDir();
+    buildFullRepo(tmp.path);
+    const repo = new Repo(tmp.path);
+    const ret = runVerify(repo, passValidator);
+    expect(ret).toBe(0);
+  });
+});
+
+// --- runVerify — failing checks ---
+
+describe("runVerify failing", () => {
+  it("fails on empty repo", () => {
+    const tmp = useTmpDir();
+    const repo = new Repo(tmp.path);
+    const ret = runVerify(repo, passValidator);
+    expect(ret).toBe(1);
+  });
+
+  it("fails when AGENT.md is missing", () => {
+    const tmp = useTmpDir();
+    makeFramework(tmp.path);
+    writeFileSync(
+      join(tmp.path, "NODE.md"),
+      "---\ntitle: My Org\nowners: [alice]\n---\n",
+    );
+    const repo = new Repo(tmp.path);
+    const ret = runVerify(repo, passValidator);
+    expect(ret).toBe(1);
+  });
+
+  it("fails when node validation returns non-zero", () => {
+    const tmp = useTmpDir();
+    buildFullRepo(tmp.path);
+    const repo = new Repo(tmp.path);
+    const ret = runVerify(repo, failValidator);
+    expect(ret).toBe(1);
+  });
+});

package/dist/init-CE_944sb.js

@@ -1,283 +0,0 @@
-import { n as Repo, t as FRAMEWORK_END_MARKER } from "./repo-BByc3VvM.js";
-import { execFileSync } from "node:child_process";
-import { copyFileSync, cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { tmpdir } from "node:os";
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-//#endregion
-//#region src/rules/agent-instructions.ts
-var agent_instructions_exports = /* @__PURE__ */ __exportAll({ evaluate: () => evaluate$5 });
-function evaluate$5(repo) {
-	const tasks = [];
-	if (!repo.pathExists("AGENT.md")) tasks.push("AGENT.md is missing — create from `.context-tree/templates/agent.md.template`");
-	else if (!repo.hasAgentMdMarkers()) tasks.push("AGENT.md exists but is missing framework markers — add `<!-- BEGIN CONTEXT-TREE FRAMEWORK -->` and `<!-- END CONTEXT-TREE FRAMEWORK -->` sections");
-	else {
-		const afterMarker = (repo.readFile("AGENT.md") ?? "").split(FRAMEWORK_END_MARKER);
-		if (afterMarker.length > 1) {
-			if (afterMarker[1].trim().split("\n").filter((l) => l.trim() && !l.trim().startsWith("#") && !l.trim().startsWith("<!--")).length === 0) tasks.push("Add your project-specific instructions below the framework markers in AGENT.md");
-		}
-	}
-	return {
-		group: "Agent Instructions",
-		order: 3,
-		tasks
-	};
-}
-//#endregion
-//#region src/rules/agent-integration.ts
-var agent_integration_exports = /* @__PURE__ */ __exportAll({ evaluate: () => evaluate$4 });
-function evaluate$4(repo) {
-	const tasks = [];
-	if (repo.pathExists(".claude/settings.json")) {
-		if (!repo.fileContains(".claude/settings.json", "inject-tree-context")) tasks.push("Add SessionStart hook to `.claude/settings.json` (see `.context-tree/examples/claude-code/`)");
-	} else if (!repo.anyAgentConfig()) tasks.push("No agent configuration detected. Configure your agent to load tree context at session start. See `.context-tree/examples/` for supported agents. You can skip this and set it up later.");
-	return {
-		group: "Agent Integration",
-		order: 5,
-		tasks
-	};
-}
-//#endregion
-//#region src/rules/ci-validation.ts
-var ci_validation_exports = /* @__PURE__ */ __exportAll({ evaluate: () => evaluate$3 });
-function evaluate$3(repo) {
-	const tasks = [];
-	let hasValidation = false;
-	const workflowsDir = join(repo.root, ".github", "workflows");
-	try {
-		if (statSync(workflowsDir).isDirectory()) for (const name of readdirSync(workflowsDir)) {
-			if (!name.endsWith(".yml") && !name.endsWith(".yaml")) continue;
-			const fullPath = join(workflowsDir, name);
-			try {
-				if (!statSync(fullPath).isFile()) continue;
-				const content = readFileSync(fullPath, "utf-8");
-				if (content.includes("validate_nodes") || content.includes("validate_members")) {
-					hasValidation = true;
-					break;
-				}
-			} catch {
-				continue;
-			}
-		}
-	} catch {}
-	if (!hasValidation) tasks.push("No validation workflow found — copy `.context-tree/workflows/validate.yml` to `.github/workflows/validate.yml`");
-	return {
-		group: "CI / Validation",
-		order: 6,
-		tasks
-	};
-}
-//#endregion
-//#region src/rules/framework.ts
-var framework_exports = /* @__PURE__ */ __exportAll({ evaluate: () => evaluate$2 });
-const SEED_TREE_URL$1 = "https://github.com/agent-team-foundation/seed-tree";
-function evaluate$2(repo) {
-	const tasks = [];
-	if (!repo.hasFramework()) tasks.push(`\`.context-tree/\` not found — run \`context-tree init\` to clone the framework from ${SEED_TREE_URL$1}`);
-	return {
-		group: "Framework",
-		order: 1,
-		tasks
-	};
-}
-//#endregion
-//#region src/rules/members.ts
-var members_exports = /* @__PURE__ */ __exportAll({ evaluate: () => evaluate$1 });
-function evaluate$1(repo) {
-	const tasks = [];
-	if (!repo.pathExists("members")) tasks.push("`members/` directory is missing — create it with a NODE.md");
-	else if (!repo.pathExists("members/NODE.md")) tasks.push("`members/NODE.md` is missing — create it from the template");
-	if (repo.hasMembers() && repo.memberCount() === 0) tasks.push("Add at least one member node for a team member or agent under `members/`");
-	else if (!repo.hasMembers()) tasks.push("Add at least one member node for a team member or agent under `members/`");
-	return {
-		group: "Members",
-		order: 4,
-		tasks
-	};
-}
-//#endregion
-//#region src/rules/root-node.ts
-var root_node_exports = /* @__PURE__ */ __exportAll({ evaluate: () => evaluate });
-function evaluate(repo) {
-	const tasks = [];
-	if (!repo.pathExists("NODE.md")) tasks.push("NODE.md is missing — create from `.context-tree/templates/root-node.md.template`, fill in your project's domains");
-	else {
-		const fm = repo.frontmatter("NODE.md");
-		if (fm === null) tasks.push("NODE.md exists but has no frontmatter — add frontmatter with title and owners fields");
-		else {
-			if (!fm.title || fm.title.startsWith("<")) tasks.push("NODE.md has a placeholder title — replace with your organization name");
-			if (!fm.owners || fm.owners.length === 0 || fm.owners.length === 1 && fm.owners[0].startsWith("<")) tasks.push("NODE.md has placeholder owners — set owners to your GitHub username(s)");
-		}
-		if (repo.hasPlaceholderNode()) tasks.push("NODE.md has placeholder content — fill in your project's domains and description");
-	}
-	return {
-		group: "Root Node",
-		order: 2,
-		tasks
-	};
-}
-//#endregion
-//#region src/rules/index.ts
-const ALL_RULES = [
-	framework_exports,
-	root_node_exports,
-	agent_instructions_exports,
-	members_exports,
-	agent_integration_exports,
-	ci_validation_exports
-];
-function evaluateAll(repo) {
-	const results = [];
-	for (const rule of ALL_RULES) {
-		const result = rule.evaluate(repo);
-		if (result.tasks.length > 0) results.push(result);
-	}
-	return results.sort((a, b) => a.order - b.order);
-}
-//#endregion
-//#region src/init.ts
-const SEED_TREE_URL = "https://github.com/agent-team-foundation/seed-tree";
-const FRAMEWORK_DIR = ".context-tree";
-const TEMPLATE_MAP = [
-	["root-node.md.template", "NODE.md"],
-	["agent.md.template", "AGENT.md"],
-	["members-domain.md.template", "members/NODE.md"]
-];
-function cloneSeedTree() {
-	const tmp = mkdtempSync(join(tmpdir(), "context-tree-"));
-	console.log(`Cloning seed-tree from ${SEED_TREE_URL}...`);
-	try {
-		execFileSync("git", [
-			"clone",
-			"--depth",
-			"1",
-			SEED_TREE_URL,
-			tmp
-		], {
-			encoding: "utf-8",
-			stdio: "pipe"
-		});
-	} catch (err) {
-		const message = err instanceof Error ? err.message : "unknown error";
-		console.error(`Failed to clone seed-tree: ${message}`);
-		rmSync(tmp, {
-			recursive: true,
-			force: true
-		});
-		process.exit(1);
-	}
-	return tmp;
-}
-function copyFramework(source, target) {
-	const src = join(source, FRAMEWORK_DIR);
-	const dst = join(target, FRAMEWORK_DIR);
-	if (existsSync(dst)) rmSync(dst, {
-		recursive: true,
-		force: true
-	});
-	cpSync(src, dst, { recursive: true });
-	console.log(`  Copied ${FRAMEWORK_DIR}/`);
-}
-function renderTemplates(frameworkDir, target) {
-	const templatesDir = join(frameworkDir, "templates");
-	for (const [templateName, targetPath] of TEMPLATE_MAP) {
-		const src = join(templatesDir, templateName);
-		const dst = join(target, targetPath);
-		if (existsSync(dst)) console.log(`  Skipped ${targetPath} (already exists)`);
-		else if (existsSync(src)) {
-			mkdirSync(dirname(dst), { recursive: true });
-			copyFileSync(src, dst);
-			console.log(`  Created ${targetPath}`);
-		}
-	}
-}
-function addUpstreamRemote(target) {
-	try {
-		if (!execFileSync("git", ["remote"], {
-			cwd: target,
-			encoding: "utf-8"
-		}).split(/\s+/).includes("context-tree-upstream")) {
-			execFileSync("git", [
-				"remote",
-				"add",
-				"context-tree-upstream",
-				SEED_TREE_URL
-			], {
-				cwd: target,
-				encoding: "utf-8",
-				stdio: "pipe"
-			});
-			console.log(`  Added git remote 'context-tree-upstream' -> ${SEED_TREE_URL}`);
-		}
-	} catch {}
-}
-function formatTaskList(groups) {
-	const lines = ["# Context Tree Init\n"];
-	for (const group of groups) {
-		lines.push(`## ${group.group}`);
-		for (const task of group.tasks) lines.push(`- [ ] ${task}`);
-		lines.push("");
-	}
-	lines.push("## Verification");
-	lines.push("After completing the tasks above, run `context-tree verify` to confirm:");
-	lines.push("- [ ] `.context-tree/VERSION` exists");
-	lines.push("- [ ] Root NODE.md has valid frontmatter (title, owners)");
-	lines.push("- [ ] AGENT.md exists with framework markers");
-	lines.push("- [ ] `context-tree verify` passes with no errors");
-	lines.push("- [ ] At least one member node exists");
-	lines.push("");
-	lines.push("---");
-	lines.push("");
-	lines.push("**Important:** As you complete each task, check it off in `.context-tree/progress.md` by changing `- [ ]` to `- [x]`. Run `context-tree verify` when done — it will fail if any items remain unchecked.");
-	lines.push("");
-	return lines.join("\n");
-}
-function writeProgress(repo, content) {
-	const progressPath = join(repo.root, ".context-tree", "progress.md");
-	mkdirSync(dirname(progressPath), { recursive: true });
-	writeFileSync(progressPath, content);
-}
-function runInit(repo) {
-	const r = repo ?? new Repo();
-	if (!r.isGitRepo()) {
-		console.error("Error: not a git repository. Initialize one first:\n  git init");
-		return 1;
-	}
-	if (!r.hasFramework()) {
-		const seed = cloneSeedTree();
-		try {
-			console.log("Copying framework and scaffolding...");
-			copyFramework(seed, r.root);
-			renderTemplates(join(r.root, FRAMEWORK_DIR), r.root);
-			addUpstreamRemote(r.root);
-		} finally {
-			rmSync(seed, {
-				recursive: true,
-				force: true
-			});
-		}
-		console.log();
-	}
-	const groups = evaluateAll(r);
-	if (groups.length === 0) {
-		console.log("All checks passed. Your context tree is set up.");
-		return 0;
-	}
-	const output = formatTaskList(groups);
-	console.log(output);
-	writeProgress(r, output);
-	console.log("Progress file written to .context-tree/progress.md");
-	return 0;
-}
-//#endregion
-export { runInit };