@os-eco/seeds-cli 0.2.0

package/src/commands/prime.test.ts

@@ -0,0 +1,94 @@
+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-prime-test-"));
+});
+
+afterEach(async () => {
+	await rm(tmpDir, { recursive: true, force: true });
+});
+
+describe("sd prime", () => {
+	test("outputs full prime content without .seeds/ initialized", async () => {
+		const { stdout, exitCode } = await run(["prime"], tmpDir);
+		expect(exitCode).toBe(0);
+		expect(stdout).toContain("Seeds Workflow Context");
+		expect(stdout).toContain("Session Close Protocol");
+		expect(stdout).toContain("sd ready");
+	});
+
+	test("outputs compact content with --compact", async () => {
+		const { stdout, exitCode } = await run(["prime", "--compact"], tmpDir);
+		expect(exitCode).toBe(0);
+		expect(stdout).toContain("Seeds Quick Reference");
+		expect(stdout).not.toContain("Session Close Protocol");
+	});
+
+	test("outputs JSON with --json", async () => {
+		const { stdout, exitCode } = await run(["prime", "--json"], tmpDir);
+		expect(exitCode).toBe(0);
+		const result = JSON.parse(stdout) as { success: boolean; command: string; content: string };
+		expect(result.success).toBe(true);
+		expect(result.command).toBe("prime");
+		expect(result.content).toContain("Seeds Workflow Context");
+	});
+
+	test("--export outputs default template even with custom PRIME.md", async () => {
+		await initSeeds(tmpDir);
+		await Bun.write(join(tmpDir, ".seeds", "PRIME.md"), "custom prime content");
+		const { stdout, exitCode } = await run(["prime", "--export"], tmpDir);
+		expect(exitCode).toBe(0);
+		expect(stdout).toContain("Seeds Workflow Context");
+		expect(stdout).not.toContain("custom prime content");
+	});
+
+	test("uses custom PRIME.md when present", async () => {
+		await initSeeds(tmpDir);
+		await Bun.write(join(tmpDir, ".seeds", "PRIME.md"), "my custom agent context");
+		const { stdout, exitCode } = await run(["prime"], tmpDir);
+		expect(exitCode).toBe(0);
+		expect(stdout).toBe("my custom agent context");
+	});
+
+	test("full content includes essential command sections", async () => {
+		const { stdout } = await run(["prime"], tmpDir);
+		expect(stdout).toContain("Finding Work");
+		expect(stdout).toContain("Creating & Updating");
+		expect(stdout).toContain("Dependencies & Blocking");
+		expect(stdout).toContain("Common Workflows");
+	});
+
+	test("--export with --json returns JSON", async () => {
+		const { stdout, exitCode } = await run(["prime", "--export", "--json"], tmpDir);
+		expect(exitCode).toBe(0);
+		const result = JSON.parse(stdout) as { success: boolean; content: string };
+		expect(result.success).toBe(true);
+		expect(result.content).toContain("Seeds Workflow Context");
+	});
+});

package/src/commands/prime.ts

