@lchase/kiln 0.0.0-stage → 0.1.0

package/dist/config.js

@@ -0,0 +1,237 @@
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { KilnConfigError } from "./errors.js";
+import { KilnConfigFileSchema } from "./schemas.js";
+const CONFIG_NAME = "kiln.config.json";
+const REPO_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+export function loadKilnConfig(configPath, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const home = options.home ?? homedir();
+    const resolvedPath = resolve(configPath);
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(resolvedPath, "utf8"));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new KilnConfigError(`Could not read kiln config ${resolvedPath}: ${message}`);
+    }
+    const parsed = KilnConfigFileSchema.safeParse(raw);
+    if (!parsed.success) {
+        throw new KilnConfigError(`Kiln config ${resolvedPath} is invalid: ${parsed.error.message}`);
+    }
+    const configDir = dirname(resolvedPath);
+    const repos = {};
+    for (const [name, entry] of Object.entries(parsed.data.repos)) {
+        assertRepoName(name);
+        const checkout = resolveConfiguredPath(configDir, entry.path, home);
+        if (!existsSync(checkout) || !statSync(checkout).isDirectory()) {
+            throw new KilnConfigError(`Checkout for ${name} does not exist or is not a directory: ${checkout}. Set repos.${name}.path in the kiln config.`);
+        }
+        repos[name] = {
+            path: checkout,
+            ...(entry.test ? { test: entry.test } : {}),
+            deliver: entry.deliver ?? "local",
+            ...(entry.base ? { base: entry.base } : {}),
+        };
+    }
+    const kilnDir = basename(configDir) === ".kiln" ? configDir : join(cwd, ".kiln");
+    const jira = jiraFromFile(parsed.data.jira);
+    return {
+        configPath: resolvedPath,
+        configDir,
+        note: parsed.data.note,
+        repos,
+        kilnDir,
+        jobsDir: join(kilnDir, "jobs"),
+        maxConcurrent: parsed.data.maxConcurrent ?? 2,
+        adapter: parsed.data.adapter ?? "claude-code",
+        ...(jira ? { jira } : {}),
+    };
+}
+/**
+ * Local config wins: `./.kiln/kiln.config.json`, then `~/.kiln/kiln.config.json`.
+ */
+export function resolveKilnConfig(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const home = options.home ?? homedir();
+    if (options.configPath) {
+        return loadKilnConfig(resolve(cwd, options.configPath), { cwd, home });
+    }
+    const cwdConfig = join(cwd, ".kiln", CONFIG_NAME);
+    if (existsSync(cwdConfig))
+        return loadKilnConfig(cwdConfig, { cwd, home });
+    const homeConfig = join(home, ".kiln", CONFIG_NAME);
+    if (existsSync(homeConfig))
+        return loadKilnConfig(homeConfig, { cwd, home });
+    throw new KilnConfigError([
+        "No kiln config found.",
+        `Run kiln repo add <name> <path> to create ${join(cwd, ".kiln", CONFIG_NAME)},`,
+        `or create ${join(home, ".kiln", CONFIG_NAME)}.`,
+        "Those directories are gitignored. Do not commit checkout paths.",
+    ].join("\n"));
+}
+const BRANCH_NAME = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/;
+/** Create or update one repo entry. Returns the text to print. */
+export function addRepo(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const home = options.home ?? homedir();
+    assertRepoName(options.name);
+    if (options.test !== undefined && !options.test.trim()) {
+        throw new KilnConfigError("The test command is empty. Omit --test, or pass a command.");
+    }
+    if (options.base !== undefined)
+        assertBranchName(options.base);
+    const configPath = configPathForWrite(options);
+    const configDir = dirname(configPath);
+    const storedPath = pathToStore(options.repoPath, configDir, cwd, home);
+    const checkout = resolveConfiguredPath(configDir, storedPath, home);
+    if (!existsSync(checkout) || !statSync(checkout).isDirectory()) {
+        throw new KilnConfigError(`Checkout for ${options.name} does not exist or is not a directory: ${checkout}.`);
+    }
+    const raw = readConfigObject(configPath);
+    const repos = repoMap(raw);
+    const previous = repos[options.name];
+    const entry = { path: storedPath };
+    const previousTest = previousString(previous, "test");
+    const test = options.test ?? previousTest;
+    if (test)
+        entry.test = test;
+    const deliver = options.deliver ?? previousDeliver(previous);
+    if (deliver)
+        entry.deliver = deliver;
+    const base = options.base ?? previousString(previous, "base");
+    if (base)
+        entry.base = base;
+    repos[options.name] = entry;
+    raw.repos = repos;
+    const parsed = KilnConfigFileSchema.safeParse(raw);
+    if (!parsed.success) {
+        throw new KilnConfigError(`Kiln config ${configPath} is invalid: ${parsed.error.message}`);
+    }
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(configPath, `${JSON.stringify(raw, null, 2)}\n`);
+    const lines = [`added ${options.name}`, `path ${checkout}`];
+    if (entry.test)
+        lines.push(`test ${entry.test}`);
+    if (entry.deliver)
+        lines.push(`deliver ${entry.deliver}`);
+    if (entry.base)
+        lines.push(`base ${entry.base}`);
+    lines.push(`wrote ${configPath}`);
+    return `${lines.join("\n")}\n`;
+}
+export function renderRepoList(config) {
+    const names = Object.keys(config.repos).sort();
+    if (names.length === 0)
+        return "no repos\n";
+    const lines = names.map((name) => {
+        const repo = config.repos[name];
+        if (!repo)
+            return name;
+        const bits = [name, repo.path];
+        if (repo.test)
+            bits.push(`test ${repo.test}`);
+        if (repo.deliver === "pr")
+            bits.push("deliver pr");
+        if (repo.base)
+            bits.push(`base ${repo.base}`);
+        return bits.join("  ");
+    });
+    return `${lines.join("\n")}\n`;
+}
+export function assertBranchName(name) {
+    if (!BRANCH_NAME.test(name) || name.includes("..") || name.endsWith("/") || name.includes("//")) {
+        throw new KilnConfigError(`--base ${JSON.stringify(name)} must be a branch name (letters, digits, dots, underscores, hyphens, and slashes).`);
+    }
+}
+export function assertRepoName(name) {
+    if (!REPO_NAME.test(name)) {
+        throw new KilnConfigError(`Repo name ${JSON.stringify(name)} must start with a letter or digit and contain only letters, digits, dots, underscores, and hyphens.`);
+    }
+}
+function configPathForWrite(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const home = options.home ?? homedir();
+    if (options.configPath)
+        return resolve(cwd, options.configPath);
+    const cwdConfig = join(cwd, ".kiln", CONFIG_NAME);
+    if (existsSync(cwdConfig))
+        return cwdConfig;
+    const homeConfig = join(home, ".kiln", CONFIG_NAME);
+    if (existsSync(homeConfig))
+        return homeConfig;
+    return cwdConfig;
+}
+function readConfigObject(configPath) {
+    if (!existsSync(configPath))
+        return { repos: {} };
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(configPath, "utf8"));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new KilnConfigError(`Could not read kiln config ${configPath}: ${message}`);
+    }
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new KilnConfigError(`Kiln config ${configPath} must be a JSON object.`);
+    }
+    return raw;
+}
+function previousString(previous, key) {
+    if (typeof previous !== "object" || previous === null || !(key in previous))
+        return undefined;
+    const value = previous[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function previousDeliver(previous) {
+    const value = previousString(previous, "deliver");
+    if (value === "local" || value === "pr")
+        return value;
+    return undefined;
+}
+function repoMap(raw) {
+    const repos = raw.repos;
+    if (repos === undefined)
+        return {};
+    if (typeof repos !== "object" || repos === null || Array.isArray(repos)) {
+        throw new KilnConfigError("Kiln config repos must be an object.");
+    }
+    return repos;
+}
+export function resolveConfiguredPath(configDir, value, home) {
+    const expanded = expandHome(value, home);
+    return isAbsolute(expanded) ? expanded : resolve(configDir, expanded);
+}
+function pathToStore(userPath, configDir, cwd, home) {
+    if (userPath === "~" || userPath.startsWith("~/"))
+        return userPath;
+    if (isAbsolute(userPath))
+        return userPath;
+    const absolute = resolve(cwd, userPath);
+    const stored = relative(configDir, absolute);
+    return stored === "" ? "." : stored;
+}
+function jiraFromFile(jira) {
+    if (!jira)
+        return undefined;
+    const baseUrl = jira.baseUrl?.trim();
+    const email = jira.email?.trim();
+    const apiToken = jira.apiToken?.trim();
+    if (!baseUrl && !email && !apiToken)
+        return undefined;
+    return {
+        ...(baseUrl ? { baseUrl } : {}),
+        ...(email ? { email } : {}),
+        ...(apiToken ? { apiToken } : {}),
+    };
+}
+function expandHome(value, home) {
+    if (value === "~")
+        return home;
+    if (value.startsWith("~/"))
+        return join(home, value.slice(2));
+    return value;
+}

package/dist/delivery.js

@@ -0,0 +1,245 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { HostError } from "./host.js";
+import { readJobSpec } from "./jobs.js";
+import { jobBasename } from "./paths.js";
+/**
+ * Derived per run, under `<kilnDir>/deliveries/<jobId>.json`. Not the job file.
+ * `pushed` is true once origin has this branch at `sha`. Re-tick uses it, and
+ * `gh pr list --head`, so a crash between push and create does not open a
+ * second pull request or push the same commit again.
+ */
+export const DeliveryRecordSchema = z.object({
+    jobId: z.string().min(1),
+    runId: z.string().min(1),
+    branch: z.string().min(1),
+    base: z.string().min(1),
+    sha: z.string().min(1).optional(),
+    pushed: z.boolean(),
+    prNumber: z.number().int().positive().optional(),
+    prUrl: z.string().min(1).optional(),
+    error: z.string().min(1).optional(),
+});
+export function deliveryPath(kilnDir, jobId) {
+    return join(kilnDir, "deliveries", `${jobBasename(jobId)}.json`);
+}
+export function readDelivery(kilnDir, jobId) {
+    const path = deliveryPath(kilnDir, jobId);
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return DeliveryRecordSchema.parse(JSON.parse(readFileSync(path, "utf8")));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeDelivery(kilnDir, record) {
+    const path = deliveryPath(kilnDir, record.jobId);
+    mkdirSync(join(kilnDir, "deliveries"), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(DeliveryRecordSchema.parse(record), null, 2)}\n`);
+}
+const LAUNCH_ERROR = z.object({ error: z.string().min(1) });
+export function launchErrorPath(kilnDir, jobId) {
+    return join(kilnDir, "launch-errors", `${jobBasename(jobId)}.json`);
+}
+export function readLaunchError(kilnDir, jobId) {
+    const path = launchErrorPath(kilnDir, jobId);
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return LAUNCH_ERROR.parse(JSON.parse(readFileSync(path, "utf8"))).error;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeLaunchError(kilnDir, jobId, error) {
+    const path = launchErrorPath(kilnDir, jobId);
+    mkdirSync(join(kilnDir, "launch-errors"), { recursive: true });
+    writeFileSync(path, `${JSON.stringify({ error }, null, 2)}\n`);
+}
+export function clearLaunchError(kilnDir, jobId) {
+    rmSync(launchErrorPath(kilnDir, jobId), { force: true });
+}
+/**
+ * Full SHA the worktree is cut from. Passed to yak as `--from` and to the
+ * workflow as `baseRef`.
+ *
+ * `deliver=local` without `--stack` is checkout HEAD.
+ * `deliver=pr` fetches and uses `origin/<base>` (configured, or origin's default).
+ * A stacked job uses the upstream `yak/<run-id>` tip in this checkout.
+ */
+export function resolveLaunchBase(input) {
+    if (input.stack) {
+        if (!input.upstreamBranch) {
+            throw new HostError("This stacked job has no upstream branch to start from yet.");
+        }
+        return input.git.revParse(input.checkout, input.upstreamBranch);
+    }
+    if (input.deliver === "pr") {
+        input.git.fetch(input.checkout);
+        const base = input.configuredBase ?? input.git.defaultBranch(input.checkout);
+        return input.git.revParse(input.checkout, `origin/${base}`);
+    }
+    return input.git.revParse(input.checkout, "HEAD");
+}
+/**
+ * Push `yak/<run-id>` and open one draft pull request. A later tick looks up
+ * the branch's pull request and skips both when the remote SHA already matches.
+ * Failures stay on this job (`HostError` text) and do not escape.
+ */
+export function deliverJob(request) {
+    const branch = `yak/${request.runId}`;
+    const prior = readDelivery(request.config.kilnDir, request.job.id);
+    const sameRun = prior?.runId === request.runId ? prior : undefined;
+    try {
+        const localSha = request.host.git.revParse(request.checkout, branch);
+        if (sameRun?.prNumber && sameRun.prUrl && sameRun.sha === localSha) {
+            return { ok: true, detail: sameRun.prUrl, prUrl: sameRun.prUrl, prNumber: sameRun.prNumber };
+        }
+        // Ask gh before pushing so a missing or logged-out CLI does not publish the branch.
+        let existing = request.host.github.findByHead(request.checkout, branch);
+        const remoteSha = request.host.git.remoteBranchSha(request.checkout, branch);
+        if (remoteSha !== localSha) {
+            request.host.git.pushBranch(request.checkout, branch, request.baseBranch);
+        }
+        writeDelivery(request.config.kilnDir, {
+            jobId: request.job.id,
+            runId: request.runId,
+            branch,
+            base: request.baseBranch,
+            sha: localSha,
+            pushed: true,
+            ...(sameRun?.prNumber ? { prNumber: sameRun.prNumber, prUrl: sameRun.prUrl } : {}),
+        });
+        if (!existing)
+            existing = request.host.github.findByHead(request.checkout, branch);
+        const pr = existing ??
+            (sameRun?.prNumber && sameRun.prUrl
+                ? {
+                    number: sameRun.prNumber,
+                    url: sameRun.prUrl,
+                    state: "OPEN",
+                    mergedAt: null,
+                    head: branch,
+                    base: request.baseBranch,
+                }
+                : request.host.github.createDraft({
+                    checkout: request.checkout,
+                    head: branch,
+                    base: request.baseBranch,
+                    title: request.job.title,
+                    body: pullRequestBody(request),
+                }));
+        writeDelivery(request.config.kilnDir, {
+            jobId: request.job.id,
+            runId: request.runId,
+            branch,
+            base: request.baseBranch,
+            sha: localSha,
+            pushed: true,
+            prNumber: pr.number,
+            prUrl: pr.url,
+        });
+        return { ok: true, detail: pr.url, prUrl: pr.url, prNumber: pr.number };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const kept = readDelivery(request.config.kilnDir, request.job.id);
+        const base = kept?.runId === request.runId ? kept : sameRun;
+        writeDelivery(request.config.kilnDir, {
+            jobId: request.job.id,
+            runId: request.runId,
+            branch,
+            base: request.baseBranch,
+            ...(base?.sha ? { sha: base.sha } : {}),
+            pushed: base?.pushed ?? false,
+            ...(base?.prNumber ? { prNumber: base.prNumber, prUrl: base.prUrl } : {}),
+            error: message,
+        });
+        return { ok: false, detail: message };
+    }
+}
+/** First paragraph of the job spec, capped, plus the job id and reviewer verdicts. */
+export function pullRequestBody(request) {
+    const spec = readJobSpec(request.config.kilnDir, request.job);
+    const summary = specSummary(spec);
+    const reviews = reviewerLines(join(request.checkout, ".runs", request.runId, "artifacts"));
+    return [
+        summary,
+        "",
+        `Kiln job: ${request.job.id}`,
+        "",
+        "## Reviewers",
+        ...(reviews.length > 0 ? reviews : ["- (no reviewer artifacts)"]),
+        "",
+    ].join("\n");
+}
+export function specSummary(specText) {
+    const lines = specText.split(/\r?\n/);
+    const body = [];
+    let skippedTitle = false;
+    for (const line of lines) {
+        if (!skippedTitle && /^#\s+/.test(line)) {
+            skippedTitle = true;
+            continue;
+        }
+        body.push(line);
+    }
+    const paragraph = (body.join("\n").trim().split(/\n\s*\n/)[0] ?? "").trim().replace(/\s+/g, " ");
+    if (!paragraph)
+        return "(empty spec)";
+    if (paragraph.length <= 500)
+        return paragraph;
+    return `${paragraph.slice(0, 497)}...`;
+}
+function reviewerLines(artifactsDir) {
+    const lines = [];
+    for (const name of ["security", "ux", "ui", "code"]) {
+        const verdict = verdictOf(latestArtifact(artifactsDir, name));
+        if (verdict)
+            lines.push(`- ${name}: ${verdict}`);
+    }
+    const decision = verdictOf(latestArtifact(artifactsDir, "decision"), "decision");
+    if (decision)
+        lines.push(`- approver: ${decision}`);
+    return lines;
+}
+function verdictOf(value, field = "verdict") {
+    if (typeof value !== "object" || value === null || !(field in value))
+        return undefined;
+    const verdict = value[field];
+    return typeof verdict === "string" && verdict.length > 0 ? verdict : undefined;
+}
+function latestArtifact(dir, name) {
+    if (!existsSync(dir))
+        return undefined;
+    let best;
+    for (const file of readdirSync(dir)) {
+        if (file === `${name}.json`) {
+            if (!best || best.n <= 0)
+                best = { n: 0, file };
+            continue;
+        }
+        const match = new RegExp(`^${name}\\.(\\d+)\\.json$`).exec(file);
+        if (!match?.[1])
+            continue;
+        const n = Number(match[1]);
+        if (!best || n >= best.n)
+            best = { n, file };
+    }
+    if (!best)
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(join(dir, best.file), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** True when `gh pr view` says the pull request is merged, including a squash. */
+export function isMerged(pr) {
+    return pr.state === "MERGED" || (typeof pr.mergedAt === "string" && pr.mergedAt.length > 0);
+}