@lchase/kiln 0.0.0-stage → 0.3.0

package/dist/intake/tickets.js

@@ -0,0 +1,448 @@
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { INVESTIGATION_WORKFLOW } from "../findings.js";
+import { listValidJobs, newJobId, writeJob } from "../jobs.js";
+import { assertWorkflowName } from "../workflow.js";
+/** Context files larger than this are named in the spec instead of copied in. */
+export const CONTEXT_INLINE_LIMIT = 40 * 1024;
+const TICKET_FILE = /^(\d+)-.+\.md$/;
+/**
+ * `kiln import <dir> --repo R`. One job per `NN-slug.md` file.
+ * Re-running keys on the ticket directory plus the filename (`source.ref`).
+ */
+export function importTickets(config, input) {
+    const dirAbs = resolveTicketDir(input.cwd, input.dir);
+    if (!config.repos[input.repo]) {
+        const known = Object.keys(config.repos).sort();
+        const suffix = known.length > 0 ? ` Known repos: ${known.join(", ")}.` : " No repos are registered.";
+        throw new Error(`Unknown repo ${input.repo}.${suffix} Run kiln repo add ${input.repo} <path>.`);
+    }
+    const requested = input.workflow ?? "feature";
+    assertWorkflowName(requested);
+    const context = resolveContext(dirAbs, input.contextPath, input.cwd);
+    const tickets = readTickets(dirAbs);
+    const warnings = [];
+    const workflows = new Map();
+    for (const ticket of tickets) {
+        const workflow = workflowFor(ticket, requested);
+        if (workflow !== requested)
+            assertWorkflowName(workflow);
+        workflows.set(ticket.path, workflow);
+    }
+    if (input.stack) {
+        const offender = tickets.find((ticket) => ticket.blockedBy.length > 1) ??
+            tickets.find((ticket) => ticket.blockedBy.length !== 1);
+        if (offender) {
+            throw new Error(`Ticket ${offender.file} has ${offender.blockedBy.length} dependencies. stack needs exactly one.`);
+        }
+        for (const ticket of tickets) {
+            const dep = ticket.blockedBy[0];
+            if (!dep)
+                continue;
+            const upstream = tickets.find((candidate) => candidate.number === dep.number);
+            if (!upstream || workflows.get(upstream.path) !== INVESTIGATION_WORKFLOW)
+                continue;
+            throw new Error(`Ticket ${ticket.file} stacks on ${upstream.file}, which is an investigation. An investigation does not land a branch.`);
+        }
+    }
+    const existing = new Map();
+    for (const job of listValidJobs(config)) {
+        if (job.source?.kind !== "tickets")
+            continue;
+        if (!existing.has(job.source.ref))
+            existing.set(job.source.ref, job);
+    }
+    const assigned = new Map();
+    const start = input.now ?? new Date();
+    let offset = 0;
+    for (const ticket of tickets) {
+        const prior = existing.get(ticket.path);
+        if (prior) {
+            assigned.set(ticket.path, prior.id);
+            continue;
+        }
+        assigned.set(ticket.path, newJobId(new Date(start.getTime() + offset)));
+        offset += 1;
+    }
+    const pendingIds = new Set();
+    for (const ticket of tickets) {
+        if (!existing.has(ticket.path)) {
+            const id = assigned.get(ticket.path);
+            if (id)
+                pendingIds.add(id);
+        }
+    }
+    const rows = [];
+    const writes = [];
+    let newOffset = 0;
+    for (const ticket of tickets) {
+        const id = assigned.get(ticket.path);
+        if (!id)
+            continue;
+        const workflow = workflows.get(ticket.path) ?? requested;
+        const dependsOn = ticket.blockedBy.map((dep) => {
+            const upstream = tickets.find((candidate) => candidate.number === dep.number);
+            const upstreamId = upstream ? assigned.get(upstream.path) : undefined;
+            if (!upstream || !upstreamId) {
+                throw new Error(`Ticket ${ticket.file} blocks on unknown ticket ${dep.raw}.`);
+            }
+            return upstreamId;
+        });
+        const depLabels = ticket.blockedBy.map((dep) => {
+            const upstream = tickets.find((candidate) => candidate.number === dep.number);
+            return upstream?.label ?? dep.raw;
+        });
+        const prior = existing.get(ticket.path);
+        if (prior) {
+            rows.push({
+                status: "unchanged",
+                label: ticket.label,
+                title: prior.title,
+                workflow: prior.workflow,
+                depLabels,
+                jobId: prior.id,
+            });
+            continue;
+        }
+        const now = new Date(start.getTime() + newOffset);
+        newOffset += 1;
+        writes.push({ ticket, id, now, dependsOn });
+        rows.push({
+            status: "new",
+            label: ticket.label,
+            title: ticket.title,
+            workflow,
+            depLabels,
+            ...(input.dryRun ? {} : { jobId: id }),
+        });
+    }
+    if (!input.dryRun) {
+        for (const write of writes) {
+            const workflow = workflows.get(write.ticket.path) ?? requested;
+            writeJob(config, {
+                id: write.id,
+                workflow,
+                repo: input.repo,
+                specText: composeSpec(write.ticket.text, context),
+                title: write.ticket.title,
+                dependsOn: write.dependsOn,
+                ...(input.stack ? { stack: true } : {}),
+                source: { kind: "tickets", ref: write.ticket.path },
+                now: write.now,
+                pendingIds,
+            });
+        }
+    }
+    return {
+        report: renderImport(dirAbs, input.repo, rows, input.dryRun),
+        warnings,
+    };
+}
+function resolveTicketDir(cwd, dir) {
+    const resolved = resolve(cwd, dir);
+    if (!existsSync(resolved) || !statSync(resolved).isDirectory()) {
+        throw new Error(`Ticket directory ${resolved} does not exist or is not a directory.`);
+    }
+    return realpathSync(resolved);
+}
+function resolveContext(dirAbs, contextPath, cwd) {
+    const explicit = contextPath ? resolve(cwd, contextPath) : undefined;
+    const fallback = join(dirname(dirAbs), "spec.md");
+    const path = explicit ?? (existsSync(fallback) && statSync(fallback).isFile() ? fallback : undefined);
+    if (!path)
+        return undefined;
+    if (!existsSync(path) || !statSync(path).isFile()) {
+        throw new Error(`Could not read context ${path}.`);
+    }
+    const bytes = statSync(path).size;
+    if (bytes > CONTEXT_INLINE_LIMIT)
+        return { path, bytes };
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Could not read context ${path}: ${message}`);
+    }
+    if (!text.trim())
+        return undefined;
+    return { path, bytes, text };
+}
+function composeSpec(ticketText, context) {
+    const base = ticketText.endsWith("\n") ? ticketText : `${ticketText}\n`;
+    if (!context)
+        return base;
+    if (context.text === undefined) {
+        return `${base}\n## Background\n\nContext: ${context.path} (${context.bytes} bytes). The file is larger than 40KB and is referenced by path.\n`;
+    }
+    const body = context.text.endsWith("\n") ? context.text : `${context.text}\n`;
+    return `${base}\n## Background\n\n${body}`;
+}
+function workflowFor(ticket, requested) {
+    return workflowForSpike(ticket.spike, requested);
+}
+/**
+ * Spike and research work uses the investigation workflow.
+ * Jira intake calls this for issue types Spike and Research.
+ */
+export function workflowForSpike(spike, requested) {
+    if (!spike)
+        return requested;
+    return INVESTIGATION_WORKFLOW;
+}
+function readTickets(dirAbs) {
+    const names = readdirSync(dirAbs)
+        .filter((name) => TICKET_FILE.test(name))
+        .sort((left, right) => ticketNumber(left) - ticketNumber(right) || left.localeCompare(right));
+    if (names.length === 0) {
+        throw new Error(`No NN-slug.md tickets in ${dirAbs}.`);
+    }
+    const tickets = names.map((name) => parseTicket(dirAbs, name));
+    const byNumber = new Map();
+    for (const ticket of tickets) {
+        const prior = byNumber.get(ticket.number);
+        if (prior) {
+            throw new Error(`Tickets ${prior.file} and ${ticket.file} share number ${ticket.label}.`);
+        }
+        byNumber.set(ticket.number, ticket);
+    }
+    const problems = [];
+    for (const ticket of tickets) {
+        if (ticket.blockedBy.some((dep) => dep.number === ticket.number)) {
+            problems.push(`${ticket.file} blocks on itself.`);
+            continue;
+        }
+        const unknown = ticket.blockedBy.filter((dep) => !byNumber.has(dep.number));
+        if (unknown.length === 0)
+            continue;
+        const listed = unknown.map((dep) => dep.raw).join(", ");
+        const noun = unknown.length === 1 ? "ticket" : "tickets";
+        problems.push(`${ticket.file} blocks on unknown ${noun} ${listed}.`);
+    }
+    if (problems.length > 0) {
+        throw new Error(problems.join("\n"));
+    }
+    return tickets;
+}
+function parseTicket(dirAbs, file) {
+    const path = join(dirAbs, file);
+    const label = ticketLabel(file);
+    const number = ticketNumber(file);
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Could not read ticket ${file}: ${message}`);
+    }
+    if (!text.trim()) {
+        throw new Error(`Ticket ${file} is empty.`);
+    }
+    let meta;
+    let body;
+    try {
+        ({ meta, body } = splitFrontMatter(text));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Could not read front matter in ${file}: ${message}`);
+    }
+    let bodyDeps;
+    try {
+        bodyDeps = blockedByFromBody(body, file);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(message);
+    }
+    const heading = headingTitle(body);
+    if (heading?.number !== undefined && heading.number !== number) {
+        throw new Error(`Ticket ${file} heading is numbered ${heading.rawNumber ?? heading.number}, not ${label}.`);
+    }
+    const title = heading?.title ?? meta.title;
+    if (!title) {
+        throw new Error(`Ticket ${file} has no title. Expected a "# NN: Title" heading or front matter title.`);
+    }
+    return {
+        file,
+        path,
+        label,
+        number,
+        title,
+        text,
+        blockedBy: dedupeRefs([...meta.blockedBy, ...bodyDeps]),
+        spike: looksLikeSpike(title, text, meta.type),
+    };
+}
+function splitFrontMatter(text) {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
+    if (!match?.[1])
+        return { meta: { blockedBy: [] }, body: text };
+    return { meta: parseFrontMatter(match[1]), body: text.slice(match[0].length) };
+}
+function parseFrontMatter(yaml) {
+    const lines = yaml.split(/\r?\n/);
+    let title;
+    let type;
+    const blockedBy = [];
+    let listKey;
+    for (const line of lines) {
+        if (!line.trim() || line.trim().startsWith("#"))
+            continue;
+        const item = /^\s*-\s+(.+)$/.exec(line);
+        if (item?.[1] && listKey === "blocked-by") {
+            blockedBy.push(...refsFromScalar(item[1]));
+            continue;
+        }
+        const field = /^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/.exec(line);
+        if (!field?.[1])
+            continue;
+        listKey = undefined;
+        const key = field[1];
+        const value = field[2] ?? "";
+        if (key === "title")
+            title = unquote(value);
+        else if (key === "type")
+            type = unquote(value);
+        else if (key === "blocked-by") {
+            if (!value.trim())
+                listKey = "blocked-by";
+            else
+                blockedBy.push(...refsFromScalar(value));
+        }
+    }
+    return { title: title?.trim() || undefined, type: type?.trim() || undefined, blockedBy };
+}
+function refsFromScalar(raw) {
+    const value = unquote(raw.trim());
+    if (!value || /^(none\b.*|null|~)$/i.test(value))
+        return [];
+    const flow = /^\[([\s\S]*)\]$/.exec(value);
+    if (flow?.[1] !== undefined) {
+        const inner = flow[1].trim();
+        if (!inner)
+            return [];
+        return inner.split(",").flatMap((part) => refsFromScalar(part));
+    }
+    const num = /^(\d+)\b/.exec(value);
+    if (!num?.[1]) {
+        throw new Error(`could not read blocked-by value ${JSON.stringify(raw)}`);
+    }
+    return [{ raw: num[1], number: Number(num[1]) }];
+}
+function blockedByFromBody(body, filename) {
+    const lines = body.split(/\r?\n/);
+    const start = lines.findIndex((line) => /^\*\*Blocked by:\*\*/i.test(line.trim()));
+    if (start < 0)
+        return [];
+    const collected = [];
+    const inline = /^\*\*Blocked by:\*\*\s*(.*)$/i.exec(lines[start]?.trim() ?? "");
+    if (inline?.[1]?.trim())
+        collected.push(inline[1].trim());
+    for (let index = start + 1; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        if (!line.trim())
+            continue;
+        const trimmed = line.trim();
+        if (/^#{1,6}\s/.test(trimmed) || /^\*\*[^*]/.test(trimmed))
+            break;
+        const bullet = /^[-*]\s+/.test(trimmed);
+        const none = /^none\b/i.test(trimmed) || /^[-*]\s+none\b/i.test(trimmed);
+        if (!bullet && !none) {
+            if (collected.length > 0)
+                break;
+            throw new Error(`Could not read blocked-by line ${JSON.stringify(trimmed)} in ${filename}.`);
+        }
+        collected.push(trimmed);
+    }
+    const refs = [];
+    for (const line of collected) {
+        const bullet = /^[-*]\s+(.*)$/.exec(line);
+        const text = (bullet?.[1] ?? line).trim();
+        if (/^none\b/i.test(text))
+            continue;
+        const num = /^(\d+)\b/.exec(text);
+        if (!num?.[1]) {
+            throw new Error(`Could not read blocked-by line ${JSON.stringify(line)} in ${filename}.`);
+        }
+        refs.push({ raw: num[1], number: Number(num[1]) });
+    }
+    return refs;
+}
+function headingTitle(body) {
+    for (const line of body.split(/\r?\n/)) {
+        const heading = /^#\s+(.+?)\s*$/.exec(line);
+        if (!heading?.[1])
+            continue;
+        const numbered = /^(\d+)\s*:\s+(\S.*?)$/.exec(heading[1]);
+        if (numbered?.[1] && numbered[2]) {
+            return { title: `${numbered[1]}: ${numbered[2]}`, number: Number(numbered[1]), rawNumber: numbered[1] };
+        }
+        return { title: heading[1] };
+    }
+    return undefined;
+}
+/**
+ * A spike is a typed research ticket, a title that says spike or probe, or text
+ * that says there is no product code. Mentioning an upstream spike in the body
+ * does not count.
+ */
+function looksLikeSpike(title, text, type) {
+    if (typeLooksLikeSpike(type))
+        return true;
+    if (/\b(spike|probe)\b/i.test(title))
+        return true;
+    return /no product code/i.test(text);
+}
+/** `spike`, `investigation`, `research`, or that word after a colon (`wayfinder:research`). */
+export function typeLooksLikeSpike(type) {
+    if (!type)
+        return false;
+    return type.split(":").some((part) => /^(spike|investigation|research)$/i.test(part.trim()));
+}
+function dedupeRefs(refs) {
+    const seen = new Set();
+    const out = [];
+    for (const ref of refs) {
+        if (seen.has(ref.number))
+            continue;
+        seen.add(ref.number);
+        out.push(ref);
+    }
+    return out;
+}
+function ticketLabel(file) {
+    const label = TICKET_FILE.exec(basename(file))?.[1];
+    if (!label)
+        throw new Error(`Ticket ${file} does not match NN-slug.md.`);
+    return label;
+}
+function ticketNumber(file) {
+    return Number(ticketLabel(file));
+}
+function unquote(value) {
+    const trimmed = value.trim();
+    const quoted = /^(['"])([\s\S]*)\1$/.exec(trimmed);
+    return quoted?.[2] ?? trimmed;
+}
+function renderImport(dir, repo, rows, dryRun) {
+    const lines = [`import ${dir}`, `repo ${repo}`];
+    for (const row of rows) {
+        const deps = row.depLabels.length > 0 ? row.depLabels.join(", ") : "none";
+        if (dryRun) {
+            lines.push(`${row.label}  ${row.title}  ${row.workflow}  deps ${deps}  ${row.status}`);
+        }
+        else {
+            lines.push(`${row.status} ${row.jobId}  ${row.label}  ${row.title}  ${row.workflow}  deps ${deps}`);
+        }
+    }
+    const created = rows.filter((row) => row.status === "new").length;
+    const unchanged = rows.filter((row) => row.status === "unchanged").length;
+    if (dryRun)
+        lines.push(`dry-run: ${created} new, ${unchanged} unchanged, created nothing`);
+    else
+        lines.push(`imported ${created} new, ${unchanged} unchanged`);
+    return `${lines.join("\n")}\n`;
+}

package/dist/jobs.js

@@ -0,0 +1,154 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, isAbsolute, join } from "node:path";
+import { INVESTIGATION_WORKFLOW } from "./findings.js";
+import { jobBasename } from "./paths.js";
+import { JobSchema } from "./schemas.js";
+import { assertWorkflowName } from "./workflow.js";
+export function newJobId(now = new Date()) {
+    const stamp = now.toISOString().replace(/[-:TZ.]/g, "").slice(0, 14);
+    return `j${stamp}${randomBytes(2).toString("hex")}`;
+}
+export function jobFilePath(jobsDir, id) {
+    return join(jobsDir, `${jobBasename(id)}.json`);
+}
+export function resolveJobSpec(kilnDir, spec) {
+    return isAbsolute(spec) ? spec : join(kilnDir, spec);
+}
+export function readJobSpec(kilnDir, job) {
+    const path = resolveJobSpec(kilnDir, job.spec);
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Could not read spec for job ${job.id} at ${path}: ${message}`);
+    }
+}
+export function titleFromSpec(text, filePath) {
+    for (const line of text.split("\n")) {
+        const heading = /^#\s+(.+?)\s*$/.exec(line);
+        if (heading?.[1])
+            return heading[1];
+    }
+    const base = basename(filePath).replace(/\.md$/i, "");
+    if (!base || base === "." || base === "..") {
+        throw new Error(`Could not derive a title from ${filePath}. Pass --title.`);
+    }
+    return base;
+}
+/** Persist one job. Intake adapters call this; they do not write job files themselves. */
+export function writeJob(config, input) {
+    assertWorkflowName(input.workflow);
+    if (!config.repos[input.repo]) {
+        const known = Object.keys(config.repos).sort();
+        const suffix = known.length > 0 ? ` Known repos: ${known.join(", ")}.` : " No repos are registered.";
+        throw new Error(`Unknown repo ${input.repo}.${suffix} Run kiln repo add ${input.repo} <path>.`);
+    }
+    if (!input.specText.trim()) {
+        throw new Error("Job spec is empty.");
+    }
+    const title = input.title.trim();
+    if (!title) {
+        throw new Error("Job title is empty. Pass --title.");
+    }
+    const now = input.now ?? new Date();
+    const id = input.id ?? newJobId(now);
+    const dependsOn = normalizedDepends(input.dependsOn);
+    if (dependsOn.includes(id)) {
+        throw new Error(`Job ${id} cannot depend on itself.`);
+    }
+    const known = listValidJobs(config);
+    assertCanStack(input.repo, dependsOn, input.stack, known);
+    const knownIds = new Set(known.map((job) => job.id));
+    for (const pending of input.pendingIds ?? [])
+        knownIds.add(pending);
+    for (const dep of dependsOn) {
+        if (!knownIds.has(dep)) {
+            throw new Error(`Job ${dep} does not exist. --after must name a job already under ${config.jobsDir}.`);
+        }
+    }
+    const specRel = `specs/${id}.md`;
+    const specDest = join(config.kilnDir, specRel);
+    mkdirSync(join(config.kilnDir, "specs"), { recursive: true });
+    writeFileSync(specDest, input.specText);
+    const job = JobSchema.parse({
+        id,
+        repo: input.repo,
+        workflow: input.workflow,
+        spec: specRel,
+        title,
+        ...(dependsOn.length > 0 ? { dependsOn } : {}),
+        ...(input.stack ? { stack: true } : {}),
+        source: input.source,
+        createdAt: now.toISOString(),
+    });
+    mkdirSync(config.jobsDir, { recursive: true });
+    const jsonPath = jobFilePath(config.jobsDir, job.id);
+    writeFileSync(jsonPath, `${JSON.stringify(job, null, 2)}\n`);
+    return { job, jsonPath };
+}
+export function renderAddedJob(job, jsonPath) {
+    const lines = [`added ${job.id}`, `repo ${job.repo}`, `workflow ${job.workflow}`, `spec ${job.spec}`];
+    if (job.stack)
+        lines.push("stack");
+    if (job.source)
+        lines.push(`source ${job.source.kind} ${job.source.ref}`);
+    lines.push(`wrote ${jsonPath}`, "");
+    return lines.join("\n");
+}
+/** Valid job files. Unreadable files are skipped; the driver reports those. */
+export function listValidJobs(config) {
+    if (!existsSync(config.jobsDir))
+        return [];
+    const jobs = [];
+    for (const name of readdirSync(config.jobsDir)) {
+        if (!name.endsWith(".json"))
+            continue;
+        try {
+            const raw = JSON.parse(readFileSync(join(config.jobsDir, name), "utf8"));
+            const job = JobSchema.parse(raw);
+            if (`${jobBasename(job.id)}.json` === name)
+                jobs.push(job);
+        }
+        catch {
+            // An unreadable job is not a dependency target. The driver reports it.
+        }
+    }
+    return jobs;
+}
+/**
+ * `stack` needs one upstream in the same repo: the pull request has one base
+ * branch, and the worktree is cut from that branch. Zero dependencies and
+ * two or more are both rejected. An investigation upstream is rejected: that
+ * workflow does not land a branch. An upstream that is not on disk yet is
+ * allowed here so an import batch can validate the count before every job
+ * exists; the same-repo check runs when the upstream file is already there.
+ */
+export function assertCanStack(repo, dependsOn, stack, known = []) {
+    if (!stack)
+        return;
+    if (dependsOn.length !== 1) {
+        throw new Error(`stack needs exactly one dependency so the pull request has one base branch. Got ${dependsOn.length}.`);
+    }
+    const upstreamId = dependsOn[0];
+    const upstream = known.find((job) => job.id === upstreamId);
+    if (upstream?.workflow === INVESTIGATION_WORKFLOW) {
+        throw new Error(`stack cannot target investigation job ${upstreamId}. An investigation does not land a branch.`);
+    }
+    if (upstream && upstream.repo !== repo) {
+        throw new Error(`stack needs upstream ${upstreamId} to be in repo ${repo}. That job is in repo ${upstream.repo}.`);
+    }
+}
+function normalizedDepends(dependsOn) {
+    const seen = new Set();
+    const out = [];
+    for (const id of dependsOn) {
+        if (seen.has(id)) {
+            throw new Error(`--after lists ${id} more than once.`);
+        }
+        seen.add(id);
+        out.push(id);
+    }
+    return out;
+}

package/dist/paths.js

@@ -0,0 +1,34 @@
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Directory of the Kiln package that contains this file.
+ *
+ * Starts at `import.meta.url` and walks up to the nearest `package.json`.
+ * That is the repo root in a checkout (`src/` via tsx, or compiled `dist/`)
+ * and the installed package root for `node_modules/@lchase/kiln`. Workflows
+ * and prompts are read from there, not from `process.cwd()`.
+ */
+export function packageRoot() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 6; i += 1) {
+        if (existsSync(join(dir, "package.json")))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new Error("Could not find package.json above the running file.");
+}
+/** One path segment. Job ids we generate already pass; this rejects `..` and slashes. */
+export function jobBasename(id) {
+    const safe = id
+        .replace(/[^A-Za-z0-9._-]+/g, "-")
+        .replace(/^[-.]+/, "")
+        .replace(/[-.]+$/, "");
+    if (!safe) {
+        throw new Error(`Job id ${JSON.stringify(id)} cannot be used as a file name.`);
+    }
+    return safe;
+}