@dev.fast/whiteboard 0.0.0-stage → 0.2.0

package/dist/runtime-CKiWhGrf.js

@@ -0,0 +1,52 @@
+import path from "node:path";
+import { spawn } from "node:child_process";
+//#region src/runtime.ts
+async function resolveReviewRoot(cwd, execFile = execFilePromise) {
+	const initialCwd = path.resolve(cwd);
+	try {
+		const { stdout } = await execFile("jj", ["root"], { cwd: initialCwd });
+		const root = stdout.trim();
+		if (root) return path.resolve(root);
+	} catch {}
+	try {
+		const { stdout } = await execFile("git", [
+			"-C",
+			initialCwd,
+			"rev-parse",
+			"--show-toplevel"
+		]);
+		const root = stdout.trim();
+		if (root) return path.resolve(root);
+	} catch {}
+	return initialCwd;
+}
+function execFilePromise(file, args, options = {}) {
+	return execFileUntraced(file, args, options);
+}
+function execFileUntraced(file, args, options = {}) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(file, args, {
+			cwd: options.cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout?.on("data", (chunk) => {
+			stdout += String(chunk);
+		});
+		child.stderr?.on("data", (chunk) => {
+			stderr += String(chunk);
+		});
+		child.on("error", reject);
+		child.on("exit", (code) => {
+			if (code === 0) resolve({ stdout });
+			else reject(new Error(stderr.trim() || `${file} exited with ${code}`));
+		});
+	});
+}
+//#endregion
+export { resolveReviewRoot as t };

package/dist/runtime.d.ts

@@ -0,0 +1,9 @@
+//#region src/runtime.d.ts
+declare function resolveReviewRoot(cwd: string, execFile?: typeof execFilePromise): Promise<string>;
+declare function execFilePromise(file: string, args: string[], options?: {
+  cwd?: string;
+}): Promise<{
+  stdout: string;
+}>;
+//#endregion
+export { resolveReviewRoot };

package/dist/runtime.js

@@ -0,0 +1,2 @@
+import { t as resolveReviewRoot } from "./runtime-CKiWhGrf.js";
+export { resolveReviewRoot };

package/dist/s3-SzLpeCG6.js

