@os-eco/seeds-cli 0.2.0

package/src/commands/init.test.ts

@@ -0,0 +1,86 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+let tmpDir: string;
+
+// Path to the CLI entry point (relative to repo root)
+const CLI = join(import.meta.dir, "../../src/index.ts");
+
+async function run(
+	args: string[],
+	cwd: string,
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+	const proc = Bun.spawn(["bun", "run", CLI, ...args], {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const stdout = await new Response(proc.stdout).text();
+	const stderr = await new Response(proc.stderr).text();
+	const exitCode = await proc.exited;
+	return { stdout, stderr, exitCode };
+}
+
+beforeEach(async () => {
+	tmpDir = await mkdtemp(join(tmpdir(), "seeds-init-test-"));
+});
+
+afterEach(async () => {
+	await rm(tmpDir, { recursive: true, force: true });
+});
+
+describe("sd init", () => {
+	test("creates .seeds directory", async () => {
+		const { exitCode } = await run(["init"], tmpDir);
+		expect(exitCode).toBe(0);
+		const stat = await Bun.file(join(tmpDir, ".seeds", "config.yaml")).exists();
+		expect(stat).toBe(true);
+	});
+
+	test("creates config.yaml with project name", async () => {
+		await run(["init"], tmpDir);
+		const config = await Bun.file(join(tmpDir, ".seeds", "config.yaml")).text();
+		expect(config).toContain("project:");
+		expect(config).toContain("version:");
+	});
+
+	test("creates empty issues.jsonl", async () => {
+		await run(["init"], tmpDir);
+		const exists = await Bun.file(join(tmpDir, ".seeds", "issues.jsonl")).exists();
+		expect(exists).toBe(true);
+	});
+
+	test("creates empty templates.jsonl", async () => {
+		await run(["init"], tmpDir);
+		const exists = await Bun.file(join(tmpDir, ".seeds", "templates.jsonl")).exists();
+		expect(exists).toBe(true);
+	});
+
+	test("creates .gitignore ignoring lock files", async () => {
+		await run(["init"], tmpDir);
+		const gitignore = await Bun.file(join(tmpDir, ".seeds", ".gitignore")).text();
+		expect(gitignore).toContain("*.lock");
+	});
+
+	test("appends gitattributes to project root", async () => {
+		await run(["init"], tmpDir);
+		const gitattributes = await Bun.file(join(tmpDir, ".gitattributes")).text();
+		expect(gitattributes).toContain(".seeds/issues.jsonl merge=union");
+		expect(gitattributes).toContain(".seeds/templates.jsonl merge=union");
+	});
+
+	test("is idempotent — second init does not fail", async () => {
+		await run(["init"], tmpDir);
+		const { exitCode } = await run(["init"], tmpDir);
+		expect(exitCode).toBe(0);
+	});
+
+	test("--json flag returns success JSON", async () => {
+		const { stdout, exitCode } = await run(["init", "--json"], tmpDir);
+		expect(exitCode).toBe(0);
+		const result = JSON.parse(stdout) as { success: boolean };
+		expect(result.success).toBe(true);
+	});
+});

package/src/commands/init.ts

@@ -0,0 +1,49 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { outputJson, printSuccess } from "../output.ts";
+import { CONFIG_FILE, ISSUES_FILE, SEEDS_DIR_NAME, TEMPLATES_FILE } from "../types.ts";
+
+export async function run(args: string[]): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const cwd = process.cwd();
+	const seedsDir = join(cwd, SEEDS_DIR_NAME);
+
+	if (existsSync(join(seedsDir, CONFIG_FILE))) {
+		if (jsonMode) {
+			outputJson({ success: true, command: "init", dir: seedsDir });
+		} else {
+			printSuccess(`Already initialized: ${seedsDir}`);
+		}
+		return;
+	}
+
+	mkdirSync(seedsDir, { recursive: true });
+
+	// config.yaml
+	writeFileSync(join(seedsDir, CONFIG_FILE), 'project: "seeds"\nversion: "1"\n');
+
+	// empty JSONL files
+	writeFileSync(join(seedsDir, ISSUES_FILE), "");
+	writeFileSync(join(seedsDir, TEMPLATES_FILE), "");
+
+	// .gitignore inside .seeds/
+	writeFileSync(join(seedsDir, ".gitignore"), "*.lock\n");
+
+	// Append .gitattributes to project root
+	const gitattrsPath = join(cwd, ".gitattributes");
+	const entry = ".seeds/issues.jsonl merge=union\n.seeds/templates.jsonl merge=union\n";
+	if (existsSync(gitattrsPath)) {
+		const existing = readFileSync(gitattrsPath, "utf8");
+		if (!existing.includes(".seeds/issues.jsonl")) {
+			writeFileSync(gitattrsPath, `${existing}\n${entry}`);
+		}
+	} else {
+		writeFileSync(gitattrsPath, entry);
+	}
+
+	if (jsonMode) {
+		outputJson({ success: true, command: "init", dir: seedsDir });
+	} else {
+		printSuccess(`Initialized .seeds/ in ${cwd}`);
+	}
+}

package/src/commands/list.ts

@@ -0,0 +1,69 @@
+import { findSeedsDir } from "../config.ts";
+import { outputJson, printIssueOneLine } from "../output.ts";
+import { readIssues } from "../store.ts";
+import type { Issue } from "../types.ts";
+
+function parseArgs(args: string[]) {
+	const flags: Record<string, string | boolean> = {};
+	let i = 0;
+	while (i < args.length) {
+		const arg = args[i];
+		if (!arg) {
+			i++;
+			continue;
+		}
+		if (arg.startsWith("--")) {
+			const key = arg.slice(2);
+			const eqIdx = key.indexOf("=");
+			if (eqIdx !== -1) {
+				flags[key.slice(0, eqIdx)] = key.slice(eqIdx + 1);
+				i++;
+			} else {
+				const next = args[i + 1];
+				if (next !== undefined && !next.startsWith("--")) {
+					flags[key] = next;
+					i += 2;
+				} else {
+					flags[key] = true;
+					i++;
+				}
+			}
+		} else {
+			i++;
+		}
+	}
+	return flags;
+}
+
+export async function run(args: string[], seedsDir?: string): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const flags = parseArgs(args);
+
+	const statusFilter = typeof flags.status === "string" ? flags.status : undefined;
+	const typeFilter = typeof flags.type === "string" ? flags.type : undefined;
+	const assigneeFilter = typeof flags.assignee === "string" ? flags.assignee : undefined;
+	const limitStr = typeof flags.limit === "string" ? flags.limit : "50";
+	const limit = Number.parseInt(limitStr, 10) || 50;
+
+	const dir = seedsDir ?? (await findSeedsDir());
+	let issues = await readIssues(dir);
+
+	if (statusFilter) issues = issues.filter((i: Issue) => i.status === statusFilter);
+	if (typeFilter) issues = issues.filter((i: Issue) => i.type === typeFilter);
+	if (assigneeFilter) issues = issues.filter((i: Issue) => i.assignee === assigneeFilter);
+
+	issues = issues.slice(0, limit);
+
+	if (jsonMode) {
+		outputJson({ success: true, command: "list", issues, count: issues.length });
+	} else {
+		if (issues.length === 0) {
+			console.log("No issues found.");
+			return;
+		}
+		for (const issue of issues) {
+			printIssueOneLine(issue);
+		}
+		console.log(`\n${issues.length} issue(s)`);
+	}
+}

