kibi-cli 1.0.1 → 2.1.0

package/dist/operations/mutation/workspace-mutation-lock.js

@@ -0,0 +1,362 @@
+import { mkdirSync, readFileSync, rmdirSync, unlinkSync, writeFileSync, } from "node:fs";
+import * as path from "node:path";
+import { InputError, OperationError } from "../../cli-errors.js";
+/**
+ * Portable cooperative mutex for Kibi source mutations. The lock protects
+ * cooperating Kibi writers; arbitrary external processes remain outside this
+ * protocol and cannot be CAS-protected by it.
+ */
+const DEFAULT_LOCK_FILE_RELATIVE = path.join(".kb", "recovery", "source-authoring.lock");
+const OWNER_FILE = "owner.json";
+const DEFAULT_TIMEOUT_MS = 15_000;
+const RETRY_INTERVAL_MS = 25;
+const MAX_RELEASE_FILESYSTEM_ATTEMPTS = 3;
+/** Bounded rereads for the transient mkdir->owner and unlink->rmdir windows. */
+const MAX_MISSING_OWNER_REREADS = 4;
+const NODE_FILE_SYSTEM = {
+    mkdirSync: (target, options) => {
+        mkdirSync(target, options);
+    },
+    readFileSync: (target) => readFileSync(target, "utf8"),
+    writeFileSync: (target, data, options) => {
+        writeFileSync(target, data, options);
+    },
+    unlinkSync: (target) => unlinkSync(target),
+    rmdirSync: (target) => rmdirSync(target),
+};
+// implements REQ-generated-coordinate-persistence
+export class WorkspaceMutationLockError extends Error {
+    name = "WorkspaceMutationLockError";
+}
+function lockPath(workspaceRoot, lockFileRelative) {
+    return path.join(workspaceRoot, lockFileRelative);
+}
+function randomToken() {
+    return `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function readLockRecord(content) {
+    try {
+        const parsed = JSON.parse(content);
+        if (typeof parsed !== "object" ||
+            parsed === null ||
+            typeof parsed.pid !== "number" ||
+            typeof parsed.token !== "string" ||
+            typeof parsed.acquiredAt !== "number") {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function errorDetail(error) {
+    if (!(error instanceof Error))
+        return String(error);
+    const code = error.code;
+    return code === undefined ? error.message : `${code}: ${error.message}`;
+}
+function errorCode(error) {
+    if (typeof error !== "object" || error === null)
+        return undefined;
+    return error.code;
+}
+function isTransientFilesystemError(error) {
+    if (typeof error !== "object" || error === null)
+        return false;
+    const code = error.code;
+    return (code === "EBUSY" ||
+        code === "EAGAIN" ||
+        code === "EINTR" ||
+        code === "EPERM");
+}
+function retryTransientFilesystemOperation(operation, canRetry = () => true) {
+    let attempts = 0;
+    while (attempts < MAX_RELEASE_FILESYSTEM_ATTEMPTS) {
+        attempts += 1;
+        try {
+            return { ok: true, value: operation(), attempts };
+        }
+        catch (error) {
+            if (!isTransientFilesystemError(error) ||
+                attempts === MAX_RELEASE_FILESYSTEM_ATTEMPTS ||
+                !canRetry(error)) {
+                return { ok: false, error, attempts };
+            }
+        }
+    }
+    throw new Error("unreachable retry state");
+}
+function manualCleanupGuidance(target, ownerPath) {
+    return `To clean it manually, verify no operation is active, verify ${ownerPath} and ${target}, then remove ${target}`;
+}
+function removeLockDirectory(fileSystem, target) {
+    const result = retryTransientFilesystemOperation(() => fileSystem.rmdirSync(target));
+    if (result.ok)
+        return;
+    const ownerPath = path.join(target, OWNER_FILE);
+    throw new WorkspaceMutationLockError(`failed to remove workspace mutation lock directory at ${target} after ${result.attempts} attempt(s): ${errorDetail(result.error)}; lock remains fail-closed. ${manualCleanupGuidance(target, ownerPath)}`);
+}
+function removeLockOwner(fileSystem, target, ownerPath, ignoreMissing) {
+    const result = retryTransientFilesystemOperation(() => fileSystem.unlinkSync(ownerPath));
+    if (result.ok)
+        return;
+    const code = errorCode(result.error);
+    if (ignoreMissing && code === "ENOENT")
+        return;
+    throw new WorkspaceMutationLockError(`failed to remove workspace mutation lock owner at ${ownerPath} after ${result.attempts} attempt(s): ${errorDetail(result.error)}; lock remains fail-closed. ${manualCleanupGuidance(target, ownerPath)}`);
+}
+function observeExistingLock(fileSystem, target, ownerPath, isProcessAlive) {
+    let record = null;
+    let source = "lock owner metadata";
+    let ownerMissing = false;
+    try {
+        record = readLockRecord(fileSystem.readFileSync(ownerPath));
+    }
+    catch (ownerError) {
+        ownerMissing = errorCode(ownerError) === "ENOENT";
+        try {
+            source = "legacy lock metadata";
+            record = readLockRecord(fileSystem.readFileSync(target));
+        }
+        catch {
+            // A lock directory without readable owner metadata is the normal
+            // mkdir->owner-publish window (and the unlink->rmdir release window):
+            // callers reread it a bounded number of times before failing closed.
+            // Any other owner read failure is not a creation gap.
+            if (ownerMissing) {
+                return {
+                    kind: "missing",
+                    description: "lock owner metadata is missing",
+                };
+            }
+            return {
+                kind: "recovery",
+                description: "lock owner metadata is missing or unverifiable",
+            };
+        }
+    }
+    if (record === null) {
+        return {
+            kind: "recovery",
+            description: `${source} is corrupt or unverifiable`,
+        };
+    }
+    try {
+        if (isProcessAlive(record.pid)) {
+            return { kind: "live", description: `held by pid ${record.pid}` };
+        }
+    }
+    catch {
+        return {
+            kind: "recovery",
+            description: `holder pid ${record.pid} could not be verified as live`,
+        };
+    }
+    return {
+        kind: "recovery",
+        description: `holder pid ${record.pid} is not live`,
+    };
+}
+function defaultIsProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            "code" in error &&
+            error.code === "ESRCH")
+            return false;
+        throw error;
+    }
+}
+async function defaultSleep(ms) {
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}
+// implements REQ-generated-coordinate-persistence
+export function releaseWorkspaceMutationLock(handle, operationFailure, committed = false) {
+    if (handle === undefined)
+        return;
+    try {
+        handle.release();
+    }
+    catch (releaseError) {
+        if (committed) {
+            throw new OperationError("SOURCE_MUTATION_LOCK_RELEASE_FAILED", `Mutation committed, but workspace source lock release failed: ${errorDetail(releaseError)}; do not retry the mutation until the lock is manually verified and released`, false);
+        }
+        if (operationFailure !== undefined) {
+            throw new AggregateError([operationFailure.error, releaseError], "Operation failed and workspace mutation lock release failed");
+        }
+        throw releaseError;
+    }
+}
+/**
+ * Classify the failure of an operation whose authoritative commit already
+ * happened. Typed operation errors keep their code and retryability; generic
+ * failures are wrapped immediately as non-retryable so callers never read a
+ * committed mutation as an invitation to retry.
+ */
+export function classifySourceMutationFailure(operation, error, committed) {
+    if (!committed)
+        return error;
+    if (error instanceof OperationError || error instanceof InputError) {
+        return error;
+    }
+    const detail = error instanceof Error ? error.message : String(error);
+    return new OperationError("SOURCE_MUTATION_POST_COMMIT_FAILED", `${operation} committed, but a postcommit step failed: ${detail}; do not retry the original mutation; inspect the committed snapshot and recovery metadata before repairing`, false);
+}
+/**
+ * Acquire the workspace workspace mutation lock without a callback shape, for
+ * operations whose lock must span several awaits (source publication,
+ * coordinate refresh, canonical re-extraction, and the RDF commit).
+ */
+// implements REQ-generated-coordinate-persistence
+export async function acquireWorkspaceMutationLock(workspaceRoot, options = {}) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const now = options.now ?? Date.now;
+    const sleep = options.sleep ?? defaultSleep;
+    const fileSystem = options.fileSystem ?? NODE_FILE_SYSTEM;
+    const isProcessAlive = options.isProcessAlive ?? defaultIsProcessAlive;
+    const target = lockPath(workspaceRoot, options.lockFileRelative ?? DEFAULT_LOCK_FILE_RELATIVE);
+    const ownerPath = path.join(target, OWNER_FILE);
+    const token = randomToken();
+    const deadline = now() + timeoutMs;
+    const parentPath = path.dirname(target);
+    const parentResult = retryTransientFilesystemOperation(() => fileSystem.mkdirSync(parentPath, { recursive: true }));
+    if (!parentResult.ok) {
+        throw new WorkspaceMutationLockError(`failed to create workspace mutation lock parent at ${parentPath} after ${parentResult.attempts} attempt(s): ${errorDetail(parentResult.error)}`);
+    }
+    let acquired = false;
+    let lastBlocker = "unknown";
+    let lastObservationMissing = false;
+    let missingOwnerRereads = 0;
+    while (now() < deadline) {
+        const targetResult = retryTransientFilesystemOperation(() => {
+            // Directory creation is the sole atomic lock authority.
+            fileSystem.mkdirSync(target);
+        });
+        if (targetResult.ok) {
+            acquired = true;
+            break;
+        }
+        if (errorCode(targetResult.error) !== "EEXIST") {
+            throw new WorkspaceMutationLockError(`failed to acquire workspace mutation lock directory at ${target} after ${targetResult.attempts} attempt(s): ${errorDetail(targetResult.error)}`);
+        }
+        const observation = observeExistingLock(fileSystem, target, ownerPath, isProcessAlive);
+        lastBlocker = observation.description;
+        lastObservationMissing = observation.kind === "missing";
+        if (observation.kind === "missing") {
+            // A missing owner is usually another holder's transient
+            // mkdir->owner-publish or unlink->rmdir window. Reread a bounded number
+            // of times; never reclaim the lock automatically.
+            if (missingOwnerRereads < MAX_MISSING_OWNER_REREADS) {
+                missingOwnerRereads += 1;
+                await sleep(RETRY_INTERVAL_MS);
+                continue;
+            }
+            throw new OperationError("SOURCE_MUTATION_LOCK_RECOVERY_REQUIRED", `workspace mutation lock at ${target} requires operator recovery: ${observation.description} after ${missingOwnerRereads} reread(s). Quiesce all Kibi and source-mutating writers, then manually verify the owner metadata and remove the lock only after confirming no operation is active`, false);
+        }
+        if (observation.kind === "recovery") {
+            throw new OperationError("SOURCE_MUTATION_LOCK_RECOVERY_REQUIRED", `workspace mutation lock at ${target} requires operator recovery: ${observation.description}. Quiesce all Kibi and source-mutating writers, then manually verify the owner metadata and remove the lock only after confirming no operation is active`, false);
+        }
+        await sleep(RETRY_INTERVAL_MS);
+    }
+    if (!acquired) {
+        if (lastObservationMissing) {
+            // The deadline expired inside a sustained missing-owner window: that is
+            // a fail-closed recovery state, not a busy holder.
+            throw new OperationError("SOURCE_MUTATION_LOCK_RECOVERY_REQUIRED", `workspace mutation lock at ${target} requires operator recovery: ${lastBlocker} for the whole acquisition window. Quiesce all Kibi and source-mutating writers, then manually verify the owner metadata and remove the lock only after confirming no operation is active`, false);
+        }
+        throw new OperationError("SOURCE_MUTATION_LOCK_TIMEOUT", `workspace mutation lock is ${lastBlocker}; acquisition timed out after ${timeoutMs}ms while the live owner remained in place; retry after the owner releases the lock to avoid a lost update`, true);
+    }
+    const payload = `${JSON.stringify({
+        pid: process.pid,
+        token,
+        acquiredAt: now(),
+    })}\n`;
+    try {
+        const ownerResult = retryTransientFilesystemOperation(() => fileSystem.writeFileSync(ownerPath, payload, {
+            encoding: "utf8",
+            flag: "wx",
+        }), () => {
+            try {
+                fileSystem.readFileSync(ownerPath);
+                return false;
+            }
+            catch (probeError) {
+                return errorCode(probeError) === "ENOENT";
+            }
+        });
+        if (!ownerResult.ok)
+            throw ownerResult.error;
+    }
+    catch (error) {
+        const cleanupFailures = [];
+        try {
+            removeLockOwner(fileSystem, target, ownerPath, true);
+        }
+        catch (cleanupError) {
+            cleanupFailures.push(`owner cleanup: ${errorDetail(cleanupError)}`);
+        }
+        try {
+            removeLockDirectory(fileSystem, target);
+        }
+        catch (cleanupError) {
+            cleanupFailures.push(`directory cleanup: ${errorDetail(cleanupError)}`);
+        }
+        const cleanupContext = cleanupFailures.length === 0
+            ? "lock directory cleanup completed"
+            : `lock remains fail-closed at ${target}; ${cleanupFailures.join("; ")}`;
+        throw new WorkspaceMutationLockError(`failed to initialize workspace mutation lock owner at ${ownerPath}: ${errorDetail(error)}; ${cleanupContext}`);
+    }
+    let releaseState = "owned";
+    return {
+        release: () => {
+            if (releaseState === "released")
+                return;
+            if (releaseState === "owned") {
+                const readResult = retryTransientFilesystemOperation(() => fileSystem.readFileSync(ownerPath));
+                if (!readResult.ok) {
+                    throw new WorkspaceMutationLockError(`failed to validate workspace mutation lock owner at ${ownerPath} after ${readResult.attempts} attempt(s): ${errorDetail(readResult.error)}; lock remains fail-closed. ${manualCleanupGuidance(target, ownerPath)}`);
+                }
+                const record = readLockRecord(readResult.value);
+                if (record === null) {
+                    throw new WorkspaceMutationLockError(`refused to release workspace mutation lock with corrupt owner metadata at ${ownerPath}; lock remains fail-closed. ${manualCleanupGuidance(target, ownerPath)}`);
+                }
+                if (record.token !== token) {
+                    releaseState = "released";
+                    return;
+                }
+                removeLockOwner(fileSystem, target, ownerPath, false);
+                releaseState = "owner-removed";
+            }
+            removeLockDirectory(fileSystem, target);
+            releaseState = "released";
+        },
+    };
+}
+/**
+ * Run `operation` while holding the workspace mutation lock.
+ *
+ * Atomic directory creation is the sole lock authority. Owner metadata is
+ * release authorization and diagnostics. Every existing target, including a
+ * legacy file or a directory with missing/corrupt metadata, blocks or fails
+ * closed without mutating the lock path. Release failures propagate so
+ * successful work is never reported unlocked.
+ */
+// implements REQ-generated-coordinate-persistence
+export async function withWorkspaceMutationLock(workspaceRoot, operation, options = {}) {
+    const handle = await acquireWorkspaceMutationLock(workspaceRoot, options);
+    let operationFailure;
+    try {
+        return await operation();
+    }
+    catch (error) {
+        operationFailure = { error };
+        throw error;
+    }
+    finally {
+        releaseWorkspaceMutationLock(handle, operationFailure);
+    }
+}

package/dist/operations/planning/apply-plan.d.ts

@@ -1,110 +1,13 @@
-import { type MigrationPlan } from "../../public/operations/migration-plan.js";
 import type { OperationContext } from "../../public/operations/runtime-types.js";
-import { type BootstrapAction, type BootstrapPlanV1 } from "../bootstrap/types.js";
-import { type CompilePlanV1, type SourceWritePlan } from "./compile-intent.js";
+import { type BootstrapAction } from "../bootstrap/types.js";
+import type { ApplyPlanArgs, ApplyPlanResult } from "./apply-plan-types.js";
+export type { ApplyPlanArgs, ApplyPlanResult, EntityDeletionPlan, } from "./apply-plan-types.js";
 export declare const PLAN_APPLY_RESULT_VERSION: "kibi.plan-apply-result.v1";
-export type ApplyPlanArgs = Readonly<{
-    plan: BootstrapPlanV1;
-    approvedPlanHash: string;
-}> | Readonly<{
-    plan: CompilePlanV1;
-    approvedPlanHash: string;
-}> | Readonly<{
-    plan: MigrationPlan;
-    approvedPlanHash: string;
-    approvedActionIds: readonly string[];
-}> | Readonly<{
-    plan: EntityDeletionPlan;
-    approvedPlanHash: string;
-}> | Readonly<{
-    recoveryJournalId: string;
-}>;
-export type EntityDeletionPlan = Readonly<{
-    version: "kibi.entity-deletion-plan.v1";
-    planHash: string;
-    entityIds: readonly string[];
-    sourceHashes: Readonly<Record<string, string | null>>;
-    sourceWrites?: readonly SourceWritePlan[];
-    supersessionRequired: boolean;
-}>;
-type BootstrapActionResult = Readonly<{
-    actionId: string;
-    outcome: "applied" | "failed" | "skipped";
-    detail: string;
-}>;
-export type ApplyPlanResult = Readonly<{
-    version: typeof PLAN_APPLY_RESULT_VERSION;
-    outcome: "applied" | "replayed" | "partially_applied";
-    planHash: string;
-    actionResults: readonly BootstrapActionResult[];
-    changedEntities: number;
-    changedRelationships: number;
-    finalSnapshots: {
-        branch: string;
-        kbSnapshotId: string;
-        workspaceSnapshot: string;
-    };
-    recoveryJournalId: string | null;
-    changedPaths?: readonly string[];
-    validationSummary?: Readonly<Record<string, unknown>>;
-    status?: "committed_with_repairs";
-    effectFailures?: readonly Readonly<Record<string, unknown>>[];
-    nextActions?: readonly Readonly<Record<string, unknown>>[];
-}> | Readonly<{
-    version: typeof PLAN_APPLY_RESULT_VERSION;
-    outcome: "applied" | "replayed";
-    planHash: string;
-    changedEntities: number;
-    changedRelationships: number;
-    changedPaths: readonly string[];
-    finalSnapshots: {
-        branch: string;
-        kbSnapshotId: string;
-        workspaceSnapshot: string;
-    };
-    validationSummary: {
-        stepsValidated: number;
-        stepsApplied: number;
-        sourceHashesChecked: number;
-        notes: readonly string[];
-    };
-    recoveryJournalId: string | null;
-    status?: "committed_with_repairs";
-    effectFailures?: readonly Readonly<Record<string, unknown>>[];
-    nextActions?: readonly Readonly<Record<string, unknown>>[];
-}> | Readonly<{
-    version: "kibi.entity-deletion-apply-result.v1";
-    outcome: "applied";
-    planHash: string;
-    deleted: number;
-    sourcePaths: readonly string[];
-    recoveryJournalId?: string | null;
-    status?: "committed_with_repairs";
-    nextActions?: readonly Readonly<Record<string, unknown>>[];
-}> | Readonly<{
-    version: "kibi.migration-apply-result.v1";
-    outcome: "applied" | "partially_applied" | "replayed" | "reconciliation_required";
-    planHash: string;
-    actionResults: readonly Readonly<{
-        actionId: string;
-        outcome: "applied" | "failed" | "skipped";
-        detail: string;
-    }>[];
-    finalSnapshots: {
-        branch: string;
-        kbSnapshotId: string;
-        workspaceSnapshot: string;
-    };
-    notes: readonly string[];
-    remainingPlan?: MigrationPlan;
-    closeout?: {
-        taskOutcome: "complete" | "interim" | "blocked";
-        kbState: "clean_fresh" | "stale" | "dirty" | "legacy_compat" | "not_evaluated";
-        verificationState: "fresh" | "dirty" | "unavailable" | "not_evaluated";
-        proofState: "proven" | "mixed" | "unresolved" | "not_evaluated";
-        limitationDisposition: "none" | "accepted" | "unaccepted" | "not_applicable";
-    };
-}>;
+export declare function assertSourceWriteStaysInWorkspace(root: string, absolute: string, writePath: string): void;
+export declare function assertBootstrapRecoveryDependencies(remaining: readonly {
+    id: string;
+    dependsOn?: readonly string[];
+}[], applied: ReadonlySet<string>): void;
 export declare function orderBootstrapActions(actions: readonly BootstrapAction[], completed?: Set<string>): BootstrapAction[];
 export declare function executeApplyPlan(args: ApplyPlanArgs, context: OperationContext): Promise<{
     content: Array<{
@@ -113,5 +16,4 @@ export declare function executeApplyPlan(args: ApplyPlanArgs, context: Operation
     }>;
     structuredContent: ApplyPlanResult;
 }>;
-export {};
 //# sourceMappingURL=apply-plan.d.ts.map

package/dist/operations/planning/apply-plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apply-plan.d.ts","sourceRoot":"","sources":["../../../src/operations/planning/apply-plan.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"apply-plan.d.ts","sourceRoot":"","sources":["../../../src/operations/planning/apply-plan.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAGjF,OAAO,EACL,KAAK,eAAe,EAIrB,MAAM,uBAAuB,CAAC;AAqB/B,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EAGhB,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EACV,aAAa,EACb,eAAe,EACf,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAG/B,eAAO,MAAM,yBAAyB,EAAG,2BAAoC,CAAC;AA6G9E,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,IAAI,CAMN;AAED,wBAAgB,mCAAmC,CACjD,SAAS,EAAE,SAAS;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,EAAE,EACnE,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAC3B,IAAI,CAaN;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,SAAS,eAAe,EAAE,EACnC,SAAS,cAAoB,GAC5B,eAAe,EAAE,CA2CnB;AAggDD,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC;IACT,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,iBAAiB,EAAE,eAAe,CAAC;CACpC,CAAC,CA2BD"}