@@ -0,0 +1,146 @@
+import { join } from "node:path";
+import { findSeedsDir } from "../config.ts";
+import { outputJson } from "../output.ts";
+
+const PRIME_FILE = "PRIME.md";
+
+function defaultPrimeContent(compact: boolean): string {
+	if (compact) {
+		return compactContent();
+	}
+	return fullContent();
+}
+
+function compactContent(): string {
+	return `# Seeds Quick Reference
+
+\`\`\`
+sd ready                  # Find unblocked work
+sd show <id>              # View issue details
+sd create --title "..."   # Create issue (--type, --priority)
+sd update <id> --status in_progress  # Claim work
+sd close <id>             # Complete work
+sd dep add <a> <b>        # a depends on b
+sd blocked                # Show blocked issues
+sd sync                   # Stage + commit .seeds/
+\`\`\`
+
+**Before finishing:** \`sd close <ids> && sd sync && git push\`
+`;
+}
+
+function fullContent(): string {
+	return `# Seeds Workflow Context
+
+> **Context Recovery**: Run \`sd prime\` after compaction, clear, or new session
+
+# Session Close Protocol
+
+**CRITICAL**: Before saying "done" or "complete", you MUST run this checklist:
+
+\`\`\`
+[ ] 1. Close completed issues:    sd close <id1> <id2> ...
+[ ] 2. File issues for remaining:  sd create --title "..."
+[ ] 3. Run quality gates:          bun test && bun run lint && bun run typecheck
+[ ] 4. Sync and push:              sd sync && git push
+[ ] 5. Verify:                     git status (must show "up to date with origin")
+\`\`\`
+
+**NEVER skip this.** Work is not done until pushed.
+
+## Core Rules
+- **Default**: Use seeds for ALL task tracking (\`sd create\`, \`sd ready\`, \`sd close\`)
+- **Prohibited**: Do NOT use TodoWrite, TaskCreate, or markdown files for task tracking
+- **Workflow**: Create issues BEFORE writing code, mark in_progress when starting
+- Git workflow: run \`sd sync\` at session end
+
+## Essential Commands
+
+### Finding Work
+- \`sd ready\` — Show issues ready to work (no blockers)
+- \`sd list --status=open\` — All open issues
+- \`sd list --status=in_progress\` — Your active work
+- \`sd show <id>\` — Detailed issue view with dependencies
+
+### Creating & Updating
+- \`sd create --title="..." --type=task|bug|feature|epic --priority=2\` — New issue
+  - Priority: 0-4 or P0-P4 (0=critical, 2=medium, 4=backlog)
+- \`sd update <id> --status=in_progress\` — Claim work
+- \`sd update <id> --assignee=username\` — Assign to someone
+- \`sd close <id>\` — Mark complete
+- \`sd close <id1> <id2> ...\` — Close multiple issues at once
+
+### Dependencies & Blocking
+- \`sd dep add <issue> <depends-on>\` — Add dependency
+- \`sd dep remove <issue> <depends-on>\` — Remove dependency
+- \`sd blocked\` — Show all blocked issues
+
+### Sync & Project Health
+- \`sd sync\` — Stage and commit .seeds/ changes
+- \`sd sync --status\` — Check without committing
+- \`sd stats\` — Project statistics
+- \`sd doctor\` — Check for data integrity issues
+
+## Common Workflows
+
+**Starting work:**
+\`\`\`bash
+sd ready                              # Find available work
+sd show <id>                          # Review issue details
+sd update <id> --status=in_progress   # Claim it
+\`\`\`
+
+**Completing work:**
+\`\`\`bash
+sd close <id1> <id2> ...    # Close all completed issues at once
+sd sync                     # Stage + commit .seeds/
+git push                    # Push to remote
+\`\`\`
+
+**Creating dependent work:**
+\`\`\`bash
+sd create --title="Implement feature X" --type=feature
+sd create --title="Write tests for X" --type=task
+sd dep add <test-id> <feature-id>   # Tests depend on feature
+\`\`\`
+`;
+}
+
+export async function run(args: string[]): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const compact = args.includes("--compact");
+	const exportMode = args.includes("--export");
+
+	// --export always outputs the default template
+	if (exportMode) {
+		const content = defaultPrimeContent(false);
+		if (jsonMode) {
+			outputJson({ success: true, command: "prime", content });
+		} else {
+			process.stdout.write(content);
+		}
+		return;
+	}
+
+	// Try to find seeds dir for custom PRIME.md
+	let content: string | null = null;
+	try {
+		const seedsDir = await findSeedsDir();
+		const customFile = Bun.file(join(seedsDir, PRIME_FILE));
+		if (await customFile.exists()) {
+			content = await customFile.text();
+		}
+	} catch {
+		// No seeds dir — that's fine, use default
+	}
+
+	if (!content) {
+		content = defaultPrimeContent(compact);
+	}
+
+	if (jsonMode) {
+		outputJson({ success: true, command: "prime", content });
+	} else {
+		process.stdout.write(content);
+	}
+}

package/src/commands/ready.ts

@@ -0,0 +1,31 @@
+import { findSeedsDir } from "../config.ts";
+import { outputJson, printIssueOneLine } from "../output.ts";
+import { readIssues } from "../store.ts";
+import type { Issue } from "../types.ts";
+
+export async function run(args: string[], seedsDir?: string): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const dir = seedsDir ?? (await findSeedsDir());
+	const issues = await readIssues(dir);
+
+	const closedIds = new Set(issues.filter((i: Issue) => i.status === "closed").map((i) => i.id));
+
+	const ready = issues.filter((i: Issue) => {
+		if (i.status !== "open") return false;
+		const blockers = i.blockedBy ?? [];
+		return blockers.every((bid) => closedIds.has(bid));
+	});
+
+	if (jsonMode) {
+		outputJson({ success: true, command: "ready", issues: ready, count: ready.length });
+	} else {
+		if (ready.length === 0) {
+			console.log("No ready issues.");
+			return;
+		}
+		for (const issue of ready) {
+			printIssueOneLine(issue);
+		}
+		console.log(`\n${ready.length} ready issue(s)`);
+	}
+}

package/src/commands/show.ts

@@ -0,0 +1,20 @@
+import { findSeedsDir } from "../config.ts";
+import { outputJson, printIssueFull } from "../output.ts";
+import { readIssues } from "../store.ts";
+
+export async function run(args: string[], seedsDir?: string): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const id = args.find((a) => !a.startsWith("--"));
+	if (!id) throw new Error("Usage: sd show <id>");
+
+	const dir = seedsDir ?? (await findSeedsDir());
+	const issues = await readIssues(dir);
+	const issue = issues.find((i) => i.id === id);
+	if (!issue) throw new Error(`Issue not found: ${id}`);
+
+	if (jsonMode) {
+		outputJson({ success: true, command: "show", issue });
+	} else {
+		printIssueFull(issue);
+	}
+}

package/src/commands/stats.ts