package/src/commands/migrate.ts

@@ -0,0 +1,117 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { findSeedsDir, projectRootFromSeedsDir } from "../config.ts";
+import { outputJson } from "../output.ts";
+import { issuesPath, readIssues, withLock, writeIssues } from "../store.ts";
+import type { Issue } from "../types.ts";
+
+interface BeadsIssue {
+	id?: string;
+	title?: string;
+	status?: string;
+	issue_type?: string;
+	type?: string;
+	priority?: number;
+	owner?: string;
+	assignee?: string;
+	description?: string;
+	close_reason?: string;
+	closeReason?: string;
+	blocks?: string[];
+	blocked_by?: string[];
+	blockedBy?: string[];
+	created_at?: string;
+	createdAt?: string;
+	updated_at?: string;
+	updatedAt?: string;
+	closed_at?: string;
+	closedAt?: string;
+}
+
+function mapStatus(s: string | undefined): Issue["status"] {
+	if (s === "in_progress" || s === "in-progress") return "in_progress";
+	if (s === "closed" || s === "done" || s === "complete") return "closed";
+	return "open";
+}
+
+function mapType(t: string | undefined): Issue["type"] {
+	if (t === "bug") return "bug";
+	if (t === "feature") return "feature";
+	if (t === "epic") return "epic";
+	return "task";
+}
+
+function mapBeadsIssue(b: BeadsIssue): Issue | null {
+	if (!b.id || !b.title) return null;
+	const now = new Date().toISOString();
+	const issue: Issue = {
+		id: b.id,
+		title: b.title,
+		status: mapStatus(b.status),
+		type: mapType(b.issue_type ?? b.type),
+		priority: b.priority ?? 2,
+		createdAt: b.created_at ?? b.createdAt ?? now,
+		updatedAt: b.updated_at ?? b.updatedAt ?? now,
+	};
+	const assignee = b.owner ?? b.assignee;
+	if (assignee) issue.assignee = assignee;
+	if (b.description) issue.description = b.description;
+	const closeReason = b.close_reason ?? b.closeReason;
+	if (closeReason) issue.closeReason = closeReason;
+	const blockedBy = b.blocked_by ?? b.blockedBy;
+	if (blockedBy?.length) issue.blockedBy = blockedBy;
+	if (b.blocks?.length) issue.blocks = b.blocks;
+	const closedAt = b.closed_at ?? b.closedAt;
+	if (closedAt) issue.closedAt = closedAt;
+	return issue;
+}
+
+export async function run(args: string[], seedsDir?: string): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const dir = seedsDir ?? (await findSeedsDir());
+	const projectRoot = projectRootFromSeedsDir(dir);
+
+	const beadsPath = join(projectRoot, ".beads", "issues.jsonl");
+	if (!existsSync(beadsPath)) {
+		throw new Error(`Beads issues not found at: ${beadsPath}`);
+	}
+
+	const file = Bun.file(beadsPath);
+	const content = await file.text();
+	const lines = content.split("\n").filter((l) => l.trim());
+
+	const beadsIssues: BeadsIssue[] = [];
+	for (const line of lines) {
+		try {
+			beadsIssues.push(JSON.parse(line) as BeadsIssue);
+		} catch {
+			// skip malformed lines
+		}
+	}
+
+	const mapped: Issue[] = [];
+	const skipped: string[] = [];
+	for (const b of beadsIssues) {
+		const issue = mapBeadsIssue(b);
+		if (issue) mapped.push(issue);
+		else skipped.push(b.id ?? "(unknown)");
+	}
+
+	let written = 0;
+	await withLock(issuesPath(dir), async () => {
+		const existing = await readIssues(dir);
+		const existingIds = new Set(existing.map((i) => i.id));
+		const newIssues = mapped.filter((i) => !existingIds.has(i.id));
+		await writeIssues(dir, [...existing, ...newIssues]);
+		written = newIssues.length;
+	});
+
+	if (jsonMode) {
+		outputJson({ success: true, command: "migrate-from-beads", written, skipped: skipped.length });
+	} else {
+		console.log(`Migrated ${written} issues from beads.`);
+		if (skipped.length > 0) {
+			console.log(`Skipped ${skipped.length} malformed issues.`);
+		}
+	}
+}

