@foundation0/api 1.1.12 → 1.1.13

package/taskgraph-parser.ts

@@ -1,217 +1,217 @@
-import { promises as fs } from 'node:fs';
-import * as path from 'node:path';
-
-export type TaskId = `TASK-${string}`;
-
-export interface TaskGraphTask {
-	id: TaskId;
-	deps: TaskId[];
-	desc: string;
-}
-
-export interface TaskGraphParseResult {
-	version: 'TASKGRAPH-V1';
-	tasks: TaskGraphTask[];
-	byId: Record<string, TaskGraphTask>;
-	topo: TaskId[];
-}
-
-const TASK_ID_RE = /^TASK-[0-9]{3}[A-Za-z0-9]*$/;
-
-/**
- * Extract exactly one ```taskgraph fenced block from markdown (returns raw block contents).
- */
-export function extractTaskGraphBlockFromMarkdown(markdown: string): string {
-	const matches = [...markdown.matchAll(/```taskgraph\s*\n([\s\S]*?)\n```/g)];
-	if (matches.length !== 1) {
-		throw new Error(`Expected exactly 1 taskgraph block, found ${matches.length}`);
-	}
-	return matches[0][1];
-}
-
-/**
- * Parse + validate TASKGRAPH-V1 block content (no fences).
- *
- * Returns a validated DAG plus a deterministic topological order (Kahn).
- */
-export function parseTaskGraphV1(block: string): TaskGraphParseResult {
-	const lines = block.replace(/\r\n/g, '\n').split('\n');
-
-	const isIgnorable = (raw: string) => {
-		const t = raw.trim();
-		return t.length === 0 || t.startsWith('#');
-	};
-
-	let i = 0;
-	while (i < lines.length && isIgnorable(lines[i])) i++;
-	if (i >= lines.length) throw new Error('Missing TASKGRAPH-V1 header');
-	if (lines[i].trim() !== 'TASKGRAPH-V1') throw new Error(`Line ${i + 1}: expected TASKGRAPH-V1`);
-	i++;
-
-	const tasks: TaskGraphTask[] = [];
-	const byId = new Map<TaskId, TaskGraphTask>();
-
-	for (; i < lines.length; i++) {
-		const raw = lines[i];
-		if (isIgnorable(raw)) continue;
-
-		const parts = raw.split('|');
-		if (parts.length !== 3) throw new Error(`Line ${i + 1}: expected <id>|<deps>|<desc>`);
-
-		const idRaw = parts[0].trim();
-		const depsRaw = parts[1].trim();
-		const desc = parts[2].trim();
-
-		if (!TASK_ID_RE.test(idRaw)) throw new Error(`Line ${i + 1}: invalid id '${idRaw}'`);
-		const id = idRaw as TaskId;
-
-		if (!desc) throw new Error(`Line ${i + 1}: empty desc for '${id}'`);
-		if (byId.has(id)) throw new Error(`Line ${i + 1}: duplicate id '${id}'`);
-		if (depsRaw !== '' && /\s/.test(depsRaw)) throw new Error(`Line ${i + 1}: deps contains whitespace`);
-
-		const deps =
-			depsRaw === ''
-				? []
-				: depsRaw.split(',').map((d) => {
-						if (!TASK_ID_RE.test(d)) throw new Error(`Line ${i + 1}: invalid dep '${d}'`);
-						return d as TaskId;
-					});
-
-		if (deps.includes(id)) throw new Error(`Line ${i + 1}: task '${id}' cannot depend on itself`);
-		if (new Set(deps).size !== deps.length) throw new Error(`Line ${i + 1}: duplicate deps for '${id}'`);
-
-		const task: TaskGraphTask = { id, deps, desc };
-		tasks.push(task);
-		byId.set(id, task);
-	}
-
-	for (const t of tasks) {
-		for (const d of t.deps) {
-			if (!byId.has(d)) throw new Error(`Task '${t.id}' depends on unknown task '${d}'`);
-		}
-	}
-
-	const inDeg = new Map<TaskId, number>();
-	const adj = new Map<TaskId, TaskId[]>();
-	for (const t of tasks) {
-		inDeg.set(t.id, t.deps.length);
-		adj.set(t.id, []);
-	}
-	for (const t of tasks) {
-		for (const d of t.deps) adj.get(d)!.push(t.id);
-	}
-	for (const outs of adj.values()) outs.sort();
-
-	const ready = [...inDeg.entries()]
-		.filter(([, deg]) => deg === 0)
-		.map(([id]) => id)
-		.sort();
-
-	const topo: TaskId[] = [];
-	while (ready.length > 0) {
-		const id = ready.shift()!;
-		topo.push(id);
-		for (const v of adj.get(id)!) {
-			const next = inDeg.get(v)! - 1;
-			inDeg.set(v, next);
-			if (next === 0) {
-				ready.push(v);
-				ready.sort();
-			}
-		}
-	}
-
-	if (topo.length !== tasks.length) {
-		const remaining = [...inDeg.entries()].filter(([, deg]) => deg > 0).map(([id]) => id).sort();
-		throw new Error(`Dependency cycle detected among: ${remaining.join(',')}`);
-	}
-
-	const byIdObj: Record<string, TaskGraphTask> = {};
-	for (const [id, task] of byId.entries()) {
-		byIdObj[id] = task;
-	}
-
-	return { version: 'TASKGRAPH-V1', tasks, byId: byIdObj, topo };
-}
-
-export function parseTaskGraphFromMarkdown(markdown: string): TaskGraphParseResult {
-	return parseTaskGraphV1(extractTaskGraphBlockFromMarkdown(markdown));
-}
-
-function parseArgs(argv: string[]): { inputPath: string; outputPath?: string; indent: number } {
-	let inputPath: string | undefined;
-	let outputPath: string | undefined;
-	let indent = 2;
-
-	for (let i = 0; i < argv.length; i++) {
-		const arg = argv[i];
-		if (arg === '--help' || arg === '-h') {
-			process.stdout.write(
-				[
-					'Usage:',
-					'  bun api/taskgraph-parser.ts --tracks <path>',
-					'  bun api/taskgraph-parser.ts --tracks <path> --out <file>',
-					'  bun scripts/taskgraph-parser.ts --tracks <path>',
-					'  bun scripts/taskgraph-parser.ts --tracks <path> --out <file>',
-					'',
-					'Options:',
-					'  --tracks   Input tracks.md path (required)',
-					'  --out      Optional output JSON file path (defaults to stdout)',
-					'  --indent   Optional JSON indent (default: 2)',
-					'  --help, -h Show this help message',
-					'',
-				].join('\n'),
-			);
-			process.exit(0);
-		}
-		if (arg === '--tracks') {
-			inputPath = argv[i + 1];
-			if (!inputPath) throw new Error('Missing value for --tracks');
-			i++;
-			continue;
-		}
-		if (arg === '--out') {
-			outputPath = argv[i + 1];
-			if (!outputPath) throw new Error('Missing value for --out');
-			i++;
-			continue;
-		}
-		if (arg === '--indent') {
-			const value = Number(argv[i + 1]);
-			if (!Number.isFinite(value) || value < 0) throw new Error(`Invalid --indent: ${argv[i + 1]}`);
-			indent = Math.floor(value);
-			i++;
-			continue;
-		}
-
-		if (!arg.startsWith('--')) {
-			if (!inputPath) inputPath = arg;
-			continue;
-		}
-		throw new Error(`Unknown argument: ${arg}`);
-	}
-
-	if (!inputPath) throw new Error('Missing required --tracks <path>');
-	return { inputPath: path.resolve(inputPath), outputPath: outputPath ? path.resolve(outputPath) : undefined, indent };
-}
-
-export async function main(): Promise<void> {
-	const { inputPath, outputPath, indent } = parseArgs(process.argv.slice(2));
-	const markdown = await fs.readFile(inputPath, 'utf8');
-	const graph = parseTaskGraphFromMarkdown(markdown);
-	const payload = JSON.stringify(graph, null, indent);
-
-	if (outputPath) {
-		await fs.writeFile(outputPath, payload + '\n', 'utf8');
-		return;
-	}
-
-	process.stdout.write(payload + '\n');
-}
-
-if (import.meta.main) {
-	main().catch((err) => {
-		process.stderr.write(String(err instanceof Error ? err.stack ?? err.message : err) + '\n');
-		process.exitCode = 1;
-	});
-}
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+
+export type TaskId = `TASK-${string}`;
+
+export interface TaskGraphTask {
+	id: TaskId;
+	deps: TaskId[];
+	desc: string;
+}
+
+export interface TaskGraphParseResult {
+	version: 'TASKGRAPH-V1';
+	tasks: TaskGraphTask[];
+	byId: Record<string, TaskGraphTask>;
+	topo: TaskId[];
+}
+
+const TASK_ID_RE = /^TASK-[0-9]{3}[A-Za-z0-9]*$/;
+
+/**
+ * Extract exactly one ```taskgraph fenced block from markdown (returns raw block contents).
+ */
+export function extractTaskGraphBlockFromMarkdown(markdown: string): string {
+	const matches = [...markdown.matchAll(/```taskgraph\s*\n([\s\S]*?)\n```/g)];
+	if (matches.length !== 1) {
+		throw new Error(`Expected exactly 1 taskgraph block, found ${matches.length}`);
+	}
+	return matches[0][1];
+}
+
+/**
+ * Parse + validate TASKGRAPH-V1 block content (no fences).
+ *
+ * Returns a validated DAG plus a deterministic topological order (Kahn).
+ */
+export function parseTaskGraphV1(block: string): TaskGraphParseResult {
+	const lines = block.replace(/\r\n/g, '\n').split('\n');
+
+	const isIgnorable = (raw: string) => {
+		const t = raw.trim();
+		return t.length === 0 || t.startsWith('#');
+	};
+
+	let i = 0;
+	while (i < lines.length && isIgnorable(lines[i])) i++;
+	if (i >= lines.length) throw new Error('Missing TASKGRAPH-V1 header');
+	if (lines[i].trim() !== 'TASKGRAPH-V1') throw new Error(`Line ${i + 1}: expected TASKGRAPH-V1`);
+	i++;
+
+	const tasks: TaskGraphTask[] = [];
+	const byId = new Map<TaskId, TaskGraphTask>();
+
+	for (; i < lines.length; i++) {
+		const raw = lines[i];
+		if (isIgnorable(raw)) continue;
+
+		const parts = raw.split('|');
+		if (parts.length !== 3) throw new Error(`Line ${i + 1}: expected <id>|<deps>|<desc>`);
+
+		const idRaw = parts[0].trim();
+		const depsRaw = parts[1].trim();
+		const desc = parts[2].trim();
+
+		if (!TASK_ID_RE.test(idRaw)) throw new Error(`Line ${i + 1}: invalid id '${idRaw}'`);
+		const id = idRaw as TaskId;
+
+		if (!desc) throw new Error(`Line ${i + 1}: empty desc for '${id}'`);
+		if (byId.has(id)) throw new Error(`Line ${i + 1}: duplicate id '${id}'`);
+		if (depsRaw !== '' && /\s/.test(depsRaw)) throw new Error(`Line ${i + 1}: deps contains whitespace`);
+
+		const deps =
+			depsRaw === ''
+				? []
+				: depsRaw.split(',').map((d) => {
+						if (!TASK_ID_RE.test(d)) throw new Error(`Line ${i + 1}: invalid dep '${d}'`);
+						return d as TaskId;
+					});
+
+		if (deps.includes(id)) throw new Error(`Line ${i + 1}: task '${id}' cannot depend on itself`);
+		if (new Set(deps).size !== deps.length) throw new Error(`Line ${i + 1}: duplicate deps for '${id}'`);
+
+		const task: TaskGraphTask = { id, deps, desc };
+		tasks.push(task);
+		byId.set(id, task);
+	}
+
+	for (const t of tasks) {
+		for (const d of t.deps) {
+			if (!byId.has(d)) throw new Error(`Task '${t.id}' depends on unknown task '${d}'`);
+		}
+	}
+
+	const inDeg = new Map<TaskId, number>();
+	const adj = new Map<TaskId, TaskId[]>();
+	for (const t of tasks) {
+		inDeg.set(t.id, t.deps.length);
+		adj.set(t.id, []);
+	}
+	for (const t of tasks) {
+		for (const d of t.deps) adj.get(d)!.push(t.id);
+	}
+	for (const outs of adj.values()) outs.sort();
+
+	const ready = [...inDeg.entries()]
+		.filter(([, deg]) => deg === 0)
+		.map(([id]) => id)
+		.sort();
+
+	const topo: TaskId[] = [];
+	while (ready.length > 0) {
+		const id = ready.shift()!;
+		topo.push(id);
+		for (const v of adj.get(id)!) {
+			const next = inDeg.get(v)! - 1;
+			inDeg.set(v, next);
+			if (next === 0) {
+				ready.push(v);
+				ready.sort();
+			}
+		}
+	}
+
+	if (topo.length !== tasks.length) {
+		const remaining = [...inDeg.entries()].filter(([, deg]) => deg > 0).map(([id]) => id).sort();
+		throw new Error(`Dependency cycle detected among: ${remaining.join(',')}`);
+	}
+
+	const byIdObj: Record<string, TaskGraphTask> = {};
+	for (const [id, task] of byId.entries()) {
+		byIdObj[id] = task;
+	}
+
+	return { version: 'TASKGRAPH-V1', tasks, byId: byIdObj, topo };
+}
+
+export function parseTaskGraphFromMarkdown(markdown: string): TaskGraphParseResult {
+	return parseTaskGraphV1(extractTaskGraphBlockFromMarkdown(markdown));
+}
+
+function parseArgs(argv: string[]): { inputPath: string; outputPath?: string; indent: number } {
+	let inputPath: string | undefined;
+	let outputPath: string | undefined;
+	let indent = 2;
+
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === '--help' || arg === '-h') {
+			process.stdout.write(
+				[
+					'Usage:',
+					'  bun api/taskgraph-parser.ts --tracks <path>',
+					'  bun api/taskgraph-parser.ts --tracks <path> --out <file>',
+					'  bun scripts/taskgraph-parser.ts --tracks <path>',
+					'  bun scripts/taskgraph-parser.ts --tracks <path> --out <file>',
+					'',
+					'Options:',
+					'  --tracks   Input tracks.md path (required)',
+					'  --out      Optional output JSON file path (defaults to stdout)',
+					'  --indent   Optional JSON indent (default: 2)',
+					'  --help, -h Show this help message',
+					'',
+				].join('\n'),
+			);
+			process.exit(0);
+		}
+		if (arg === '--tracks') {
+			inputPath = argv[i + 1];
+			if (!inputPath) throw new Error('Missing value for --tracks');
+			i++;
+			continue;
+		}
+		if (arg === '--out') {
+			outputPath = argv[i + 1];
+			if (!outputPath) throw new Error('Missing value for --out');
+			i++;
+			continue;
+		}
+		if (arg === '--indent') {
+			const value = Number(argv[i + 1]);
+			if (!Number.isFinite(value) || value < 0) throw new Error(`Invalid --indent: ${argv[i + 1]}`);
+			indent = Math.floor(value);
+			i++;
+			continue;
+		}
+
+		if (!arg.startsWith('--')) {
+			if (!inputPath) inputPath = arg;
+			continue;
+		}
+		throw new Error(`Unknown argument: ${arg}`);
+	}
+
+	if (!inputPath) throw new Error('Missing required --tracks <path>');
+	return { inputPath: path.resolve(inputPath), outputPath: outputPath ? path.resolve(outputPath) : undefined, indent };
+}
+
+export async function main(): Promise<void> {
+	const { inputPath, outputPath, indent } = parseArgs(process.argv.slice(2));
+	const markdown = await fs.readFile(inputPath, 'utf8');
+	const graph = parseTaskGraphFromMarkdown(markdown);
+	const payload = JSON.stringify(graph, null, indent);
+
+	if (outputPath) {
+		await fs.writeFile(outputPath, payload + '\n', 'utf8');
+		return;
+	}
+
+	process.stdout.write(payload + '\n');
+}
+
+if (import.meta.main) {
+	main().catch((err) => {
+		process.stderr.write(String(err instanceof Error ? err.stack ?? err.message : err) + '\n');
+		process.exitCode = 1;
+	});
+}

