kibi-cli 2.4.0 → 2.5.0

package/dist/operations/migration/schema6.js

@@ -0,0 +1,379 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+import path from "node:path";
+import { extractFromMarkdown, } from "../../extractors/markdown.js";
+import { migrationAction, } from "../../public/operations/migration-plan.js";
+import { CLOSE_SUPERSEDED_REQUIREMENTS_ACTION_ID, CLOSE_SUPERSEDED_REQUIREMENTS_CODE, MIGRATION_SYNC_ACTION_ID, MIGRATION_SYNC_CODE, SOURCE_PATH_REWRITE_ACTION_ID, SOURCE_PATH_REWRITE_CODE, closeSupersededRequirementsActionInput, exceptionUnapprovedActionInput, migrationSyncActionInput, sourcePathReviewActionInput, sourcePathRewriteActionInput, supersessionCycleReviewActionInput, } from "../../public/operations/schema6-check-actions.js";
+import { readAllShards } from "../../relationships/shards.js";
+import { applyInventoryRederivation, planInventoryRederivation, } from "./inventory-rederive.js";
+import { listLaneMarkdownFiles } from "./kb-sources.js";
+import { applyOriginBackfill, planOriginBackfill } from "./origin-backfill.js";
+import { POLARITY_VALUE_BACKFILL_CODE, applyPolarityValueBackfill, planPolarityValueBackfill, } from "./polarity-values.js";
+import { applySourcePathRepairs, findSourceRepairs, plannedSourcePathRepairs, } from "./source-paths.js";
+import { applySupersededClosures, planSupersededClosures, } from "./superseded-closure.js";
+/** The KB schema generation that introduced entity `origin`. */
+// implements REQ-kibi-schema6-migration, REQ-cli-schema-migration
+export const ORIGIN_SCHEMA_VERSION = 6;
+/** Automatic: re-derive a drifted inventory with the current advisor. */
+// implements REQ-kibi-schema6-migration, REQ-cli-schema-migration
+export const SEMANTIC_INVENTORY_REDERIVE_CODE = "semantic_inventory_rederive";
+/** Review: a drifted inventory Kibi cannot re-derive safely. */
+// implements REQ-kibi-schema6-migration, REQ-cli-schema-migration
+export const SEMANTIC_INVENTORY_REVIEW_CODE = "semantic_inventory_review";
+/** Automatic: stamp `origin: {kind: migration}` on authored entities. */
+// implements REQ-kibi-schema6-migration, REQ-cli-schema-migration
+export const ENTITY_ORIGIN_BACKFILL_CODE = "entity_origin_backfill";
+// implements REQ-kibi-schema6-migration, REQ-cli-schema-migration
+export const ENTITY_ORIGIN_BACKFILL_ACTION_ID = "entity-origin-backfill";
+export { CLOSE_SUPERSEDED_REQUIREMENTS_CODE, MIGRATION_SYNC_ACTION_ID, MIGRATION_SYNC_CODE, SOURCE_PATH_REWRITE_CODE, };
+const CURRENT_REQUIREMENT_STATUSES = new Set([
+    "open",
+    "in_progress",
+    "closed",
+    "active",
+    "approved",
+]);
+function rederiveAction(plan) {
+    const changed = plan.changes.filter((change) => change.change !== "kept");
+    return migrationAction({
+        id: `semantic-inventory-rederive-${plan.requirementId}`,
+        code: SEMANTIC_INVENTORY_REDERIVE_CODE,
+        category: "semantic",
+        safety: "automatic",
+        autoApplicable: true,
+        invocation: { kind: "cli", command_argv: ["kibi", "migrate", "--yes"] },
+        affectedEntityIds: [plan.requirementId],
+        affectedFiles: [plan.path],
+        postconditions: [
+            {
+                check: "proposition-complete-ingestion",
+                entityId: plan.requirementId,
+                errors: 0,
+            },
+        ],
+        evidence: {
+            reason: "The stored semantic inventory no longer matches the current semantic advisor, so kibi sync rejects this requirement.",
+            ingestionErrors: plan.errors,
+            summary: plan.summary,
+            changes: changed,
+            contractHash: plan.contractHash,
+            rule: "Claims whose claim_key and claim_text still match keep their status and grounding; new or changed claims are unresolved, never modeled.",
+        },
+    });
+}
+function reviewAction(plan) {
+    return migrationAction({
+        id: `semantic-inventory-review-${plan.requirementId}`,
+        code: SEMANTIC_INVENTORY_REVIEW_CODE,
+        category: "semantic",
+        safety: "review",
+        invocation: {
+            kind: "review",
+            instruction: `${plan.requirementId} (${plan.path}) no longer matches the current semantic advisor and cannot be re-derived automatically: ${plan.reasons.join("; ")}. Fix it by hand: run \`kibi model --input -\` with {"mode":"analyze","payload":{"type":"req","id":"${plan.requirementId}","properties":<the requirement's current properties>}} to get the current inventory; re-ground or remove each listed grounding link (kb_delete with the relationship) so modeled claims and requires_* links match one to one; kb_upsert the requirement with the returned semantic_inventory, logic_claims and semantic_source_hash (keep modeled only for claims that still have a grounding fact with the same claim_key); then run kibi sync.`,
+        },
+        affectedEntityIds: [plan.requirementId],
+        affectedFiles: [plan.path],
+        dispositionRequired: true,
+        allowedDispositions: ["fixed", "deferred"],
+        evidence: {
+            ingestionErrors: plan.errors,
+            reasons: plan.reasons,
+            summary: plan.summary,
+            changes: plan.changes.filter((change) => change.change !== "kept"),
+        },
+    });
+}
+/**
+ * Exceptions without approved_by, read from authored sources so the list is
+ * available before the KB compiles.
+ */
+// implements REQ-kibi-schema6-migration, REQ-cli-schema-migration
+export function unapprovedExceptionsFromSources(workspaceRoot) {
+    const requirements = new Map();
+    const relationships = [];
+    for (const file of listLaneMarkdownFiles(workspaceRoot, ["requirements"])) {
+        try {
+            const result = extractFromMarkdown(file.absolutePath);
+            requirements.set(result.entity.id, {
+                id: result.entity.id,
+                status: result.entity.status,
+                approvedBy: (result.entity.approved_by ?? "").trim(),
+                source: file.relativePath,
+            });
+            relationships.push(...result.relationships);
+        }
+        catch {
+            // Unreadable requirements fail sync with their own diagnostic.
+        }
+    }
+    try {
+        relationships.push(...readAllShards(path.join(workspaceRoot, ".kb")));
+    }
+    catch {
+        // Malformed shards fail sync with their own diagnostic.
+    }
+    const superseded = new Set(relationships
+        .filter((relationship) => relationship.type === "supersedes")
+        .map((relationship) => relationship.to));
+    const exempts = new Map();
+    for (const relationship of relationships) {
+        if (relationship.type !== "exempts")
+            continue;
+        const bases = exempts.get(relationship.from) ?? new Set();
+        bases.add(relationship.to);
+        exempts.set(relationship.from, bases);
+    }
+    return [...exempts.entries()]
+        .flatMap(([exceptionId, bases]) => {
+        const requirement = requirements.get(exceptionId);
+        if (requirement === undefined ||
+            requirement.approvedBy !== "" ||
+            !CURRENT_REQUIREMENT_STATUSES.has(requirement.status) ||
+            superseded.has(exceptionId)) {
+            return [];
+        }
+        return [
+            {
+                exceptionId,
+                exempts: [...bases].sort(),
+                source: requirement.source,
+            },
+        ];
+    })
+        .sort((left, right) => left.exceptionId.localeCompare(right.exceptionId));
+}
+/**
+ * Source-derived migration actions: inventory re-derivation whenever an
+ * advisor change makes stored inventories drift and the lifecycle repairs
+ * (superseded requirements to close, dangling source paths) at any schema
+ * version, and, for a KB older than schema 6, the origin backfill plus the
+ * exceptions that stop exempting anything. Read-only.
+ */
+// implements REQ-cli-schema-migration, REQ-agent-guided-migration-orchestration, REQ-kibi-proposition-complete-ingestion
+export function buildSchema6MigrationFragment(input) {
+    const actions = [];
+    const sourceRewriteActionIds = [];
+    const diagnostics = [];
+    const polarityTargets = planPolarityValueBackfill(input.workspaceRoot);
+    if (polarityTargets.length > 0) {
+        const id = "polarity-value-backfill";
+        sourceRewriteActionIds.push(id);
+        actions.push(migrationAction({
+            id,
+            code: POLARITY_VALUE_BACKFILL_CODE,
+            category: "schema",
+            safety: "automatic",
+            autoApplicable: true,
+            invocation: { kind: "cli", command_argv: ["kibi", "migrate", "--yes"] },
+            affectedEntityIds: polarityTargets.map((row) => row.id),
+            affectedFiles: polarityTargets.map((row) => row.path),
+            postconditions: [{ rule: "strict-fact-shape", findings: 0 }],
+            evidence: {
+                count: polarityTargets.length,
+                encoding: { operator: "eq", value_type: "bool", value_bool: true },
+                preserves: "IDs, polarity and authored body",
+            },
+        }));
+    }
+    const drift = planInventoryRederivation(input.workspaceRoot);
+    for (const plan of drift) {
+        const action = plan.safe ? rederiveAction(plan) : reviewAction(plan);
+        actions.push(action);
+        if (plan.safe)
+            sourceRewriteActionIds.push(action.id);
+    }
+    if (drift.some((plan) => !plan.safe)) {
+        diagnostics.push(`${drift.filter((plan) => !plan.safe).length} requirement inventory(ies) need a manual fix before kibi sync succeeds; see the semantic_inventory_review actions.`);
+    }
+    // A missing or invalid version upgrades through every step, schema 6's
+    // backfill included, so it is planned here too.
+    const preOrigin = input.currentSchemaVersion === null ||
+        input.currentSchemaVersion < ORIGIN_SCHEMA_VERSION;
+    if (preOrigin) {
+        const backfill = planOriginBackfill(input.workspaceRoot);
+        if (backfill.targets.length > 0) {
+            const byType = {};
+            for (const target of backfill.targets) {
+                byType[target.type || "unknown"] =
+                    (byType[target.type || "unknown"] ?? 0) + 1;
+            }
+            actions.push(migrationAction({
+                id: ENTITY_ORIGIN_BACKFILL_ACTION_ID,
+                code: ENTITY_ORIGIN_BACKFILL_CODE,
+                category: "schema",
+                safety: "automatic",
+                autoApplicable: true,
+                invocation: {
+                    kind: "cli",
+                    command_argv: ["kibi", "migrate", "--yes"],
+                },
+                affectedFiles: [".kb/"],
+                postconditions: [{ entitiesWithoutOrigin: 0 }],
+                evidence: {
+                    reason: "Schema 6 records who authored each entity. Entities written before it get origin {kind: migration, ref: 'kibi migrate v5->v6', recorded_at}; the frontmatter is otherwise unchanged.",
+                    count: backfill.targets.length,
+                    byType,
+                    entityIds: backfill.targets.map((target) => target.id),
+                    skipped: backfill.skipped,
+                    ...(input.currentSchemaVersion === null ||
+                        input.currentSchemaVersion < 5
+                        ? {
+                            note: "Knowledge the schema upgrade moves into .kb/ is stamped when it moves.",
+                        }
+                        : {}),
+                },
+            }));
+            sourceRewriteActionIds.push(ENTITY_ORIGIN_BACKFILL_ACTION_ID);
+        }
+        for (const exception of unapprovedExceptionsFromSources(input.workspaceRoot)) {
+            actions.push(migrationAction(exceptionUnapprovedActionInput(exception)));
+        }
+    }
+    // Blocking lifecycle findings with a mechanical fix are planned at any
+    // schema version: they block kibi check until they are resolved.
+    const lifecycle = buildLifecycleRepairActions(input.workspaceRoot);
+    actions.push(...lifecycle.actions);
+    sourceRewriteActionIds.push(...lifecycle.sourceRewriteActionIds);
+    return { actions, sourceRewriteActionIds, diagnostics };
+}
+/**
+ * Actions for the superseded-requirement-open and source-path-dangling
+ * findings in authored sources: close superseded requirements, and rewrite
+ * moved or remove redundant and dead source values, automatically; one
+ * review per supersession cycle and per source value Kibi cannot edit
+ * safely. Read-only.
+ */
+// implements REQ-cli-schema-migration, REQ-core-validation-rules, REQ-kibi-schema6-migration
+export function buildLifecycleRepairActions(workspaceRoot) {
+    const actions = [];
+    const sourceRewriteActionIds = [];
+    const supersession = planSupersededClosures(workspaceRoot);
+    if (supersession.closures.length > 0) {
+        actions.push(migrationAction(closeSupersededRequirementsActionInput(supersession.closures)));
+        sourceRewriteActionIds.push(CLOSE_SUPERSEDED_REQUIREMENTS_ACTION_ID);
+    }
+    for (const cycle of supersession.cycles) {
+        actions.push(migrationAction(supersessionCycleReviewActionInput(cycle)));
+    }
+    const repairs = findSourceRepairs(workspaceRoot);
+    for (const repair of repairs) {
+        if (repair.refused === undefined)
+            continue;
+        actions.push(migrationAction(sourcePathReviewActionInput({
+            entityId: repair.entityId,
+            value: repair.value,
+            file: repair.file,
+            reason: repair.refused,
+            ...(repair.fix.kind === "rewrite" ? { rewrite: repair.fix.to } : {}),
+        })));
+    }
+    const planned = plannedSourcePathRepairs(repairs);
+    if (planned.rewrites.length > 0 || planned.removals.length > 0) {
+        actions.push(migrationAction(sourcePathRewriteActionInput(planned)));
+        sourceRewriteActionIds.push(SOURCE_PATH_REWRITE_ACTION_ID);
+    }
+    return { actions, sourceRewriteActionIds };
+}
+/** The sync that recompiles sources rewritten by earlier actions. */
+// implements REQ-kibi-schema6-migration, REQ-cli-schema-migration
+export function migrationSyncAction(dependsOn) {
+    return migrationAction(migrationSyncActionInput(dependsOn));
+}
+function plannedRecords(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((raw) => raw !== null && typeof raw === "object" && !Array.isArray(raw));
+}
+/** The rewrites and removals an approved source_path_rewrite action lists. */
+// implements REQ-kibi-schema6-migration
+function plannedRepairs(action) {
+    const rewrites = [];
+    for (const { entityId, file, from, to } of plannedRecords(action.evidence.rewrites)) {
+        if (typeof entityId === "string" &&
+            typeof file === "string" &&
+            typeof from === "string" &&
+            typeof to === "string") {
+            rewrites.push({ entityId, file, from, to });
+        }
+    }
+    const removals = [];
+    for (const { entityId, file, from, reason } of plannedRecords(action.evidence.removals)) {
+        if (typeof entityId === "string" &&
+            typeof file === "string" &&
+            typeof from === "string" &&
+            (reason === "self" || reason === "dangling")) {
+            removals.push({ entityId, file, from, reason });
+        }
+    }
+    return { rewrites, removals };
+}
+/** Execute one automatic action produced by this module. */
+// implements REQ-cli-schema-migration, REQ-agent-guided-migration-orchestration
+export async function applySchema6MigrationAction(action, context) {
+    switch (action.code) {
+        case POLARITY_VALUE_BACKFILL_CODE: {
+            applyPolarityValueBackfill(context.workspaceRoot);
+            return;
+        }
+        case SEMANTIC_INVENTORY_REDERIVE_CODE: {
+            const requirementId = action.affectedEntityIds[0];
+            if (requirementId === undefined)
+                throw new Error("Inventory re-derivation names no requirement.");
+            const contractHash = typeof action.evidence.contractHash === "string"
+                ? action.evidence.contractHash
+                : undefined;
+            applyInventoryRederivation(context.workspaceRoot, requirementId, contractHash);
+            return;
+        }
+        case ENTITY_ORIGIN_BACKFILL_CODE:
+            applyOriginBackfill(context.workspaceRoot, context.clock().toISOString());
+            return;
+        case CLOSE_SUPERSEDED_REQUIREMENTS_CODE: {
+            const result = applySupersededClosures(context.workspaceRoot, new Set(action.affectedEntityIds));
+            if (result.skipped.length > 0)
+                throw new Error(`Could not close ${result.skipped.map((skip) => `${skip.path} (${skip.reason})`).join(", ")}; set status: closed by hand.`);
+            return;
+        }
+        case SOURCE_PATH_REWRITE_CODE: {
+            const result = applySourcePathRepairs(context.workspaceRoot, plannedRepairs(action));
+            if (result.skipped.length > 0)
+                throw new Error(`Could not repair the source of ${result.skipped.map((skip) => `${skip.file} (${skip.reason})`).join(", ")}; rerun kibi migrate and approve the new plan.`);
+            return;
+        }
+        case MIGRATION_SYNC_CODE: {
+            const { syncCommand } = await import("../../commands/sync.js");
+            const result = await syncCommand({
+                workspaceRoot: context.workspaceRoot,
+            });
+            if (!result.success)
+                throw new Error("kibi sync did not complete after the migration rewrote sources; run kibi sync to see why.");
+            return;
+        }
+        default:
+            throw new Error(`Migration action '${action.code}' has no schema 6 executor.`);
+    }
+}
+// implements REQ-kibi-schema6-migration, REQ-cli-schema-migration
+export const SCHEMA6_AUTOMATIC_CODES = new Set([
+    POLARITY_VALUE_BACKFILL_CODE,
+    SEMANTIC_INVENTORY_REDERIVE_CODE,
+    ENTITY_ORIGIN_BACKFILL_CODE,
+    CLOSE_SUPERSEDED_REQUIREMENTS_CODE,
+    SOURCE_PATH_REWRITE_CODE,
+    MIGRATION_SYNC_CODE,
+]);

