kibi-cli 0.10.0 → 0.11.0

package/dist/traceability/staged-symbols-manifest.d.ts

@@ -0,0 +1,23 @@
+import type { StagedFile } from "./git-staged.js";
+export interface StagedSymbolsManifestAssessment {
+    state: "fresh" | "stale" | "missing" | "not_required";
+    sourcePaths: string[];
+    path: string;
+}
+export interface StagedAuthoredSymbolsManifestEvidence {
+    path: string;
+    entries: Array<{
+        sourcePath: string;
+        entityIds: string[];
+    }>;
+}
+export declare function assessStagedSymbolsManifest(options: {
+    symbolsManifestPath: string;
+    sourceFiles: StagedFile[];
+    stagedFiles: StagedFile[];
+}): StagedSymbolsManifestAssessment;
+export declare function collectStagedAuthoredSymbolsManifestEvidence(options: {
+    sourceFiles: StagedFile[];
+    stagedFiles: StagedFile[];
+}): StagedAuthoredSymbolsManifestEvidence;
+//# sourceMappingURL=staged-symbols-manifest.d.ts.map

package/dist/traceability/staged-symbols-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staged-symbols-manifest.d.ts","sourceRoot":"","sources":["../../src/traceability/staged-symbols-manifest.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AA8BlD,MAAM,WAAW,+BAA+B;IAC9C,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,GAAG,cAAc,CAAC;IACtD,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,qCAAqC;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,KAAK,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CAC7D;AAmQD,wBAAgB,2BAA2B,CAAC,OAAO,EAAE;IACnD,mBAAmB,EAAE,MAAM,CAAC;IAC5B,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B,GAAG,+BAA+B,CA0ElC;AAoBD,wBAAgB,4CAA4C,CAAC,OAAO,EAAE;IACpE,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B,GAAG,qCAAqC,CA6CxC"}

package/dist/traceability/staged-symbols-manifest.js