package/libs/curl.test.ts

@@ -1,130 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { curl } from './curl'
-
-describe('api/libs/curl', () => {
-  const withServer = async <T>(fn: (baseUrl: string) => Promise<T>): Promise<T> => {
-    const server = Bun.serve({
-      port: 0,
-      fetch: async (req) => {
-        const url = new URL(req.url)
-
-        if (url.pathname === '/hello') {
-          return new Response('hello', { headers: { 'x-test': '1' } })
-        }
-
-        if (url.pathname === '/echo') {
-          const body = await req.text()
-          return Response.json({
-            method: req.method,
-            body,
-            contentType: req.headers.get('content-type'),
-            ua: req.headers.get('user-agent'),
-          })
-        }
-
-        if (url.pathname === '/redirect') {
-          return new Response('nope', { status: 302, headers: { location: '/hello' } })
-        }
-
-        return new Response('not found', { status: 404 })
-      },
-    })
-
-    try {
-      return await fn(`http://127.0.0.1:${server.port}`)
-    } finally {
-      server.stop(true)
-    }
-  }
-
-  it('fetches a URL and returns body on stdout', async () => {
-    await withServer(async (baseUrl) => {
-      const result = await curl(`${baseUrl}/hello`)
-      expect(result.exitCode).toBe(0)
-      expect(result.timedOut).toBe(false)
-      expect(result.stdout).toBe('hello')
-      expect(result.results?.[0]?.httpCode).toBe(200)
-    })
-  })
-
-  it('defaults scheme-less host URLs to http://', async () => {
-    await withServer(async (baseUrl) => {
-      const url = baseUrl.replace('http://', '')
-      const result = await curl(`${url}/hello`)
-      expect(result.exitCode).toBe(0)
-      expect(result.stdout).toBe('hello')
-    })
-  })
-
-  it('supports -i to include response headers', async () => {
-    await withServer(async (baseUrl) => {
-      const result = await curl('-i', `${baseUrl}/hello`)
-      expect(result.exitCode).toBe(0)
-      expect(result.stdout).toContain('HTTP/1.1 200')
-      expect(result.stdout.toLowerCase()).toContain('x-test: 1')
-      expect(result.stdout).toContain('hello')
-    })
-  })
-
-  it('supports -d for POST body and defaults method to POST', async () => {
-    await withServer(async (baseUrl) => {
-      const result = await curl('-d', 'a=1', `${baseUrl}/echo`)
-      expect(result.exitCode).toBe(0)
-      const payload = JSON.parse(result.stdout)
-      expect(payload.method).toBe('POST')
-      expect(payload.body).toBe('a=1')
-      expect(payload.contentType).toContain('application/x-www-form-urlencoded')
-    })
-  })
-
-  it('supports -G with -d to apply data as query params', async () => {
-    await withServer(async (baseUrl) => {
-      const result = await curl('-G', '-d', 'a=1', `${baseUrl}/hello`)
-      expect(result.exitCode).toBe(0)
-      expect(result.stdout).toBe('hello')
-    })
-  })
-
-  it('supports -L to follow redirects', async () => {
-    await withServer(async (baseUrl) => {
-      const result = await curl('-L', `${baseUrl}/redirect`)
-      expect(result.exitCode).toBe(0)
-      expect(result.results?.[0]?.redirectCount).toBe(1)
-      expect(result.results?.[0]?.urlEffective).toContain('/hello')
-      expect(result.stdout).toBe('hello')
-    })
-  })
-
-  it('supports -f to fail on HTTP >= 400 and suppress body', async () => {
-    await withServer(async (baseUrl) => {
-      const result = await curl('-f', `${baseUrl}/missing`)
-      expect(result.exitCode).toBe(22)
-      expect(result.stdout).toBe('')
-      expect(result.stderr).toContain('returned error')
-    })
-  })
-
-  it('supports -w to write out %{http_code}', async () => {
-    await withServer(async (baseUrl) => {
-      const result = await curl('-w', '%{http_code}', `${baseUrl}/hello`)
-      expect(result.exitCode).toBe(0)
-      expect(result.stdout).toBe('hello200')
-    })
-  })
-
-  it('accepts trailing tool options object without turning it into a curl arg', async () => {
-    await withServer(async (baseUrl) => {
-      const result = await curl(`${baseUrl}/hello`, { timeoutMs: 10_000 })
-      expect(result.exitCode).toBe(0)
-      expect(result.args).toEqual([`${baseUrl}/hello`])
-    })
-  })
-
-  it('returns usage exit code for unsupported flags', async () => {
-    await withServer(async (baseUrl) => {
-      const result = await curl('--version', `${baseUrl}/hello`)
-      expect(result.exitCode).toBe(2)
-      expect(result.stderr).toContain('Unsupported curl option')
-    })
-  })
-})