package/dist/operations/migration/source-paths.d.ts

@@ -0,0 +1,131 @@
+/**
+ * The authored `source` frontmatter field is dead data. The compiled
+ * `source` is always the entity's own file: the Markdown extractor ignores
+ * the field, and Kibi never writes it. Values written before the canonical
+ * `.kb/` layout still name knowledge files by their old path: under the
+ * retired `documentation/` tree, or relative to the knowledge root
+ * (`requirements/REQ-x.md`). This module finds the values that resolve to
+ * nothing (the `source-path-dangling` check) and every value `kibi migrate`
+ * repairs: a moved file is rewritten to its `.kb/` path, and a value that
+ * names the entity's own file or nothing Kibi can map is removed. A value
+ * naming another existing workspace path, an entity id or an http(s) URL is
+ * provenance and stays.
+ */
+/** One authored `source` value and the entity file that carries it. */
+export type AuthoredSourceRef = Readonly<{
+    entityId: string;
+    /** Workspace-relative, `/`-separated path of the entity's own file. */
+    file: string;
+    value: unknown;
+}>;
+export type AuthoredSourceScan = Readonly<{
+    refs: readonly AuthoredSourceRef[];
+    /** Ids of every authored entity, symbols included. */
+    entityIds: ReadonlySet<string>;
+}>;
+export type SourceResolution = Readonly<{
+    kind: "missing" | "path" | "entity" | "url";
+}>
+/** Names the entity's own file; `resolves` is false when that spelling names no existing path. */
+ | Readonly<{
+    kind: "self";
+    resolves: boolean;
+}> | Readonly<{
+    kind: "dangling";
+    rewrite?: string;
+}>;
+/** Why `kibi migrate` removes an authored `source` value. */
+export type SourceRemovalReason = "self" | "dangling";
+/** The edit `kibi migrate` makes to one authored `source` value. */
+export type SourceFix = Readonly<{
+    kind: "rewrite";
+    to: string;
+}> | Readonly<{
+    kind: "remove";
+    reason: SourceRemovalReason;
+}>;
+/** One authored `source` value that is redundant or resolves to nothing. */
+export type SourceRepair = AuthoredSourceRef & Readonly<{
+    /** Names no existing path, entity id or URL: `source-path-dangling` blocks it. */
+    dangling: boolean;
+    fix: SourceFix;
+    /** Why the value cannot be edited safely; a person must edit it. */
+    refused?: string;
+}>;
+/** An authored value as plain text, the form plans record and compare. */
+export declare function shownSourceValue(value: unknown): string;
+/**
+ * Read every authored entity's `source` field and id in one pass over the
+ * canonical lanes, plus the symbol ids of the symbols manifest. Only the id
+ * and source lines are parsed. Read-only.
+ */
+export declare function scanAuthoredSources(workspaceRoot: string): AuthoredSourceScan;
+/**
+ * Resolve one authored `source` value: an existing workspace path (any
+ * `#anchor` suffix ignored), an existing entity id or an http(s) URL. With
+ * the entity's own `file`, a value naming that file (canonical or
+ * pre-canonical spelling, `./` and `#anchor` ignored, compared
+ * case-insensitively) resolves to `self`. A dangling
+ * `documentation/<lane>/...` or `<lane>/...` value carries the
+ * `.kb/<lane>/...` rewrite when that file exists.
+ */
+export declare function resolveAuthoredSource(value: unknown, context: Readonly<{
+    workspaceRoot: string;
+    entityIds: ReadonlySet<string>;
+    exists: (relativePath: string) => boolean;
+    /** Workspace-relative path of the entity's own file. */
+    file?: string;
+}>): SourceResolution;
+/** A memoized existence test confined to the workspace. */
+export declare function workspacePathExists(workspaceRoot: string): (relativePath: string) => boolean;
+/**
+ * Every authored `source` value that resolves to nothing, sorted by entity
+ * id, with the fix `kibi migrate` makes and, when the edit is not safe, why.
+ * Each path is checked once per call. Read-only.
+ */
+export declare function findDanglingSources(workspaceRoot: string): SourceRepair[];
+/**
+ * Every authored `source` value `kibi migrate` rewrites or removes: the
+ * dangling ones plus existing values that name the entity's own file.
+ * Read-only.
+ */
+export declare function findSourceRepairs(workspaceRoot: string): SourceRepair[];
+export type SourcePathRewrite = Readonly<{
+    entityId: string;
+    file: string;
+    from: string;
+    to: string;
+}>;
+export type SourcePathRemoval = Readonly<{
+    entityId: string;
+    file: string;
+    from: string;
+    reason: SourceRemovalReason;
+}>;
+export type PlannedSourcePathRepairs = Readonly<{
+    rewrites: readonly SourcePathRewrite[];
+    removals: readonly SourcePathRemoval[];
+}>;
+export type SourcePathRepairResult = Readonly<{
+    rewritten: readonly SourcePathRewrite[];
+    removed: readonly SourcePathRemoval[];
+    skipped: readonly Readonly<{
+        file: string;
+        reason: string;
+    }>[];
+}>;
+/**
+ * The rewrite and removal records a migration plan lists for these repairs.
+ * Repairs Kibi cannot edit safely are left out; they need a person.
+ */
+export declare function plannedSourcePathRepairs(repairs: readonly SourceRepair[]): PlannedSourcePathRepairs;
+/**
+ * Repair each redundant or dead `source` value, editing only its line: a
+ * moved knowledge file is rewritten to its `.kb/` path, and a value naming
+ * the entity's own file or nothing Kibi can map is removed. With `planned`,
+ * only those repairs are applied, and only while the value still reads as
+ * planned. A value that cannot be edited safely is skipped with a reason.
+ * Idempotent: a repaired value is not found again.
+ */
+export declare function applySourcePathRepairs(workspaceRoot: string, planned?: PlannedSourcePathRepairs): SourcePathRepairResult;
+//# sourceMappingURL=source-paths.d.ts.map

package/dist/operations/migration/source-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-paths.d.ts","sourceRoot":"","sources":["../../../src/operations/migration/source-paths.ts"],"names":[],"mappings":"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"}