kibi-cli 0.10.0 → 0.11.0

package/dist/commands/usage-metrics.js

@@ -0,0 +1,323 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import Table from "cli-table3";
+// implements REQ-003
+export async function usageMetricsCommand(options) {
+    const limit = Number.parseInt(options.limit || "10", 10);
+    if (!Number.isFinite(limit) || limit < 1) {
+        console.error("Error: --limit must be a positive integer");
+        return { exitCode: 1 };
+    }
+    const usageLogPath = path.join(process.cwd(), ".kb", "usage.log");
+    if (!existsSync(usageLogPath)) {
+        console.error(`Error: usage log not found at ${usageLogPath}`);
+        return { exitCode: 1 };
+    }
+    const rows = parseUsageLog(readFileSync(usageLogPath, "utf8"));
+    const report = buildUsageMetricsReport(rows, limit);
+    if (options.format === "json") {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    console.log(renderUsageMetricsReport(report));
+    return;
+}
+function parseUsageLog(contents) {
+    const rows = [];
+    for (const [index, line] of contents.split(/\r?\n/).entries()) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to parse .kb/usage.log line ${index + 1}: ${message}`);
+        }
+        if (!parsed || typeof parsed !== "object") {
+            throw new Error(`Failed to parse .kb/usage.log line ${index + 1}: expected object`);
+        }
+        rows.push(parsed);
+    }
+    return rows;
+}
+function buildUsageMetricsReport(rows, limit) {
+    const timestamps = rows
+        .map((row) => row.timestamp)
+        .filter((value) => typeof value === "string")
+        .sort((left, right) => left.localeCompare(right));
+    const toolCounts = new Map();
+    const branchCounts = new Map();
+    const zeroResultToolCounts = new Map();
+    const zeroResultSourceFileCounts = new Map();
+    const upsertErrorCategories = new Map();
+    const violationTrend = [];
+    let successCount = 0;
+    let errorCount = 0;
+    let telemetryCompleteCount = 0;
+    let telemetryMissingCount = 0;
+    let zeroResultCount = 0;
+    for (const row of rows) {
+        increment(toolCounts, normalizeKey(row.tool, "unknown"));
+        increment(branchCounts, normalizeKey(row.active_branch || row.branch, "unknown"));
+        const outcome = getOutcome(row);
+        if (outcome === "success") {
+            successCount += 1;
+        }
+        if (outcome === "error") {
+            errorCount += 1;
+        }
+        if (hasCompleteTelemetry(row)) {
+            telemetryCompleteCount += 1;
+        }
+        else {
+            telemetryMissingCount += 1;
+        }
+        if (isZeroResult(row)) {
+            zeroResultCount += 1;
+            increment(zeroResultToolCounts, normalizeKey(row.tool, "unknown"));
+            const sourceFile = getSourceFile(row);
+            if (sourceFile) {
+                increment(zeroResultSourceFileCounts, sourceFile);
+            }
+        }
+        if (row.tool === "kb_check" &&
+            typeof row.violation_count === "number" &&
+            typeof row.timestamp === "string") {
+            violationTrend.push({
+                timestamp: row.timestamp,
+                violationCount: row.violation_count,
+            });
+        }
+        if (row.tool === "kb_upsert" && outcome === "error") {
+            increment(upsertErrorCategories, categorizeUpsertError(row.error_message ?? row.error));
+        }
+    }
+    violationTrend.sort((left, right) => left.timestamp.localeCompare(right.timestamp));
+    return {
+        rowCount: rows.length,
+        dateRange: {
+            first: timestamps[0] ?? null,
+            last: timestamps.at(-1) ?? null,
+        },
+        toolCounts: mapToSortedObject(toolCounts),
+        branchCounts: mapToSortedObject(branchCounts),
+        outcomeCounts: {
+            success: successCount,
+            error: errorCount,
+        },
+        telemetry: {
+            completeCount: telemetryCompleteCount,
+            missingCount: telemetryMissingCount,
+            completenessRate: rows.length === 0 ? 0 : telemetryCompleteCount / rows.length,
+        },
+        zeroResults: {
+            count: zeroResultCount,
+            rate: rows.length === 0 ? 0 : zeroResultCount / rows.length,
+            byTool: mapToSortedObject(zeroResultToolCounts),
+            topSourceFiles: sortCountEntries(zeroResultSourceFileCounts)
+                .slice(0, limit)
+                .map(([sourceFile, count]) => ({ sourceFile, count })),
+        },
+        kbCheck: {
+            violationTrend,
+        },
+        upsertErrors: {
+            categories: mapToSortedObject(upsertErrorCategories),
+        },
+    };
+}
+function hasCompleteTelemetry(row) {
+    if (row.telemetry_status === "provided") {
+        return true;
+    }
+    if (row.telemetry_status === "missing") {
+        return false;
+    }
+    return row.telemetry !== null && row.telemetry !== undefined;
+}
+function getOutcome(row) {
+    if (row.status === "success" || row.status === "error") {
+        return row.status;
+    }
+    if (row.success === true) {
+        return "success";
+    }
+    if (row.success === false) {
+        return "error";
+    }
+    return null;
+}
+function isZeroResult(row) {
+    if (row.zero_results === true) {
+        return true;
+    }
+    if (row.zero_results === false) {
+        return false;
+    }
+    if (row.result_count === 0) {
+        return true;
+    }
+    return row.result_summary === "0 results";
+}
+function getSourceFile(row) {
+    if (typeof row.sourceFile === "string" && row.sourceFile.trim()) {
+        return row.sourceFile;
+    }
+    if (row.args &&
+        typeof row.args.sourceFile === "string" &&
+        row.args.sourceFile.trim()) {
+        return row.args.sourceFile;
+    }
+    if (row.business_args &&
+        typeof row.business_args.sourceFile === "string" &&
+        row.business_args.sourceFile.trim()) {
+        return row.business_args.sourceFile;
+    }
+    return null;
+}
+function categorizeUpsertError(errorMessage) {
+    if (!errorMessage) {
+        return "Unknown error";
+    }
+    if (errorMessage.startsWith("Entity validation failed:")) {
+        return "Entity validation failed";
+    }
+    if (errorMessage.startsWith("Relationship source must match the upserted entity")) {
+        return "Relationship source must match the upserted entity";
+    }
+    const semicolonIndex = errorMessage.indexOf(";");
+    if (semicolonIndex > 0) {
+        return errorMessage.slice(0, semicolonIndex).trim();
+    }
+    const colonIndex = errorMessage.indexOf(":");
+    if (colonIndex > 0) {
+        return errorMessage.slice(0, colonIndex).trim();
+    }
+    return errorMessage.trim() || "Unknown error";
+}
+function increment(counts, key) {
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+}
+function normalizeKey(value, fallback) {
+    return typeof value === "string" && value.trim() ? value : fallback;
+}
+function sortCountEntries(counts) {
+    return [...counts.entries()].sort(([leftKey, leftCount], [rightKey, rightCount]) => rightCount - leftCount || leftKey.localeCompare(rightKey));
+}
+function mapToSortedObject(counts) {
+    return Object.fromEntries(sortCountEntries(counts));
+}
+function renderUsageMetricsReport(report) {
+    const sections = [
+        renderSummaryTable(report),
+        renderCountsTable("Tool Counts", "Tool", report.toolCounts),
+        renderCountsTable("Branch Counts", "Branch", report.branchCounts),
+        renderCountsTable("Outcome Counts", "Outcome", report.outcomeCounts),
+        renderTelemetryTable(report),
+        renderZeroResultsTable(report),
+        renderViolationTrendTable(report),
+        renderCountsTable("Upsert Error Categories", "Category", report.upsertErrors.categories),
+    ].filter(Boolean);
+    return sections.join("\n\n");
+}
+function renderSummaryTable(report) {
+    const table = new Table({
+        head: ["Field", "Value"],
+        colWidths: [24, 56],
+        wordWrap: true,
+    });
+    table.push(["Row Count", String(report.rowCount)], ["First Timestamp", report.dateRange.first ?? "-"], ["Last Timestamp", report.dateRange.last ?? "-"]);
+    return table.toString();
+}
+function renderCountsTable(title, label, counts) {
+    const entries = Object.entries(counts);
+    const table = new Table({
+        head: [label, "Count"],
+        colWidths: [48, 12],
+        wordWrap: true,
+    });
+    if (entries.length === 0) {
+        table.push(["-", "0"]);
+    }
+    else {
+        for (const [key, count] of entries) {
+            table.push([key, String(count)]);
+        }
+    }
+    return `${title}\n${table.toString()}`;
+}
+function renderTelemetryTable(report) {
+    const table = new Table({
+        head: ["Metric", "Value"],
+        colWidths: [32, 28],
+        wordWrap: true,
+    });
+    table.push(["Complete", String(report.telemetry.completeCount)], ["Missing", String(report.telemetry.missingCount)], ["Completeness Rate", formatRate(report.telemetry.completenessRate)]);
+    return `Telemetry\n${table.toString()}`;
+}
+function renderZeroResultsTable(report) {
+    const summary = new Table({
+        head: ["Metric", "Value"],
+        colWidths: [32, 28],
+        wordWrap: true,
+    });
+    summary.push(["Count", String(report.zeroResults.count)], ["Rate", formatRate(report.zeroResults.rate)]);
+    const byTool = new Table({
+        head: ["Tool", "Count"],
+        colWidths: [48, 12],
+        wordWrap: true,
+    });
+    const byToolEntries = Object.entries(report.zeroResults.byTool);
+    if (byToolEntries.length === 0) {
+        byTool.push(["-", "0"]);
+    }
+    else {
+        for (const [tool, count] of byToolEntries) {
+            byTool.push([tool, String(count)]);
+        }
+    }
+    const sourceFiles = new Table({
+        head: ["Source File", "Zero Results"],
+        colWidths: [48, 14],
+        wordWrap: true,
+    });
+    if (report.zeroResults.topSourceFiles.length === 0) {
+        sourceFiles.push(["-", "0"]);
+    }
+    else {
+        for (const entry of report.zeroResults.topSourceFiles) {
+            sourceFiles.push([entry.sourceFile, String(entry.count)]);
+        }
+    }
+    return [
+        "Zero Results",
+        summary.toString(),
+        "Zero-Result Counts By Tool",
+        byTool.toString(),
+        "Zero-Result Source Files",
+        sourceFiles.toString(),
+    ].join("\n");
+}
+function renderViolationTrendTable(report) {
+    const table = new Table({
+        head: ["Timestamp", "Violations"],
+        colWidths: [32, 12],
+        wordWrap: true,
+    });
+    if (report.kbCheck.violationTrend.length === 0) {
+        table.push(["-", "0"]);
+    }
+    else {
+        for (const entry of report.kbCheck.violationTrend) {
+            table.push([entry.timestamp, String(entry.violationCount)]);
+        }
+    }
+    return `KB Check Violation Trend\n${table.toString()}`;
+}
+function formatRate(value) {
+    return `${(value * 100).toFixed(1)}%`;
+}

package/dist/extractors/manifest.d.ts

@@ -27,6 +27,36 @@ export declare class ManifestError extends Error {
     filePath: string;
     constructor(message: string, filePath: string);
 }
+export interface ManifestSymbolRecord {
+    id?: string;
+    title?: string;
+    source?: string;
+    sourceFile?: string;
+    status?: string;
+    tags?: string[];
+    owner?: string;
+    priority?: string;
+    severity?: string;
+    text_ref?: string;
+    created_at?: string;
+    updated_at?: string;
+    links?: Array<string | {
+        type: string;
+        target: string;
+    }>;
+    relationships?: Array<{
+        type: string;
+        target: string;
+    }>;
+    sourceLine?: number;
+    sourceColumn?: number;
+    sourceEndLine?: number;
+    sourceEndColumn?: number;
+    coordinatesGeneratedAt?: string;
+    [key: string]: unknown;
+}
 export declare function extractFromManifestString(content: string, filePath: string): ExtractionResult[];
+export declare function extractManifestSymbolRecordsString(content: string, filePath: string): ManifestSymbolRecord[];
 export declare function extractFromManifest(filePath: string): ExtractionResult[];
+export declare function readManifestWithCoordinateOverlay(manifestPath: string, coordinatesPath?: string): ManifestSymbolRecord[];
 //# sourceMappingURL=manifest.d.ts.map

package/dist/extractors/manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/extractors/manifest.ts"],"names":[],"mappings":"AAsBA,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,eAAe,CAAC;IACxB,aAAa,EAAE,qBAAqB,EAAE,CAAC;IACvC,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,aAAc,SAAQ,KAAK;IAG7B,QAAQ,EAAE,MAAM;gBADvB,OAAO,EAAE,MAAM,EACR,QAAQ,EAAE,MAAM;CAK1B;AA+GD,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,gBAAgB,EAAE,CAmBpB;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAGxE"}
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/extractors/manifest.ts"],"names":[],"mappings":"AA6BA,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,eAAe,CAAC;IACxB,aAAa,EAAE,qBAAqB,EAAE,CAAC;IACvC,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,aAAc,SAAQ,KAAK;IAG7B,QAAQ,EAAE,MAAM;gBADvB,OAAO,EAAE,MAAM,EACR,QAAQ,EAAE,MAAM;CAK1B;AAED,MAAM,WAAW,oBAAoB;IACnC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACzD,aAAa,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAmHD,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,gBAAgB,EAAE,CAmBpB;AAED,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,oBAAoB,EAAE,CAmBxB;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAKxE;AAsCD,wBAAgB,iCAAiC,CAC/C,YAAY,EAAE,MAAM,EACpB,eAAe,CAAC,EAAE,MAAM,GACvB,oBAAoB,EAAE,CAWxB"}

package/dist/extractors/manifest.js

@@ -16,8 +16,11 @@
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
+import * as path from "node:path";
 import { load as parseYAML } from "js-yaml";
+import { DEFAULT_COORDINATES_PATH } from "../utils/manifest-paths.js";
+import { mergeCoordinatesWithManifest, readCoordinateArtifact, } from "./symbol-coordinates.js";
 export class ManifestError extends Error {
     filePath;
     constructor(message, filePath) {
@@ -26,6 +29,12 @@ export class ManifestError extends Error {
         this.name = "ManifestError";
     }
 }
+function getManifestSymbols(manifest, filePath) {
+    if (!manifest.symbols || !Array.isArray(manifest.symbols)) {
+        throw new ManifestError("No symbols array found in manifest", filePath);
+    }
+    return manifest.symbols;
+}
 function extractRelationships(id, symbol) {
     const relationships = [];
     if (Array.isArray(symbol.links)) {
@@ -66,10 +75,10 @@ function extractRelationships(id, symbol) {
     return relationships;
 }
 function extractFromParsedManifest(manifest, filePath) {
-    if (!manifest.symbols || !Array.isArray(manifest.symbols)) {
-        throw new ManifestError("No symbols array found in manifest", filePath);
-    }
-    return manifest.symbols.map((symbol) => {
+    return extractFromManifestSymbolRecords(getManifestSymbols(manifest, filePath), filePath);
+}
+function extractFromManifestSymbolRecords(manifestSymbols, filePath) {
+    return manifestSymbols.map((symbol) => {
         if (!symbol.title) {
             throw new ManifestError("Missing required field: title", filePath);
         }
@@ -96,6 +105,9 @@ function extractFromParsedManifest(manifest, filePath) {
         };
     });
 }
+function cloneManifestSymbols(manifest, filePath) {
+    return getManifestSymbols(manifest, filePath).map((symbol) => ({ ...symbol }));
+}
 // implements REQ-007
 export function extractFromManifestString(content, filePath) {
     try {
@@ -112,9 +124,50 @@ export function extractFromManifestString(content, filePath) {
         throw error;
     }
 }
+export function extractManifestSymbolRecordsString(content, filePath) {
+    try {
+        const manifest = parseYAML(content);
+        return cloneManifestSymbols(manifest, filePath);
+    }
+    catch (error) {
+        if (error instanceof ManifestError) {
+            throw error;
+        }
+        if (error instanceof Error) {
+            throw new ManifestError(`Failed to parse manifest: ${error.message}`, filePath);
+        }
+        throw error;
+    }
+}
 export function extractFromManifest(filePath) {
-    const content = readFileSync(filePath, "utf8");
-    return extractFromManifestString(content, filePath);
+    return extractFromManifestSymbolRecords(readManifestWithCoordinateOverlay(filePath), filePath);
+}
+function resolveCoordinatesPath(manifestPath, coordinatesPath) {
+    if (coordinatesPath) {
+        return coordinatesPath;
+    }
+    return path.join(path.dirname(manifestPath), path.basename(DEFAULT_COORDINATES_PATH));
+}
+function readCoordinateArtifactFromFile(coordinatesPath) {
+    if (!existsSync(coordinatesPath)) {
+        return null;
+    }
+    try {
+        return readCoordinateArtifact(readFileSync(coordinatesPath, "utf8"));
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new ManifestError(`Failed to parse coordinate artifact: ${error.message}`, coordinatesPath);
+        }
+        throw error;
+    }
+}
+// implements REQ-core-extractors
+export function readManifestWithCoordinateOverlay(manifestPath, coordinatesPath) {
+    const manifestContent = readFileSync(manifestPath, "utf8");
+    const manifestRecords = extractManifestSymbolRecordsString(manifestContent, manifestPath);
+    const coordinateArtifact = readCoordinateArtifactFromFile(resolveCoordinatesPath(manifestPath, coordinatesPath));
+    return mergeCoordinatesWithManifest(manifestRecords, coordinateArtifact);
 }
 function generateId(filePath, title) {
     const hash = createHash("sha256");

package/dist/extractors/symbol-coordinates.d.ts

@@ -0,0 +1,15 @@
+import type { ManifestSymbolRecord } from "./manifest.js";
+export interface SymbolCoordinatesRecord {
+    sourceFile: string;
+    sourceLine: number;
+    sourceColumn: number;
+    sourceEndLine: number;
+    sourceEndColumn: number;
+}
+export interface SymbolCoordinatesArtifact {
+    coordinates: Record<string, SymbolCoordinatesRecord>;
+}
+export declare function readCoordinateArtifact(content: string): SymbolCoordinatesArtifact;
+export declare function writeCoordinateArtifact(coordinates: Record<string, SymbolCoordinatesRecord>): string;
+export declare function mergeCoordinatesWithManifest(symbolRecords: ManifestSymbolRecord[], coordinateArtifact: SymbolCoordinatesArtifact | null): ManifestSymbolRecord[];
+//# sourceMappingURL=symbol-coordinates.d.ts.map

package/dist/extractors/symbol-coordinates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-coordinates.d.ts","sourceRoot":"","sources":["../../src/extractors/symbol-coordinates.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE1D,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;CACtD;AA0DD,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,GACd,yBAAyB,CAkB3B;AAGD,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,GACnD,MAAM,CAUR;AAGD,wBAAgB,4BAA4B,CAC1C,aAAa,EAAE,oBAAoB,EAAE,EACrC,kBAAkB,EAAE,yBAAyB,GAAG,IAAI,GACnD,oBAAoB,EAAE,CAoBxB"}

package/dist/extractors/symbol-coordinates.js

@@ -0,0 +1,83 @@
+import { dump as dumpYAML, load as parseYAML } from "js-yaml";
+const SYMBOL_COORDINATES_COMMENT_BLOCK = `# symbol-coordinates.yaml
+# GENERATED coordinate artifact — do not edit manually.
+# Run \`kibi sync --refresh-symbol-coordinates\` to refresh.
+`;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeCoordinateRecord(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const { sourceColumn, sourceEndColumn, sourceEndLine, sourceFile, sourceLine } = value;
+    if (typeof sourceFile !== "string" ||
+        typeof sourceLine !== "number" ||
+        typeof sourceColumn !== "number" ||
+        typeof sourceEndLine !== "number" ||
+        typeof sourceEndColumn !== "number") {
+        return null;
+    }
+    return {
+        sourceFile,
+        sourceLine,
+        sourceColumn,
+        sourceEndLine,
+        sourceEndColumn,
+    };
+}
+function sortCoordinates(coordinates) {
+    const sortedCoordinates = {};
+    for (const symbolId of Object.keys(coordinates).sort((left, right) => left.localeCompare(right))) {
+        const record = normalizeCoordinateRecord(coordinates[symbolId]);
+        if (!record) {
+            continue;
+        }
+        sortedCoordinates[symbolId] = record;
+    }
+    return sortedCoordinates;
+}
+// implements REQ-core-extractors
+export function readCoordinateArtifact(content) {
+    const parsed = parseYAML(content);
+    if (!isRecord(parsed) || !isRecord(parsed.coordinates)) {
+        return { coordinates: {} };
+    }
+    const coordinates = {};
+    for (const [symbolId, record] of Object.entries(parsed.coordinates)) {
+        const normalizedRecord = normalizeCoordinateRecord(record);
+        if (!normalizedRecord) {
+            continue;
+        }
+        coordinates[symbolId] = normalizedRecord;
+    }
+    return { coordinates };
+}
+// implements REQ-core-extractors
+export function writeCoordinateArtifact(coordinates) {
+    const artifact = {
+        coordinates: sortCoordinates(coordinates),
+    };
+    return `${SYMBOL_COORDINATES_COMMENT_BLOCK}${dumpYAML(artifact, {
+        lineWidth: -1,
+        noRefs: true,
+        sortKeys: true,
+    })}`;
+}
+// implements REQ-core-extractors
+export function mergeCoordinatesWithManifest(symbolRecords, coordinateArtifact) {
+    const coordinates = coordinateArtifact?.coordinates ?? {};
+    return symbolRecords.map((symbolRecord) => {
+        const legacyRecord = { ...symbolRecord };
+        const symbolId = typeof symbolRecord.id === "string" ? symbolRecord.id : undefined;
+        const coordinateRecord = symbolId ? coordinates[symbolId] : undefined;
+        if (!coordinateRecord) {
+            return legacyRecord;
+        }
+        const { coordinatesGeneratedAt: _coordinatesGeneratedAt, ...mergedRecord } = legacyRecord;
+        return {
+            ...mergedRecord,
+            ...coordinateRecord,
+        };
+    });
+}

package/dist/public/extractors/manifest.d.ts

@@ -1,2 +1,2 @@
-export { extractFromManifest, extractFromManifestString, type ExtractionResult, type ManifestError, } from "../../extractors/manifest.js";
+export { extractFromManifest, extractFromManifestString, readManifestWithCoordinateOverlay, type ExtractionResult, type ManifestError, type ManifestSymbolRecord, } from "../../extractors/manifest.js";
 //# sourceMappingURL=manifest.d.ts.map

package/dist/public/extractors/manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../src/public/extractors/manifest.ts"],"names":[],"mappings":"AAkBA,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,KAAK,gBAAgB,EACrB,KAAK,aAAa,GACnB,MAAM,8BAA8B,CAAC"}
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../src/public/extractors/manifest.ts"],"names":[],"mappings":"AAkBA,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,iCAAiC,EACjC,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,oBAAoB,GAC1B,MAAM,8BAA8B,CAAC"}

package/dist/public/extractors/manifest.js

@@ -15,4 +15,4 @@
  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/>.
 */
-export { extractFromManifest, extractFromManifestString, } from "../../extractors/manifest.js";
+export { extractFromManifest, extractFromManifestString, readManifestWithCoordinateOverlay, } from "../../extractors/manifest.js";