@@ -0,0 +1,345 @@
+import { a as jsonNumber, c as jsonString, o as jsonObject, r as jsonArray, u as parseJsonText } from "./src-X9phtB2j.js";
+import { S as sessionMetaSchema, b as commitShaSchema, y as byCommitSchema } from "./src-CGP5ytbV.js";
+import { i as isS3MockMode, l as s3CacheIdentity, s as resolveS3Credentials, u as s3MockRoot } from "./s3-config-CAxhO9u_.js";
+import { t as errorMessage } from "./error-message-OtiDonty.js";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { tmpdir } from "node:os";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region ../trace-core/src/trace-storage/s3.ts
+/**
+* Direct S3/R2 storage through the AWS CLI. Owns the legacy bucket layout:
+*
+*   by-session/<session>/trace.jsonl
+*   by-session/<session>/subagents/<name>.jsonl
+*   by-session/<session>/meta.json
+*   by-commit/<sha>.json
+*
+* Objects only grow: a transcript is re-uploaded when the local copy is
+* larger than the stored one, and a by-commit entry is written once.
+*/
+const execFileAsync = promisify(execFile);
+var S3TraceStorage = class S3TraceStorage {
+	config;
+	mockRoot;
+	env;
+	kind = "s3";
+	target;
+	constructor(config, mockRoot, env) {
+		this.config = config;
+		this.mockRoot = mockRoot;
+		this.env = env;
+		this.target = config ? {
+			kind: "s3",
+			endpoint: config.endpoint,
+			bucket: config.bucket,
+			region: config.region
+		} : {
+			kind: "s3",
+			endpoint: "mock://endpoint",
+			bucket: "mock-bucket",
+			region: "auto",
+			mockRoot: mockRoot ?? void 0
+		};
+	}
+	/**
+	* The bucket named by the legacy configuration, or null when none is
+	* configured. Mock mode yields a storage backed by a directory.
+	*/
+	static fromEnvironment(scope = {}) {
+		const env = scope.env ?? process.env;
+		if (isS3MockMode(env)) return new S3TraceStorage(null, s3MockRoot(env), env);
+		const config = resolveS3Credentials(scope);
+		return config ? new S3TraceStorage(config, null, env) : null;
+	}
+	static fromCredentials(config, env = process.env) {
+		return new S3TraceStorage(config, null, env);
+	}
+	/** Secret-free identity of the destination; the same bucket keys the same cache. */
+	cacheIdentity() {
+		return s3CacheIdentity(this.config, this.mockRoot);
+	}
+	cacheScope(repo) {
+		return repo;
+	}
+	/** A non-mutating reachability check of the configured bucket. */
+	async readiness() {
+		if (!this.config) return { ready: true };
+		try {
+			await this.aws([
+				"s3api",
+				"head-bucket",
+				"--bucket",
+				this.config.bucket
+			], { timeout: 15e3 });
+			return { ready: true };
+		} catch (error) {
+			return {
+				ready: false,
+				reason: errorMessage(error)
+			};
+		}
+	}
+	async describeObject(sessionId, traceName) {
+		const size = await this.headObjectSize(objectKey(sessionId, traceName));
+		return size === null ? null : {
+			size,
+			contentId: `size:${size}`
+		};
+	}
+	async downloadObject(sessionId, traceName, destinationPath) {
+		if (!await this.getObject(objectKey(sessionId, traceName), destinationPath)) return null;
+		const size = statSync(destinationPath).size;
+		return {
+			size,
+			contentId: `size:${size}`
+		};
+	}
+	async listSubagents(sessionId) {
+		const prefix = `by-session/${sessionId}/subagents/`;
+		const names = /* @__PURE__ */ new Set();
+		if (this.mockRoot !== null || !this.config) {
+			if (this.mockRoot) {
+				const dir = path.join(this.mockRoot, prefix);
+				if (existsSync(dir)) try {
+					for (const entry of readdirSync(dir)) if (entry.endsWith(".jsonl")) names.add(entry.slice(0, -6));
+				} catch {}
+			}
+			return [...names].sort();
+		}
+		try {
+			const proc = await this.aws([
+				"s3api",
+				"list-objects-v2",
+				"--bucket",
+				this.config.bucket,
+				"--prefix",
+				prefix
+			], { timeout: 1e4 });
+			const listing = jsonObject(parseJsonText(proc.stdout));
+			for (const item of jsonArray(listing?.Contents) ?? []) {
+				const key = jsonString(jsonObject(item)?.Key);
+				if (key && key.startsWith(prefix) && key.endsWith(".jsonl")) {
+					const name = key.slice(prefix.length, -6);
+					if (name) names.add(name);
+				}
+			}
+		} catch {}
+		return [...names].sort();
+	}
+	async sessionMeta(sessionId) {
+		try {
+			const parsed = sessionMetaSchema.safeParse(await this.getJson(metaKey(sessionId)));
+			return parsed.success ? parsed.data : null;
+		} catch {
+			return null;
+		}
+	}
+	async sessionsForCommit(commit) {
+		if (!commitShaSchema.safeParse(commit).success) return null;
+		try {
+			const parsed = byCommitSchema.safeParse(await this.getJson(commitKey(commit)));
+			if (!parsed.success || parsed.data.sessions.length === 0) return null;
+			return {
+				sessions: parsed.data.sessions,
+				pr: parsed.data.pr,
+				branch: parsed.data.branch
+			};
+		} catch {
+			return null;
+		}
+	}
+	async publish(input) {
+		const uploads = [];
+		for (const file of input.files) {
+			const key = objectKey(input.sessionId, file.name);
+			const grown = await this.putIfGrown(key, file.path);
+			uploads.push({
+				blob: file.name === "main" ? "trace.jsonl" : `subagents/${file.name}`,
+				bytes_stored: statSync(file.path).size,
+				status: grown ? "uploaded" : "unchanged"
+			});
+		}
+		const existing = await this.sessionMeta(input.sessionId);
+		const meta = {
+			session: input.sessionId,
+			repo: `${input.repo.owner}/${input.repo.repo}`,
+			branch: input.branch ?? existing?.branch ?? null,
+			pr: existing?.pr ?? null,
+			commits: deduplicateStrings([...existing?.commits ?? [], ...(input.commits ?? []).filter((commit) => commitShaSchema.safeParse(commit).success)]),
+			author: input.author ?? existing?.author ?? null,
+			ts: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		if (!await this.putBuffer(metaKey(input.sessionId), Buffer.from(JSON.stringify(meta, null, 2), "utf8"))) throw new Error(`Failed to update session metadata for ${input.sessionId} in S3/R2 storage.`);
+		return { uploads };
+	}
+	async associateCommits(input) {
+		const commit = commitShaSchema.parse(input.commit);
+		if (await this.getJson(commitKey(commit)) !== null) return false;
+		const { repo, pr } = await input.resolve();
+		const entry = byCommitSchema.parse({
+			commit,
+			sessions: deduplicateStrings(input.sessions),
+			repo: `${repo.owner}/${repo.repo}`,
+			pr,
+			branch: input.branch,
+			indexed_by: "hook",
+			ts: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		if (!await this.putBuffer(commitKey(commit), Buffer.from(JSON.stringify(entry, null, 2), "utf8"))) throw new Error(`Failed to write by-commit/${commit}.json.`);
+		return true;
+	}
+	async headObjectSize(key) {
+		if (!this.config) {
+			if (!this.mockRoot) return null;
+			try {
+				const stats = statSync(path.join(this.mockRoot, key));
+				return stats.isFile() ? stats.size : null;
+			} catch {
+				return null;
+			}
+		}
+		try {
+			const proc = await this.aws([
+				"s3api",
+				"head-object",
+				"--bucket",
+				this.config.bucket,
+				"--key",
+				key
+			], { timeout: 1e4 });
+			return jsonNumber(jsonObject(parseJsonText(proc.stdout))?.ContentLength) ?? null;
+		} catch {
+			return null;
+		}
+	}
+	async getObject(key, destPath) {
+		mkdirSync(path.dirname(destPath), { recursive: true });
+		if (!this.config) {
+			if (!this.mockRoot) return false;
+			try {
+				writeFileSync(destPath, readFileSync(path.join(this.mockRoot, key)));
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		try {
+			await this.aws([
+				"s3api",
+				"get-object",
+				"--bucket",
+				this.config.bucket,
+				"--key",
+				key,
+				destPath
+			], {
+				timeout: 6e4,
+				maxBuffer: 16777216
+			});
+			return existsSync(destPath);
+		} catch {
+			return false;
+		}
+	}
+	async getJson(key) {
+		const tmpPath = path.join(tmpdir(), `r2-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
+		try {
+			if (!await this.getObject(key, tmpPath)) return null;
+			return parseJsonText(readFileSync(tmpPath, "utf8"));
+		} catch {
+			return null;
+		} finally {
+			rmSync(tmpPath, { force: true });
+		}
+	}
+	async putFile(key, filePath) {
+		if (!this.config) {
+			if (!this.mockRoot) return false;
+			try {
+				const target = path.join(this.mockRoot, key);
+				mkdirSync(path.dirname(target), { recursive: true });
+				writeFileSync(target, readFileSync(filePath));
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		try {
+			await this.aws([
+				"s3",
+				"cp",
+				"--only-show-errors",
+				filePath,
+				`s3://${this.config.bucket}/${key}`
+			], { timeout: 6e4 });
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async putBuffer(key, content) {
+		if (!this.config) {
+			if (!this.mockRoot) return false;
+			try {
+				const target = path.join(this.mockRoot, key);
+				mkdirSync(path.dirname(target), { recursive: true });
+				writeFileSync(target, content);
+				return true;
+			} catch {
+				return false;
+			}
+		}
+		const tempFile = path.join(tmpdir(), `put-${process.pid}-${Math.random().toString(36).slice(2)}.tmp`);
+		writeFileSync(tempFile, content);
+		try {
+			return await this.putFile(key, tempFile);
+		} finally {
+			rmSync(tempFile, { force: true });
+		}
+	}
+	async putIfGrown(key, filePath) {
+		const remoteSize = await this.headObjectSize(key);
+		const localSize = statSync(filePath).size;
+		if (remoteSize !== null && localSize <= remoteSize) return false;
+		if (!await this.putFile(key, filePath)) throw new Error(`Failed to upload ${key} to S3/R2 storage.`);
+		return true;
+	}
+	aws(args, options) {
+		const config = this.config;
+		if (!config) throw new Error("S3 trace storage is not configured.");
+		return execFileAsync("aws", [
+			"--region",
+			config.region,
+			"--endpoint-url",
+			config.endpoint,
+			...args
+		], {
+			...options,
+			env: {
+				...this.env,
+				AWS_ACCESS_KEY_ID: config.accessKeyId,
+				AWS_SECRET_ACCESS_KEY: config.secretAccessKey
+			}
+		});
+	}
+};
+function objectKey(sessionId, traceName) {
+	return traceName === "main" ? `by-session/${sessionId}/trace.jsonl` : `by-session/${sessionId}/subagents/${normalizeSubagentFileName(traceName)}`;
+}
+function metaKey(sessionId) {
+	return `by-session/${sessionId}/meta.json`;
+}
+function commitKey(commit) {
+	return `by-commit/${commit}.json`;
+}
+function normalizeSubagentFileName(name) {
+	const base = path.basename(name);
+	return base.endsWith(".jsonl") ? base : `${base}.jsonl`;
+}
+function deduplicateStrings(items) {
+	return [...new Set(items)];
+}
+//#endregion
+export { S3TraceStorage, normalizeSubagentFileName };

package/dist/s3-config-BgxkSoOy.js

@@ -0,0 +1,2 @@
+import { a as noTraceConfigurationMessage, c as resolveS3Setup, d as traceEnvPath, f as traceEnvValue, i as isS3MockMode, l as s3CacheIdentity, n as clearTraceEnvCache, o as readTraceEnvFile, p as traceSettingsPath, r as describeS3Setup, s as resolveS3Credentials, t as S3_DEFAULT_REGION, u as s3MockRoot } from "./s3-config-CAxhO9u_.js";
+export { S3_DEFAULT_REGION, clearTraceEnvCache, describeS3Setup, isS3MockMode, noTraceConfigurationMessage, readTraceEnvFile, resolveS3Credentials, resolveS3Setup, s3CacheIdentity, s3MockRoot, traceEnvPath, traceEnvValue, traceSettingsPath };