@@ -0,0 +1,58 @@
+import { findSeedsDir } from "../config.ts";
+import { c, outputJson } from "../output.ts";
+import { readIssues } from "../store.ts";
+import type { Issue } from "../types.ts";
+import { PRIORITY_LABELS } from "../types.ts";
+
+export async function run(args: string[], seedsDir?: string): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const dir = seedsDir ?? (await findSeedsDir());
+	const issues = await readIssues(dir);
+
+	const total = issues.length;
+	const open = issues.filter((i: Issue) => i.status === "open").length;
+	const inProgress = issues.filter((i: Issue) => i.status === "in_progress").length;
+	const closed = issues.filter((i: Issue) => i.status === "closed").length;
+
+	const closedIds = new Set(issues.filter((i: Issue) => i.status === "closed").map((i) => i.id));
+	const blocked = issues.filter((i: Issue) => {
+		if (i.status === "closed") return false;
+		return (i.blockedBy ?? []).some((bid) => !closedIds.has(bid));
+	}).length;
+
+	const byType: Record<string, number> = {};
+	for (const issue of issues) {
+		byType[issue.type] = (byType[issue.type] ?? 0) + 1;
+	}
+
+	const byPriority: Record<number, number> = {};
+	for (const issue of issues) {
+		byPriority[issue.priority] = (byPriority[issue.priority] ?? 0) + 1;
+	}
+
+	if (jsonMode) {
+		outputJson({
+			success: true,
+			command: "stats",
+			stats: { total, open, inProgress, closed, blocked, byType, byPriority },
+		});
+	} else {
+		console.log(`${c.bold}Project Statistics${c.reset}`);
+		console.log(`  Total:       ${total}`);
+		console.log(`  Open:        ${open}`);
+		console.log(`  In progress: ${inProgress}`);
+		console.log(`  Closed:      ${closed}`);
+		console.log(`  Blocked:     ${blocked}`);
+		console.log(`\n${c.bold}By Type${c.reset}`);
+		for (const [type, count] of Object.entries(byType)) {
+			console.log(`  ${type.padEnd(10)} ${count}`);
+		}
+		if (Object.keys(byPriority).length > 0) {
+			console.log(`\n${c.bold}By Priority${c.reset}`);
+			for (const [p, count] of Object.entries(byPriority)) {
+				const label = PRIORITY_LABELS[Number(p)] ?? String(p);
+				console.log(`  P${p} ${label.padEnd(10)} ${count}`);
+			}
+		}
+	}
+}

package/src/commands/sync.ts

@@ -0,0 +1,76 @@
+import { findSeedsDir, projectRootFromSeedsDir } from "../config.ts";
+import { outputJson } from "../output.ts";
+import { SEEDS_DIR_NAME } from "../types.ts";
+
+function spawnSync(
+	cmd: string[],
+	cwd: string,
+): { stdout: string; stderr: string; exitCode: number } {
+	const result = Bun.spawnSync(cmd, { cwd, stdout: "pipe", stderr: "pipe" });
+	const stdout = new TextDecoder().decode(result.stdout);
+	const stderr = new TextDecoder().decode(result.stderr);
+	return { stdout, stderr, exitCode: result.exitCode ?? 0 };
+}
+
+export async function run(args: string[], seedsDir?: string): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const statusOnly = args.includes("--status");
+
+	const dir = seedsDir ?? (await findSeedsDir());
+	const projectRoot = projectRootFromSeedsDir(dir);
+
+	const statusResult = spawnSync(
+		["git", "-C", projectRoot, "status", "--porcelain", `${SEEDS_DIR_NAME}/`],
+		projectRoot,
+	);
+
+	const changed = statusResult.stdout.trim();
+
+	if (statusOnly) {
+		if (jsonMode) {
+			outputJson({ success: true, command: "sync", hasChanges: !!changed, changes: changed });
+		} else {
+			if (changed) {
+				console.log("Uncommitted .seeds/ changes:");
+				console.log(changed);
+			} else {
+				console.log("No uncommitted .seeds/ changes.");
+			}
+		}
+		return;
+	}
+
+	if (!changed) {
+		if (jsonMode) {
+			outputJson({
+				success: true,
+				command: "sync",
+				committed: false,
+				message: "Nothing to commit",
+			});
+		} else {
+			console.log("No changes to commit.");
+		}
+		return;
+	}
+
+	// Stage
+	const addResult = spawnSync(["git", "-C", projectRoot, "add", `${SEEDS_DIR_NAME}/`], projectRoot);
+	if (addResult.exitCode !== 0) {
+		throw new Error(`git add failed: ${addResult.stderr}`);
+	}
+
+	// Commit
+	const date = new Date().toISOString().slice(0, 10);
+	const msg = `seeds: sync ${date}`;
+	const commitResult = spawnSync(["git", "-C", projectRoot, "commit", "-m", msg], projectRoot);
+	if (commitResult.exitCode !== 0) {
+		throw new Error(`git commit failed: ${commitResult.stderr}`);
+	}
+
+	if (jsonMode) {
+		outputJson({ success: true, command: "sync", committed: true, message: msg });
+	} else {
+		console.log(`Committed: ${msg}`);
+	}
+}