@@ -0,0 +1,269 @@
+import { execSync } from "node:child_process";
+import * as path from "node:path";
+import { extractManifestSymbolRecordsString, } from "../extractors/manifest.js";
+import { mergeCoordinatesWithManifest, readCoordinateArtifact, } from "../extractors/symbol-coordinates.js";
+import { analyzeSourceText } from "../extractors/symbols-coordinator.js";
+import { resolveSymbolsManifestPaths } from "../utils/manifest-paths.js";
+function toRepoRelativePath(absoluteOrRelativePath) {
+    if (!path.isAbsolute(absoluteOrRelativePath)) {
+        return absoluteOrRelativePath.replace(/\\/g, "/");
+    }
+    const relativePath = path.relative(process.cwd(), absoluteOrRelativePath);
+    return relativePath.replace(/\\/g, "/");
+}
+function resolveRelativeManifestPaths(symbolsManifestPath) {
+    if (symbolsManifestPath) {
+        const normalizedSymbolsPath = toRepoRelativePath(symbolsManifestPath);
+        return {
+            symbolsPath: normalizedSymbolsPath,
+            coordinatesPath: path
+                .join(path.dirname(normalizedSymbolsPath), "symbol-coordinates.yaml")
+                .replace(/\\/g, "/"),
+        };
+    }
+    const { coordinatesPath, symbolsPath } = resolveSymbolsManifestPaths(process.cwd());
+    return {
+        symbolsPath: toRepoRelativePath(symbolsPath),
+        coordinatesPath: toRepoRelativePath(coordinatesPath),
+    };
+}
+function readHeadFileContent(filePath) {
+    try {
+        return execSync(`git show HEAD:${filePath}`, {
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function parseManifestRecords(content, filePath) {
+    if (content === null || content === undefined) {
+        return [];
+    }
+    try {
+        return extractManifestSymbolRecordsString(content, filePath);
+    }
+    catch {
+        return null;
+    }
+}
+function parseCoordinateArtifact(content) {
+    if (content === null || content === undefined) {
+        return { coordinates: {} };
+    }
+    try {
+        return readCoordinateArtifact(content);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeNumber(value) {
+    return typeof value === "number" ? value : null;
+}
+function normalizeLinks(links) {
+    if (!Array.isArray(links)) {
+        return [];
+    }
+    const normalized = [];
+    for (const link of links) {
+        if (typeof link === "string") {
+            normalized.push(link);
+            continue;
+        }
+        if (link &&
+            typeof link === "object" &&
+            typeof link.type === "string" &&
+            typeof link.target === "string") {
+            normalized.push({ type: link.type, target: link.target });
+        }
+    }
+    return normalized.sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
+}
+function normalizeRelationships(relationships) {
+    if (!Array.isArray(relationships)) {
+        return [];
+    }
+    return relationships
+        .flatMap((relationship) => {
+        if (relationship &&
+            typeof relationship.type === "string" &&
+            typeof relationship.target === "string") {
+            return [{ type: relationship.type, target: relationship.target }];
+        }
+        return [];
+    })
+        .sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
+}
+function normalizeManifestSymbolsForSourceFile(records, sourceFile) {
+    return records
+        .filter((record) => {
+        const recordSource = typeof record.sourceFile === "string"
+            ? record.sourceFile
+            : typeof record.source === "string"
+                ? record.source
+                : null;
+        return recordSource === sourceFile && typeof record.title === "string";
+    })
+        .map((record) => ({
+        title: record.title,
+        sourceFile,
+        sourceLine: normalizeNumber(record.sourceLine),
+        sourceColumn: normalizeNumber(record.sourceColumn),
+        sourceEndLine: normalizeNumber(record.sourceEndLine),
+        sourceEndColumn: normalizeNumber(record.sourceEndColumn),
+    }))
+        .sort(compareNormalizedSymbols);
+}
+function normalizeAuthoredManifestSymbolsForSourceFile(records, sourceFile) {
+    return records
+        .filter((record) => {
+        const recordSource = typeof record.sourceFile === "string"
+            ? record.sourceFile
+            : typeof record.source === "string"
+                ? record.source
+                : null;
+        return recordSource === sourceFile && typeof record.title === "string";
+    })
+        .map((record) => ({
+        id: typeof record.id === "string" ? record.id : null,
+        title: record.title,
+        sourceFile,
+        status: typeof record.status === "string" ? record.status : null,
+        links: normalizeLinks(record.links),
+        relationships: normalizeRelationships(record.relationships),
+        tags: Array.isArray(record.tags)
+            ? record.tags.filter((tag) => typeof tag === "string").sort()
+            : [],
+        owner: typeof record.owner === "string" ? record.owner : null,
+        priority: typeof record.priority === "string" ? record.priority : null,
+        severity: typeof record.severity === "string" ? record.severity : null,
+        textRef: typeof record.text_ref === "string" ? record.text_ref : null,
+    }))
+        .sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
+}
+function normalizeExpectedSymbolsForStagedFile(stagedFile) {
+    const analysis = analyzeSourceText(stagedFile.path, stagedFile.content ?? "");
+    return analysis.symbols
+        .map((symbol) => ({
+        title: symbol.name,
+        sourceFile: stagedFile.path,
+        sourceLine: symbol.startLine,
+        sourceColumn: symbol.startColumn,
+        sourceEndLine: symbol.endLine,
+        sourceEndColumn: symbol.endColumn,
+    }))
+        .sort(compareNormalizedSymbols);
+}
+function compareNormalizedSymbols(left, right) {
+    return JSON.stringify(left).localeCompare(JSON.stringify(right));
+}
+function signaturesEqual(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function uniqueSorted(paths) {
+    return Array.from(new Set(paths)).sort();
+}
+function mergeManifestRecordsWithCoordinates(manifestRecords, coordinateArtifact) {
+    return mergeCoordinatesWithManifest(manifestRecords ?? [], coordinateArtifact);
+}
+function getEffectiveManifestRecords(options) {
+    const { headCoordinateArtifact, headManifestRecords, paths, stagedFiles } = options;
+    const stagedManifestFile = stagedFiles.find((file) => file.path === paths.symbolsPath);
+    const stagedCoordinatesFile = stagedFiles.find((file) => file.path === paths.coordinatesPath);
+    const stagedManifestRecords = stagedManifestFile
+        ? parseManifestRecords(stagedManifestFile.content, paths.symbolsPath)
+        : headManifestRecords;
+    const stagedCoordinateArtifact = stagedCoordinatesFile
+        ? parseCoordinateArtifact(stagedCoordinatesFile.content)
+        : headCoordinateArtifact;
+    return {
+        stagedManifestFile,
+        stagedCoordinatesFile,
+        stagedManifestRecords,
+        stagedCoordinateArtifact,
+    };
+}
+export function assessStagedSymbolsManifest(options) {
+    const { sourceFiles, stagedFiles, symbolsManifestPath } = options;
+    const paths = resolveRelativeManifestPaths(symbolsManifestPath);
+    const headManifestRecords = parseManifestRecords(readHeadFileContent(paths.symbolsPath), paths.symbolsPath);
+    const headCoordinateArtifact = parseCoordinateArtifact(readHeadFileContent(paths.coordinatesPath));
+    const { stagedCoordinatesFile, stagedCoordinateArtifact, stagedManifestRecords, } = getEffectiveManifestRecords({
+        stagedFiles,
+        paths,
+        headManifestRecords,
+        headCoordinateArtifact,
+    });
+    const baselineMergedRecords = mergeManifestRecordsWithCoordinates(headManifestRecords, headCoordinateArtifact);
+    const stagedMergedRecords = mergeManifestRecordsWithCoordinates(stagedManifestRecords, stagedCoordinateArtifact);
+    const requiredRefreshPaths = [];
+    const freshPaths = new Set();
+    for (const sourceFile of sourceFiles) {
+        const expectedSymbols = normalizeExpectedSymbolsForStagedFile(sourceFile);
+        const baselineSymbols = normalizeManifestSymbolsForSourceFile(baselineMergedRecords, sourceFile.path);
+        if (signaturesEqual(expectedSymbols, baselineSymbols)) {
+            continue;
+        }
+        requiredRefreshPaths.push(sourceFile.path);
+        if (!stagedCoordinatesFile || stagedCoordinateArtifact === null) {
+            continue;
+        }
+        const stagedSymbols = normalizeManifestSymbolsForSourceFile(stagedMergedRecords, sourceFile.path);
+        if (signaturesEqual(expectedSymbols, stagedSymbols)) {
+            freshPaths.add(sourceFile.path);
+        }
+    }
+    const sourcePaths = uniqueSorted(requiredRefreshPaths);
+    if (sourcePaths.length === 0) {
+        return { state: "not_required", sourcePaths: [], path: paths.coordinatesPath };
+    }
+    if (sourcePaths.every((sourcePath) => freshPaths.has(sourcePath))) {
+        return { state: "fresh", sourcePaths, path: paths.coordinatesPath };
+    }
+    if (!stagedCoordinatesFile) {
+        return { state: "missing", sourcePaths, path: paths.coordinatesPath };
+    }
+    return { state: "stale", sourcePaths, path: paths.coordinatesPath };
+}
+function getEntityIdsForSourceFile(records, sourceFile) {
+    return records
+        .filter((record) => {
+        const recordSource = typeof record.sourceFile === "string"
+            ? record.sourceFile
+            : typeof record.source === "string"
+                ? record.source
+                : null;
+        return recordSource === sourceFile && typeof record.id === "string";
+    })
+        .map((record) => record.id)
+        .sort();
+}
+export function collectStagedAuthoredSymbolsManifestEvidence(options) {
+    const { sourceFiles, stagedFiles } = options;
+    const paths = resolveRelativeManifestPaths();
+    const stagedManifestFile = stagedFiles.find((file) => file.path === paths.symbolsPath);
+    if (!stagedManifestFile) {
+        return { path: paths.symbolsPath, entries: [] };
+    }
+    const headManifestRecords = parseManifestRecords(readHeadFileContent(paths.symbolsPath), paths.symbolsPath) ?? [];
+    const stagedManifestRecords = parseManifestRecords(stagedManifestFile.content, paths.symbolsPath);
+    if (stagedManifestRecords === null) {
+        return { path: paths.symbolsPath, entries: [] };
+    }
+    const entries = [];
+    for (const sourceFile of sourceFiles) {
+        const headSymbols = normalizeAuthoredManifestSymbolsForSourceFile(headManifestRecords, sourceFile.path);
+        const stagedSymbols = normalizeAuthoredManifestSymbolsForSourceFile(stagedManifestRecords, sourceFile.path);
+        if (signaturesEqual(headSymbols, stagedSymbols)) {
+            continue;
+        }
+        entries.push({
+            sourcePath: sourceFile.path,
+            entityIds: getEntityIdsForSourceFile(stagedManifestRecords, sourceFile.path),
+        });
+    }
+    return { path: paths.symbolsPath, entries };
+}

package/dist/traceability/symbol-extract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symbol-extract.d.ts","sourceRoot":"","sources":["../../src/traceability/symbol-extract.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7D,KAAK,wBAAwB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAU7D,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,GAAG,OAAO,GAAG,UAAU,GAAG,MAAM,GAAG,SAAS,CAAC;IAC7D,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,aAAa,CAAC,EAAE,wBAAwB,EAAE,CAAC;CAC5C;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,CAAC,EAAE,wBAAwB,EAAE,CAAC;CAC5C;AAED,MAAM,MAAM,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;AAE9D,wBAAgB,+BAA+B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAG5E;AA2LD,wBAAgB,4BAA4B,CAE1C,UAAU,EAAE,UAAU,EACtB,cAAc,CAAC,EAAE,cAAc,GAC9B,eAAe,EAAE,CA+JnB"}
+{"version":3,"file":"symbol-extract.d.ts","sourceRoot":"","sources":["../../src/traceability/symbol-extract.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7D,KAAK,wBAAwB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAU7D,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,GAAG,OAAO,GAAG,UAAU,GAAG,MAAM,GAAG,SAAS,CAAC;IAC7D,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,aAAa,CAAC,EAAE,wBAAwB,EAAE,CAAC;CAC5C;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,CAAC,EAAE,wBAAwB,EAAE,CAAC;CAC5C;AAED,MAAM,MAAM,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;AAE9D,wBAAgB,+BAA+B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAG5E;AA+ND,wBAAgB,4BAA4B,CAE1C,UAAU,EAAE,UAAU,EACtB,cAAc,CAAC,EAAE,cAAc,GAC9B,eAAe,EAAE,CA+JnB"}

package/dist/traceability/symbol-extract.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { Project, ScriptKind } from "ts-morph";
-import { extractFromManifest } from "../extractors/manifest.js";
+import { readManifestWithCoordinateOverlay } from "../extractors/manifest.js";
 const TRACEABILITY_RELATIONSHIP_TYPES = new Set([
     "implements",
     "covered_by",
@@ -55,15 +55,12 @@ function resolveSymbolTraceability(filePath, name, manifestLookup) {
     }
     for (const manifestPath of candidateManifestPaths) {
         try {
-            const ents = extractFromManifest(manifestPath);
-            for (const e of ents) {
-                if (e.entity.title === name) {
+            const records = readManifestWithCoordinateOverlay(manifestPath);
+            for (const record of records) {
+                if (record.title === name && typeof record.id === "string") {
                     return {
-                        id: e.entity.id,
-                        relationships: filterTraceabilityRelationships(e.relationships.map((relationship) => ({
-                            type: relationship.type,
-                            to: relationship.to,
-                        }))),
+                        id: record.id,
+                        relationships: filterTraceabilityRelationships(extractRelationshipsFromManifestRecord(record)),
                     };
                 }
             }
@@ -74,6 +71,33 @@ function resolveSymbolTraceability(filePath, name, manifestLookup) {
     }
     return { id: createHashFallbackId(filePath, name) };
 }
+function extractRelationshipsFromManifestRecord(record) {
+    const relationships = [];
+    if (Array.isArray(record.links)) {
+        for (const link of record.links) {
+            if (typeof link === "string") {
+                relationships.push({ type: "implements", to: link });
+                continue;
+            }
+            if (link &&
+                typeof link === "object" &&
+                typeof link.type === "string" &&
+                typeof link.target === "string") {
+                relationships.push({ type: link.type, to: link.target });
+            }
+        }
+    }
+    if (Array.isArray(record.relationships)) {
+        for (const relationship of record.relationships) {
+            if (relationship &&
+                typeof relationship.type === "string" &&
+                typeof relationship.target === "string") {
+                relationships.push({ type: relationship.type, to: relationship.target });
+            }
+        }
+    }
+    return relationships;
+}
 function buildSymbolResult(stagedFile, name, kind, span, inlineReqLinks, manifestLookup) {
     const { id, relationships } = resolveSymbolTraceability(stagedFile.path, name, manifestLookup);
     const manifestReqLinks = getRequirementLinks(relationships);

package/dist/utils/manifest-paths.d.ts

@@ -0,0 +1,8 @@
+export declare const DEFAULT_SYMBOLS_PATH = "documentation/symbols.yaml";
+export declare const DEFAULT_COORDINATES_PATH = "documentation/symbol-coordinates.yaml";
+export declare function resolveSymbolsManifestPaths(workspaceRoot: string, configPath?: string): {
+    symbolsPath: string;
+    coordinatesPath: string;
+};
+export declare function resolveSymbolsManifestPath(workspaceRoot: string, configPath?: string): string;
+//# sourceMappingURL=manifest-paths.d.ts.map

package/dist/utils/manifest-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-paths.d.ts","sourceRoot":"","sources":["../../src/utils/manifest-paths.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,oBAAoB,+BAA+B,CAAC;AACjE,eAAO,MAAM,wBAAwB,0CAA0C,CAAC;AAuEhF,wBAAgB,2BAA2B,CACzC,aAAa,EAAE,MAAM,EACrB,UAAU,CAAC,EAAE,MAAM,GAClB;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAAE,CASlD;AAGD,wBAAgB,0BAA0B,CACxC,aAAa,EAAE,MAAM,EACrB,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,CAER"}

package/dist/utils/manifest-paths.js

@@ -0,0 +1,62 @@
+import { existsSync, readFileSync } from "node:fs";
+import * as path from "node:path";
+export const DEFAULT_SYMBOLS_PATH = "documentation/symbols.yaml";
+export const DEFAULT_COORDINATES_PATH = "documentation/symbol-coordinates.yaml";
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function resolveConfigPath(workspaceRoot, configPath) {
+    const configuredPath = configPath ?? path.join(workspaceRoot, ".kb", "config.json");
+    return path.isAbsolute(configuredPath)
+        ? configuredPath
+        : path.resolve(workspaceRoot, configuredPath);
+}
+function readManifestResolverConfig(workspaceRoot, configPath) {
+    const resolvedConfigPath = resolveConfigPath(workspaceRoot, configPath);
+    if (!existsSync(resolvedConfigPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(resolvedConfigPath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function resolveConfiguredSymbolsPath(workspaceRoot, configPath) {
+    const config = readManifestResolverConfig(workspaceRoot, configPath);
+    if (!config) {
+        return null;
+    }
+    const configuredPathCandidate = config.paths?.symbols ?? config.symbolsManifest;
+    if (!isNonEmptyString(configuredPathCandidate)) {
+        return null;
+    }
+    return path.isAbsolute(configuredPathCandidate)
+        ? configuredPathCandidate
+        : path.resolve(workspaceRoot, configuredPathCandidate);
+}
+function resolveDefaultSymbolsPath(workspaceRoot) {
+    const candidates = [
+        path.join(workspaceRoot, DEFAULT_SYMBOLS_PATH),
+        path.join(workspaceRoot, "symbols.yaml"),
+        path.join(workspaceRoot, "symbols.yml"),
+    ];
+    return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0] ?? path.join(workspaceRoot, DEFAULT_SYMBOLS_PATH);
+}
+function deriveCoordinatesPath(symbolsPath) {
+    return path.join(path.dirname(symbolsPath), path.basename(DEFAULT_COORDINATES_PATH));
+}
+// implements REQ-cli-sync
+export function resolveSymbolsManifestPaths(workspaceRoot, configPath) {
+    const symbolsPath = resolveConfiguredSymbolsPath(workspaceRoot, configPath) ??
+        resolveDefaultSymbolsPath(workspaceRoot);
+    return {
+        symbolsPath,
+        coordinatesPath: deriveCoordinatesPath(symbolsPath),
+    };
+}
+// implements REQ-cli-sync
+export function resolveSymbolsManifestPath(workspaceRoot, configPath) {
+    return resolveSymbolsManifestPaths(workspaceRoot, configPath).symbolsPath;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-cli",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "type": "module",
   "description": "Kibi CLI for knowledge base management",
   "engines": {

package/src/public/extractors/manifest.ts

@@ -19,6 +19,8 @@
 export {
   extractFromManifest,
   extractFromManifestString,
+  readManifestWithCoordinateOverlay,
   type ExtractionResult,
   type ManifestError,
+  type ManifestSymbolRecord,
 } from "../../extractors/manifest.js";