@bli-cockpit/cli 0.2.48 → 0.2.50

package/dist/local-state-work-context.js

@@ -0,0 +1,190 @@
+import { LocalWorkContextSchema, } from "@bli-cockpit/telemetry-core";
+import crypto from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { ensureRuntimeDirectories, getCollectorRuntimePaths, workContextFile, } from "./local-state-paths.js";
+import { readJsonFile, writeJsonFile } from "./local-state-files.js";
+import { LOCAL_COLLECTOR_VERSION, readLocalCollectorConfig, } from "./local-state-config.js";
+import { readLocalSessionReference } from "./local-state-session.js";
+import { resolveIdentityOrFallback } from "./local-state-identity.js";
+import { validateAttributedTargetIdentity } from "./local-state-attributed-target.js";
+/** What `cockpit start` binds: the repo, branch and ticket this session's work belongs to. */
+export async function startLocalWorkContext(options = {}) {
+    return writeLocalWorkContext(options);
+}
+/**
+ * Starts a context for a transcript-attributed sync target that does not exist
+ * in the current git inventory, such as an approved wrapper folder or a
+ * deleted repo reconstructed from transcript provenance. This internal path
+ * validates the exact target identity before writing any context state.
+ */
+export async function startLocalWorkContextForAttributedTarget(options, attributedIdentity) {
+    const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
+    const identity = await validateAttributedTargetIdentity(repoRoot, attributedIdentity);
+    return writeLocalWorkContext(options, identity);
+}
+async function writeLocalWorkContext(options, attributedIdentity) {
+    if (options.activeTicketId && options.clearTicket) {
+        throw new Error("--ticket and --clear-ticket cannot be combined.");
+    }
+    const now = options.now ?? new Date();
+    const homeDir = options.homeDir ?? os.homedir();
+    const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
+    const paths = getCollectorRuntimePaths(homeDir);
+    await ensureRuntimeDirectories(paths);
+    const config = await readLocalCollectorConfig(paths).catch(() => null);
+    const session = await readLocalSessionReference(paths, {
+        operatorId: options.operatorId,
+        sessionId: options.sessionId,
+    });
+    const identity = attributedIdentity ??
+        (await resolveIdentityOrFallback(repoRoot, options.branch));
+    const branch = attributedIdentity
+        ? attributedIdentity.branch
+        : (options.branch ?? identity.branch);
+    const sessionId = options.sessionId ??
+        (session.session_state === "missing" ? `local-${crypto.randomUUID()}` : session.session_id);
+    const operatorId = options.operatorId ?? session.operator_id;
+    const deviceId = session.device_id ?? config?.device_id ?? "device-unknown";
+    const workContextId = stableWorkContextId({
+        operatorId,
+        deviceId,
+        repoFingerprint: identity.repo_fingerprint,
+        worktreeFingerprint: identity.worktree_fingerprint,
+    });
+    const existingContext = await readLocalWorkContextByFingerprint(paths, identity.worktree_fingerprint).catch(() => null);
+    const context = buildWorkContext({
+        options,
+        now,
+        identity,
+        branch,
+        operatorId,
+        sessionId,
+        workContextId,
+        existingContext,
+    });
+    await writeJsonFile(workContextFile(paths, identity.worktree_fingerprint), context);
+    await writeJsonFile(paths.active_work_context_file, context);
+    return context;
+}
+/**
+ * The context record itself, kept in one piece because it is a schema: every
+ * field an ambient envelope will later carry as provenance is decided here.
+ */
+function buildWorkContext(input) {
+    const { options, now, identity, branch, operatorId, sessionId, workContextId, existingContext } = input;
+    const { activeTicketId, ticketBindingCandidates } = resolveTicketBinding(options, existingContext);
+    return LocalWorkContextSchema.parse({
+        work_context_id: workContextId,
+        repo: identity.repo_root,
+        branch,
+        repo_label: identity.repo_label,
+        repo_fingerprint: identity.repo_fingerprint,
+        repo_origin_url: identity.repo_origin_url ?? undefined,
+        head_sha: identity.head_sha ?? undefined,
+        worktree_label: identity.worktree_label,
+        worktree_fingerprint: identity.worktree_fingerprint,
+        worktree_is_primary: identity.worktree_is_primary,
+        operator_id: operatorId,
+        session_id: sessionId,
+        started_at: existingContext?.started_at ?? now.toISOString(),
+        updated_at: now.toISOString(),
+        active_ticket_id: activeTicketId,
+        ticket_binding_candidates: ticketBindingCandidates,
+        topic_label: options.topicLabel,
+        topic_summary_redacted: options.topicSummaryRedacted,
+        work_intent: options.workIntent,
+        work_phase: options.workPhase,
+        intent_source: options.intentSource,
+        intent_confidence: options.intentConfidence,
+        pull_request_url: existingContext?.pull_request_url,
+        provenance: {
+            capture_source: "collector_runtime",
+            capture_adapter_version: LOCAL_COLLECTOR_VERSION,
+            collector_version: LOCAL_COLLECTOR_VERSION,
+            repo: identity.repo_root,
+            branch,
+            repo_label: identity.repo_label,
+            repo_fingerprint: identity.repo_fingerprint,
+            repo_origin_url: identity.repo_origin_url ?? undefined,
+            worktree_label: identity.worktree_label,
+            worktree_fingerprint: identity.worktree_fingerprint,
+            worktree_is_primary: identity.worktree_is_primary,
+            operator_id: operatorId,
+            session_id: sessionId,
+            work_context_id: workContextId,
+        },
+    });
+}
+/**
+ * Three answers, not two: a named ticket binds, `--clear-ticket` unbinds, and
+ * saying neither leaves whatever the previous `cockpit start` bound in place.
+ */
+// The return type is inferred deliberately: naming it would mean indexing the
+// context schema by field name, and this module keeps its literals to the ones
+// that reach disk.
+function resolveTicketBinding(options, existingContext) {
+    const activeTicketId = options.clearTicket
+        ? undefined
+        : (options.activeTicketId ?? existingContext?.active_ticket_id);
+    const ticketBindingCandidates = options.activeTicketId
+        ? [
+            {
+                ticket_id: options.activeTicketId,
+                binding_source: "active_work_context",
+                confidence: 1,
+                evidence_labels: ["cockpit_start_ticket"],
+            },
+        ]
+        : options.clearTicket
+            ? []
+            : (existingContext?.ticket_binding_candidates ?? []);
+    return { activeTicketId, ticketBindingCandidates };
+}
+/** The active context: what the last `cockpit start` on this machine bound, whatever the folder. */
+export async function readLocalWorkContext(paths) {
+    return LocalWorkContextSchema.parse(await readJsonFile(paths.active_work_context_file));
+}
+/**
+ * The context for ONE repo, because a machine running two checkouts at once
+ * would otherwise attribute both to whichever was started last.
+ */
+export async function readLocalWorkContextForRepo(paths, repoRoot) {
+    const identity = await resolveIdentityOrFallback(repoRoot);
+    const context = await readLocalWorkContextByFingerprint(paths, identity.worktree_fingerprint).catch(() => null);
+    if (context)
+        return context;
+    const active = await readLocalWorkContext(paths);
+    if (active.worktree_fingerprint === identity.worktree_fingerprint ||
+        path.resolve(active.repo) === identity.repo_root) {
+        return active;
+    }
+    throw new Error(`Active work context missing for ${identity.worktree_label}. Run \`cockpit start --workspace "${identity.repo_root}"\`.`);
+}
+async function readLocalWorkContextByFingerprint(paths, worktreeFingerprint) {
+    return LocalWorkContextSchema.parse(await readJsonFile(workContextFile(paths, worktreeFingerprint)));
+}
+/**
+ * The same operator, device, repo and worktree must produce the same id on
+ * every run, because the ambient envelope joins sessions on it.
+ */
+function stableWorkContextId(input) {
+    return `work-${sha256([
+        input.operatorId,
+        input.deviceId,
+        input.repoFingerprint,
+        input.worktreeFingerprint,
+    ].join(":")).slice(0, 32)}`;
+}
+function sha256(value) {
+    return crypto.createHash("sha256").update(value, "utf8").digest("hex");
+}
+/**
+ * The label a person reads for a work context — repo over worktree, so two
+ * checkouts of one repo are told apart at a glance.
+ */
+export function workDisplayLabel(context) {
+    const repoLabel = (context.repo_label ?? path.basename(context.repo)) || "workspace";
+    const worktreeLabel = context.worktree_label ?? repoLabel;
+    return `${repoLabel}/${worktreeLabel}`;
+}