@os-eco/seeds-cli 0.2.0

package/src/store.ts

@@ -0,0 +1,143 @@
+import { randomBytes } from "node:crypto";
+import { closeSync, openSync, renameSync, statSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import type { Issue, Template } from "./types.ts";
+import {
+	ISSUES_FILE,
+	LOCK_RETRY_MS,
+	LOCK_STALE_MS,
+	LOCK_TIMEOUT_MS,
+	TEMPLATES_FILE,
+} from "./types.ts";
+
+function lockFilePath(dataFilePath: string): string {
+	return `${dataFilePath}.lock`;
+}
+
+async function acquireLock(dataFilePath: string): Promise<void> {
+	const lock = lockFilePath(dataFilePath);
+	const start = Date.now();
+	while (true) {
+		try {
+			const fd = openSync(lock, "wx");
+			closeSync(fd);
+			return;
+		} catch (err: unknown) {
+			const nodeErr = err as NodeJS.ErrnoException;
+			if (nodeErr.code !== "EEXIST") throw err;
+			// Check if stale
+			try {
+				const st = statSync(lock);
+				if (Date.now() - st.mtimeMs > LOCK_STALE_MS) {
+					unlinkSync(lock);
+					continue;
+				}
+			} catch {
+				continue;
+			}
+			if (Date.now() - start > LOCK_TIMEOUT_MS) {
+				throw new Error(`Timeout acquiring lock for ${dataFilePath}`);
+			}
+			await sleep(LOCK_RETRY_MS);
+		}
+	}
+}
+
+function releaseLock(dataFilePath: string): void {
+	try {
+		unlinkSync(lockFilePath(dataFilePath));
+	} catch {
+		// best-effort
+	}
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function withLock<T>(dataFilePath: string, fn: () => Promise<T>): Promise<T> {
+	await acquireLock(dataFilePath);
+	try {
+		return await fn();
+	} finally {
+		releaseLock(dataFilePath);
+	}
+}
+
+function parseJsonl<T>(content: string): T[] {
+	const results: T[] = [];
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			results.push(JSON.parse(trimmed) as T);
+		} catch {
+			// skip malformed lines
+		}
+	}
+	return results;
+}
+
+function deduplicateById<T extends { id: string }>(items: T[]): T[] {
+	const map = new Map<string, T>();
+	for (const item of items) {
+		map.set(item.id, item); // last occurrence wins
+	}
+	return Array.from(map.values());
+}
+
+export async function readIssues(seedsDir: string): Promise<Issue[]> {
+	const file = Bun.file(join(seedsDir, ISSUES_FILE));
+	if (!(await file.exists())) return [];
+	const content = await file.text();
+	return deduplicateById(parseJsonl<Issue>(content));
+}
+
+export async function writeIssues(seedsDir: string, issues: Issue[]): Promise<void> {
+	const filePath = join(seedsDir, ISSUES_FILE);
+	const tmpPath = `${filePath}.tmp.${randomBytes(4).toString("hex")}`;
+	const content = `${issues.map((i) => JSON.stringify(i)).join("\n")}\n`;
+	await Bun.write(tmpPath, content);
+	renameSync(tmpPath, filePath);
+}
+
+export async function appendIssue(seedsDir: string, issue: Issue): Promise<void> {
+	const filePath = join(seedsDir, ISSUES_FILE);
+	const tmpPath = `${filePath}.tmp.${randomBytes(4).toString("hex")}`;
+	const file = Bun.file(filePath);
+	const existing = (await file.exists()) ? await file.text() : "";
+	await Bun.write(tmpPath, `${existing + JSON.stringify(issue)}\n`);
+	renameSync(tmpPath, filePath);
+}
+
+export async function readTemplates(seedsDir: string): Promise<Template[]> {
+	const file = Bun.file(join(seedsDir, TEMPLATES_FILE));
+	if (!(await file.exists())) return [];
+	const content = await file.text();
+	return deduplicateById(parseJsonl<Template>(content));
+}
+
+export async function writeTemplates(seedsDir: string, templates: Template[]): Promise<void> {
+	const filePath = join(seedsDir, TEMPLATES_FILE);
+	const tmpPath = `${filePath}.tmp.${randomBytes(4).toString("hex")}`;
+	const content = `${templates.map((t) => JSON.stringify(t)).join("\n")}\n`;
+	await Bun.write(tmpPath, content);
+	renameSync(tmpPath, filePath);
+}
+
+export async function appendTemplate(seedsDir: string, template: Template): Promise<void> {
+	const filePath = join(seedsDir, TEMPLATES_FILE);
+	const tmpPath = `${filePath}.tmp.${randomBytes(4).toString("hex")}`;
+	const file = Bun.file(filePath);
+	const existing = (await file.exists()) ? await file.text() : "";
+	await Bun.write(tmpPath, `${existing + JSON.stringify(template)}\n`);
+	renameSync(tmpPath, filePath);
+}
+
+export function issuesPath(seedsDir: string): string {
+	return join(seedsDir, ISSUES_FILE);
+}
+
+export function templatesPath(seedsDir: string): string {
+	return join(seedsDir, TEMPLATES_FILE);
+}

package/src/types.ts