package/src/commands/onboard.test.ts

@@ -0,0 +1,155 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+let tmpDir: string;
+
+const CLI = join(import.meta.dir, "../../src/index.ts");
+
+async function run(
+	args: string[],
+	cwd: string,
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+	const proc = Bun.spawn(["bun", "run", CLI, ...args], {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const stdout = await new Response(proc.stdout).text();
+	const stderr = await new Response(proc.stderr).text();
+	const exitCode = await proc.exited;
+	return { stdout, stderr, exitCode };
+}
+
+async function initSeeds(cwd: string): Promise<void> {
+	await run(["init"], cwd);
+}
+
+beforeEach(async () => {
+	tmpDir = await mkdtemp(join(tmpdir(), "seeds-onboard-test-"));
+});
+
+afterEach(async () => {
+	await rm(tmpDir, { recursive: true, force: true });
+});
+
+describe("sd onboard", () => {
+	test("fails without .seeds/ initialized", async () => {
+		const { exitCode, stderr } = await run(["onboard"], tmpDir);
+		expect(exitCode).toBe(1);
+		expect(stderr).toContain("Not in a seeds project");
+	});
+
+	test("creates CLAUDE.md when no target file exists", async () => {
+		await initSeeds(tmpDir);
+		const { exitCode } = await run(["onboard"], tmpDir);
+		expect(exitCode).toBe(0);
+		const content = await Bun.file(join(tmpDir, "CLAUDE.md")).text();
+		expect(content).toContain("<!-- seeds:start -->");
+		expect(content).toContain("<!-- seeds:end -->");
+		expect(content).toContain("Issue Tracking (Seeds)");
+		expect(content).toContain("sd prime");
+	});
+
+	test("appends to existing CLAUDE.md", async () => {
+		await initSeeds(tmpDir);
+		await Bun.write(join(tmpDir, "CLAUDE.md"), "# My Project\n\nExisting content.\n");
+		const { exitCode } = await run(["onboard"], tmpDir);
+		expect(exitCode).toBe(0);
+		const content = await Bun.file(join(tmpDir, "CLAUDE.md")).text();
+		expect(content).toContain("# My Project");
+		expect(content).toContain("Existing content.");
+		expect(content).toContain("<!-- seeds:start -->");
+		expect(content).toContain("Issue Tracking (Seeds)");
+	});
+
+	test("is idempotent — second onboard does not duplicate", async () => {
+		await initSeeds(tmpDir);
+		await run(["onboard"], tmpDir);
+		const first = await Bun.file(join(tmpDir, "CLAUDE.md")).text();
+		await run(["onboard"], tmpDir);
+		const second = await Bun.file(join(tmpDir, "CLAUDE.md")).text();
+		expect(second).toBe(first);
+	});
+
+	test("--check reports missing when no file exists", async () => {
+		await initSeeds(tmpDir);
+		const { stdout, exitCode } = await run(["onboard", "--check"], tmpDir);
+		expect(exitCode).toBe(0);
+		expect(stdout).toContain("missing");
+	});
+
+	test("--check reports current after onboard", async () => {
+		await initSeeds(tmpDir);
+		await run(["onboard"], tmpDir);
+		const { stdout, exitCode } = await run(["onboard", "--check"], tmpDir);
+		expect(exitCode).toBe(0);
+		expect(stdout).toContain("current");
+	});
+
+	test("--check with --json returns structured output", async () => {
+		await initSeeds(tmpDir);
+		await run(["onboard"], tmpDir);
+		const { stdout, exitCode } = await run(["onboard", "--check", "--json"], tmpDir);
+		expect(exitCode).toBe(0);
+		const result = JSON.parse(stdout) as { success: boolean; status: string };
+		expect(result.success).toBe(true);
+		expect(result.status).toBe("current");
+	});
+
+	test("--stdout prints snippet without writing", async () => {
+		await initSeeds(tmpDir);
+		const { stdout, exitCode } = await run(["onboard", "--stdout"], tmpDir);
+		expect(exitCode).toBe(0);
+		expect(stdout).toContain("<!-- seeds:start -->");
+		expect(stdout).toContain("Issue Tracking (Seeds)");
+		// Should not have created the file
+		const exists = await Bun.file(join(tmpDir, "CLAUDE.md")).exists();
+		expect(exists).toBe(false);
+	});
+
+	test("detects existing CLAUDE.md in .claude/ subdirectory", async () => {
+		await initSeeds(tmpDir);
+		const claudeDir = join(tmpDir, ".claude");
+		await Bun.write(join(claudeDir, "CLAUDE.md"), "# Agent Instructions\n");
+		const { exitCode } = await run(["onboard"], tmpDir);
+		expect(exitCode).toBe(0);
+		const content = await Bun.file(join(claudeDir, "CLAUDE.md")).text();
+		expect(content).toContain("<!-- seeds:start -->");
+		// Root CLAUDE.md should NOT have been created
+		const rootExists = await Bun.file(join(tmpDir, "CLAUDE.md")).exists();
+		expect(rootExists).toBe(false);
+	});
+
+	test("updates outdated section when version changes", async () => {
+		await initSeeds(tmpDir);
+		// Write a seeds section with an old version marker
+		const oldContent =
+			"# Project\n\n<!-- seeds:start -->\n## Old Seeds Section\n<!-- seeds-onboard-v:0 -->\nold content\n<!-- seeds:end -->\n";
+		await Bun.write(join(tmpDir, "CLAUDE.md"), oldContent);
+		const { exitCode } = await run(["onboard"], tmpDir);
+		expect(exitCode).toBe(0);
+		const content = await Bun.file(join(tmpDir, "CLAUDE.md")).text();
+		expect(content).toContain("# Project");
+		expect(content).toContain("seeds-onboard-v:1");
+		expect(content).not.toContain("seeds-onboard-v:0");
+		expect(content).not.toContain("Old Seeds Section");
+	});
+
+	test("--json output on create", async () => {
+		await initSeeds(tmpDir);
+		const { stdout, exitCode } = await run(["onboard", "--json"], tmpDir);
+		expect(exitCode).toBe(0);
+		const result = JSON.parse(stdout) as { success: boolean; action: string };
+		expect(result.success).toBe(true);
+		expect(result.action).toBe("created");
+	});
+
+	test("includes version marker in output", async () => {
+		await initSeeds(tmpDir);
+		await run(["onboard"], tmpDir);
+		const content = await Bun.file(join(tmpDir, "CLAUDE.md")).text();
+		expect(content).toContain("seeds-onboard-v:1");
+	});
+});

package/src/commands/onboard.ts

@@ -0,0 +1,140 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { findSeedsDir, projectRootFromSeedsDir } from "../config.ts";
+import { hasMarkerSection, replaceMarkerSection, wrapInMarkers } from "../markers.ts";
+import { outputJson, printSuccess } from "../output.ts";
+
+const ONBOARD_VERSION = 1;
+const VERSION_MARKER = `<!-- seeds-onboard-v:${String(ONBOARD_VERSION)} -->`;
+
+const CANDIDATE_FILES = ["CLAUDE.md", ".claude/CLAUDE.md", "AGENTS.md"] as const;
+
+function onboardSnippet(): string {
+	return `## Issue Tracking (Seeds)
+${VERSION_MARKER}
+
+This project uses [Seeds](https://github.com/jayminwest/seeds) for git-native issue tracking.
+
+**At the start of every session**, run:
+\`\`\`
+sd prime
+\`\`\`
+
+This injects session context: rules, command reference, and workflows.
+
+**Quick reference:**
+- \`sd ready\` — Find unblocked work
+- \`sd create --title "..." --type task --priority 2\` — Create issue
+- \`sd update <id> --status in_progress\` — Claim work
+- \`sd close <id>\` — Complete work
+- \`sd sync\` — Sync with git (run before pushing)
+
+### Before You Finish
+1. Close completed issues: \`sd close <id>\`
+2. File issues for remaining work: \`sd create --title "..."\`
+3. Sync and push: \`sd sync && git push\``;
+}
+
+function findTargetFile(projectRoot: string): string | null {
+	for (const candidate of CANDIDATE_FILES) {
+		const fullPath = join(projectRoot, candidate);
+		if (existsSync(fullPath)) {
+			return fullPath;
+		}
+	}
+	return null;
+}
+
+function detectStatus(content: string): "missing" | "current" | "outdated" {
+	if (!hasMarkerSection(content)) return "missing";
+	if (content.includes(VERSION_MARKER)) return "current";
+	return "outdated";
+}
+
+export async function run(args: string[]): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const stdoutMode = args.includes("--stdout");
+	const checkMode = args.includes("--check");
+
+	const seedsDir = await findSeedsDir();
+	const projectRoot = projectRootFromSeedsDir(seedsDir);
+
+	const targetPath = findTargetFile(projectRoot);
+	const snippet = onboardSnippet();
+
+	// --check mode: report status only
+	if (checkMode) {
+		if (!targetPath) {
+			if (jsonMode) {
+				outputJson({ success: true, command: "onboard", status: "missing", file: null });
+			} else {
+				console.log("Status: missing (no CLAUDE.md found)");
+			}
+			return;
+		}
+		const content = await Bun.file(targetPath).text();
+		const status = detectStatus(content);
+		if (jsonMode) {
+			outputJson({ success: true, command: "onboard", status, file: targetPath });
+		} else {
+			console.log(`Status: ${status} (${targetPath})`);
+		}
+		return;
+	}
+
+	// --stdout mode: print what would be written
+	if (stdoutMode) {
+		process.stdout.write(wrapInMarkers(snippet));
+		process.stdout.write("\n");
+		return;
+	}
+
+	// Default mode: write to file
+	const filePath = targetPath ?? join(projectRoot, "CLAUDE.md");
+	const fileExists = existsSync(filePath);
+	const wrappedSnippet = wrapInMarkers(snippet);
+
+	if (!fileExists) {
+		await Bun.write(filePath, `${wrappedSnippet}\n`);
+		if (jsonMode) {
+			outputJson({ success: true, command: "onboard", action: "created", file: filePath });
+		} else {
+			printSuccess(`Created ${filePath} with seeds section`);
+		}
+		return;
+	}
+
+	const content = await Bun.file(filePath).text();
+	const status = detectStatus(content);
+
+	if (status === "current") {
+		if (jsonMode) {
+			outputJson({ success: true, command: "onboard", action: "unchanged", file: filePath });
+		} else {
+			printSuccess("Seeds section is already up to date");
+		}
+		return;
+	}
+
+	if (status === "outdated") {
+		const updated = replaceMarkerSection(content, snippet);
+		if (updated) {
+			await Bun.write(filePath, updated);
+			if (jsonMode) {
+				outputJson({ success: true, command: "onboard", action: "updated", file: filePath });
+			} else {
+				printSuccess(`Updated seeds section in ${filePath}`);
+			}
+		}
+		return;
+	}
+
+	// status === "missing": append
+	const separator = content.endsWith("\n") ? "\n" : "\n\n";
+	await Bun.write(filePath, `${content}${separator}${wrappedSnippet}\n`);
+	if (jsonMode) {
+		outputJson({ success: true, command: "onboard", action: "appended", file: filePath });
+	} else {
+		printSuccess(`Added seeds section to ${filePath}`);
+	}
+}