@@ -0,0 +1,61 @@
+export interface Issue {
+	id: string;
+	title: string;
+	status: "open" | "in_progress" | "closed";
+	type: "task" | "bug" | "feature" | "epic";
+	priority: number;
+	assignee?: string;
+	description?: string;
+	closeReason?: string;
+	blocks?: string[];
+	blockedBy?: string[];
+	convoy?: string;
+	createdAt: string;
+	updatedAt: string;
+	closedAt?: string;
+}
+
+export interface TemplateStep {
+	title: string;
+	type?: string;
+	priority?: number;
+}
+
+export interface Template {
+	id: string;
+	name: string;
+	steps: TemplateStep[];
+}
+
+export interface Config {
+	project: string;
+	version: string;
+}
+
+export interface ConvoyStatus {
+	templateId: string;
+	total: number;
+	completed: number;
+	inProgress: number;
+	blocked: number;
+	issues: string[];
+}
+
+export const SEEDS_DIR_NAME = ".seeds";
+export const ISSUES_FILE = "issues.jsonl";
+export const TEMPLATES_FILE = "templates.jsonl";
+export const CONFIG_FILE = "config.yaml";
+export const LOCK_STALE_MS = 30_000;
+export const LOCK_RETRY_MS = 50;
+export const LOCK_TIMEOUT_MS = 5_000;
+
+export const VALID_TYPES = ["task", "bug", "feature", "epic"] as const;
+export const VALID_STATUSES = ["open", "in_progress", "closed"] as const;
+
+export const PRIORITY_LABELS: Record<number, string> = {
+	0: "Critical",
+	1: "High",
+	2: "Medium",
+	3: "Low",
+	4: "Backlog",
+};

package/src/yaml.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, test } from "bun:test";
+import { parseYaml, stringifyYaml } from "./yaml";
+
+describe("parseYaml", () => {
+	test("parses simple key-value pairs", () => {
+		const result = parseYaml('project: overstory\nversion: "1"');
+		expect(result.project).toBe("overstory");
+		expect(result.version).toBe("1");
+	});
+
+	test("parses unquoted string values", () => {
+		const result = parseYaml("name: myapp");
+		expect(result.name).toBe("myapp");
+	});
+
+	test("parses double-quoted string values", () => {
+		const result = parseYaml('version: "1.0.0"');
+		expect(result.version).toBe("1.0.0");
+	});
+
+	test("parses single-quoted string values", () => {
+		const result = parseYaml("name: 'myapp'");
+		expect(result.name).toBe("myapp");
+	});
+
+	test("ignores blank lines", () => {
+		const result = parseYaml("project: seeds\n\nversion: 1");
+		expect(result.project).toBe("seeds");
+		expect(result.version).toBe("1");
+	});
+
+	test("ignores comment lines", () => {
+		const result = parseYaml("# This is a comment\nproject: seeds");
+		expect(result.project).toBe("seeds");
+		expect(Object.keys(result)).not.toContain("# This is a comment");
+	});
+
+	test("returns empty object for empty string", () => {
+		const result = parseYaml("");
+		expect(Object.keys(result)).toHaveLength(0);
+	});
+
+	test("parses config.yaml format used by seeds", () => {
+		const yaml = 'project: overstory\nversion: "1"';
+		const result = parseYaml(yaml);
+		expect(result).toEqual({ project: "overstory", version: "1" });
+	});
+
+	test("handles values with colons in quoted strings", () => {
+		const result = parseYaml('url: "http://example.com"');
+		expect(result.url).toBe("http://example.com");
+	});
+
+	test("trims whitespace from keys and values", () => {
+		const result = parseYaml("  project : seeds  ");
+		expect(result.project).toBe("seeds");
+	});
+});
+
+describe("stringifyYaml", () => {
+	test("serializes simple key-value pairs", () => {
+		const yaml = stringifyYaml({ project: "seeds", version: "1" });
+		const parsed = parseYaml(yaml);
+		expect(parsed.project).toBe("seeds");
+		expect(parsed.version).toBe("1");
+	});
+
+	test("round-trips flat objects", () => {
+		const original = { project: "overstory", version: "1" };
+		const yaml = stringifyYaml(original);
+		const parsed = parseYaml(yaml);
+		expect(parsed).toEqual(original);
+	});
+
+	test("produces newline-terminated output", () => {
+		const yaml = stringifyYaml({ key: "value" });
+		expect(yaml.endsWith("\n")).toBe(true);
+	});
+});

package/src/yaml.ts

@@ -0,0 +1,27 @@
+/**
+ * Minimal YAML parser for flat key-value format.
+ * Only handles: key: value (string values, no nesting or arrays).
+ */
+export function parseYaml(content: string): Record<string, string> {
+	const result: Record<string, string> = {};
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const colonIdx = trimmed.indexOf(":");
+		if (colonIdx === -1) continue;
+		const key = trimmed.slice(0, colonIdx).trim();
+		const raw = trimmed.slice(colonIdx + 1).trim();
+		if ((raw.startsWith('"') && raw.endsWith('"')) || (raw.startsWith("'") && raw.endsWith("'"))) {
+			result[key] = raw.slice(1, -1);
+		} else {
+			result[key] = raw;
+		}
+	}
+	return result;
+}
+
+export function stringifyYaml(data: Record<string, string>): string {
+	return `${Object.entries(data)
+		.map(([k, v]) => `${k}: "${v}"`)
+		.join("\n")}\n`;
+}