kibi-cli 0.12.8 → 0.16.1

package/dist/operations/autopilot/candidates.js

@@ -0,0 +1,114 @@
+import path from "node:path";
+import { extractFromManifestString } from "../../extractors/manifest.js";
+import { extractFromMarkdownString } from "../../extractors/markdown.js";
+import { confidenceBand, slug, upsert } from "./candidate-helpers.js";
+import { markdownCandidates, } from "./markdown-candidates.js";
+function typedCandidates(item, existingIds) {
+    try {
+        const results = item.kind === "symbol_manifest"
+            ? extractFromManifestString(item.content ?? "", item.relativePath ?? item.label)
+            : [
+                extractFromMarkdownString(item.content ?? "", item.relativePath ?? item.label),
+            ];
+        return results.flatMap(({ entity, relationships }) => {
+            if (existingIds.has(entity.id))
+                return [];
+            const sourceKind = item.kind === "symbol_manifest" ? "symbol_manifest" : "typed_markdown";
+            return [
+                {
+                    candidateId: `${sourceKind === "symbol_manifest" ? "mf" : "md"}:${item.relativePath}:${entity.id}`,
+                    entityType: entity.type,
+                    title: entity.title,
+                    sourceKind,
+                    sourcePath: item.absolutePath ?? item.label,
+                    confidence: sourceKind === "symbol_manifest" ? 0.98 : 1,
+                    confidenceBand: "high",
+                    evidence: [
+                        `extracted_from_${sourceKind}:${item.relativePath}`,
+                        `entity_id:${entity.id}`,
+                    ],
+                    relationships: relationships.map(({ type, from, to }) => ({
+                        type,
+                        from,
+                        to,
+                    })),
+                    applyPlan: [upsert(entity, relationships)],
+                },
+            ];
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function providerCandidate(item, existingIds, minConfidence) {
+    if (!new Set([
+        "repo_metadata",
+        "repo_layout",
+        "test_topology",
+        "source_symbols",
+    ]).has(item.kind))
+        return [];
+    const relativePath = item.relativePath ?? item.label;
+    const confidence = typeof item.data.confidence === "number" ? item.data.confidence : 0.8;
+    const id = `FACT-GEN-${slug(`${item.kind}-${relativePath}`, 64) || "evidence"}`.toUpperCase();
+    if (confidence < minConfidence || existingIds.has(id))
+        return [];
+    const symbolTitle = item.kind === "source_symbols" && /\.(?:[cm]?[jt]sx?)$/i.test(relativePath)
+        ? `Source symbols: ${path.basename(relativePath, path.extname(relativePath))}`
+        : undefined;
+    const title = symbolTitle ??
+        (typeof item.data.title === "string"
+            ? item.data.title
+            : `Autopilot evidence from ${relativePath}`);
+    const entity = {
+        type: "fact",
+        id,
+        title,
+        status: "active",
+        fact_kind: typeof item.data.factKind === "string"
+            ? item.data.factKind
+            : item.kind === "repo_metadata"
+                ? "meta"
+                : "observation",
+        source: `autopilot:${item.provider}:${relativePath}`,
+        text_ref: relativePath,
+    };
+    const evidence = Array.isArray(item.data.evidence)
+        ? item.data.evidence.filter((value) => typeof value === "string")
+        : [`provider:${item.provider}`];
+    return [
+        {
+            candidateId: `prov:${item.kind}:${slug(relativePath, 96) || "evidence"}`,
+            entityType: "fact",
+            title,
+            sourceKind: item.kind,
+            sourcePath: item.absolutePath ?? relativePath,
+            confidence,
+            confidenceBand: confidenceBand(confidence),
+            evidence,
+            relationships: [],
+            applyPlan: [upsert(entity)],
+        },
+    ];
+}
+// implements REQ-mcp-init-kibi-autopilot-v1, REQ-kibi-operation-interface-parity
+export function buildAutopilotCandidates(evidence, existingIds, minConfidence, includeGenericMarkdown) {
+    const candidates = [];
+    const sourceOnlySignals = [];
+    for (const item of evidence) {
+        if (item.kind === "typed_markdown" || item.kind === "symbol_manifest")
+            candidates.push(...typedCandidates(item, existingIds));
+        if (item.kind === "generic_markdown" && includeGenericMarkdown) {
+            const built = markdownCandidates(item, existingIds, minConfidence);
+            candidates.push(...built.candidates);
+            sourceOnlySignals.push(...built.sourceOnlySignals);
+        }
+        candidates.push(...providerCandidate(item, existingIds, minConfidence));
+    }
+    return {
+        candidates,
+        sourceOnlySignals: sourceOnlySignals.sort((left, right) => right.confidence - left.confidence ||
+            left.sourcePath.localeCompare(right.sourcePath)),
+    };
+}

package/dist/operations/autopilot/discovery-evidence.d.ts

@@ -0,0 +1,10 @@
+import type { OperationContext } from "../../public/operations/runtime-types.js";
+import type { AutopilotEvidence } from "./types.js";
+export type EvidenceScan = {
+    readonly files: readonly string[];
+    readonly ignoredSources: readonly string[];
+    readonly evidence: readonly AutopilotEvidence[];
+    readonly warnings: readonly string[];
+};
+export declare function scanEvidence(context: OperationContext): Promise<EvidenceScan>;
+//# sourceMappingURL=discovery-evidence.d.ts.map

package/dist/operations/autopilot/discovery-evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery-evidence.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/discovery-evidence.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAGV,gBAAgB,EACjB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EACV,iBAAiB,EAGlB,MAAM,YAAY,CAAC;AA0BpB,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAChD,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC,CAAC;AA8HF,wBAAsB,YAAY,CAChC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,YAAY,CAAC,CAqDvB"}

package/dist/operations/autopilot/discovery-evidence.js

@@ -0,0 +1,158 @@
+import path from "node:path";
+import { OperationError } from "../../cli-errors.js";
+const SCAN_PATTERNS = [
+    "**/*.md",
+    "**/symbols.{yml,yaml}",
+    "**/package.json",
+    "**/tsconfig*.json",
+    "**/pyproject.toml",
+    "**/Cargo.toml",
+    "**/go.mod",
+    "**/opencode.json",
+    "**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs,py,rb,go,rs,java,kt,swift,php,c,cc,cpp,h,hpp}",
+];
+const CODE_EXTENSION = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs|py|rb|go|rs|java|kt|swift|php|c|cc|cpp|h|hpp)$/i;
+const LAYOUT_ROOTS = new Set([
+    "src",
+    "app",
+    "apps",
+    "packages",
+    "tests",
+    "test",
+    "docs",
+    "scripts",
+]);
+function isScanFilesystem(value) {
+    return Boolean(value && "glob" in value && typeof value.glob === "function");
+}
+function isScanGit(value) {
+    return Boolean(value &&
+        "ignoredPaths" in value &&
+        typeof value.ignoredPaths === "function");
+}
+function classifyFile(relativePath, content) {
+    if (/symbols\.ya?ml$/i.test(relativePath))
+        return ["typed_kibi_docs", "symbol_manifest"];
+    if (/\.md$/i.test(relativePath)) {
+        return /^---\s*[\r\n]/.test(content) &&
+            /(^|\/)documentation\/(requirements|scenarios|tests|adr|flags|events|facts)\//.test(relativePath)
+            ? ["typed_kibi_docs", "typed_markdown"]
+            : ["generic_repo_docs", "generic_markdown"];
+    }
+    if (/(^|\/)(package\.json|tsconfig[^/]*\.json|pyproject\.toml|Cargo\.toml|go\.mod)$/.test(relativePath))
+        return ["repo_metadata", "repo_metadata"];
+    if (/\.(test|spec)\.[^.]+$/i.test(relativePath) ||
+        /(^|\/)__tests__\//.test(relativePath))
+        return ["test_topology", "test_topology"];
+    if (CODE_EXTENSION.test(relativePath))
+        return ["source_symbols", "source_symbols"];
+    return null;
+}
+function evidenceData(provider, relativePath, content) {
+    if (provider === "repo_metadata")
+        return {
+            title: `Repository metadata: ${path.basename(relativePath)}`,
+            factKind: "meta",
+            confidence: relativePath.includes("tsconfig") ? 0.9 : 0.86,
+            evidence: [`repo_metadata:${relativePath}`],
+        };
+    if (provider === "test_topology") {
+        const frameworks = [
+            content.includes("bun:test") ? "bun:test" : "",
+            content.includes("vitest") ? "vitest" : "",
+            content.includes("node:test") ? "node:test" : "",
+        ].filter(Boolean);
+        return {
+            title: `Test topology: ${frameworks.join(", ") || relativePath}`,
+            factKind: "observation",
+            confidence: frameworks.length > 0 ? 0.92 : 0.85,
+            evidence: [
+                `test_topology:${relativePath}`,
+                ...frameworks.map((item) => `framework:${item}`),
+            ],
+            frameworks,
+        };
+    }
+    if (provider === "source_symbols")
+        return {
+            title: `Source module: ${path.basename(relativePath, path.extname(relativePath))}`,
+            factKind: "observation",
+            confidence: 0.82,
+            evidence: [`source_symbols:${relativePath}`],
+        };
+    return {};
+}
+function layoutEvidence(workspaceRoot, files, ignored) {
+    const roots = [
+        ...new Set(files
+            .filter((file) => !ignored.has(file))
+            .map((file) => file.split("/", 1)[0] ?? "")
+            .filter((root) => LAYOUT_ROOTS.has(root))),
+    ];
+    return roots.map((root) => ({
+        provider: "repo_layout",
+        kind: "repo_layout",
+        label: root,
+        relativePath: root,
+        absolutePath: path.join(workspaceRoot, root),
+        data: {
+            title: `Repository layout: ${root} directory`,
+            factKind: "observation",
+            confidence: 0.84,
+            evidence: [`repo_layout:${root}`],
+        },
+    }));
+}
+export async function scanEvidence(context) {
+    const fs = context.fs;
+    const git = context.git;
+    if (!isScanFilesystem(fs) || !isScanGit(git))
+        throw new OperationError("OPERATION_FAILED", "Autopilot requires filesystem glob and git ignore ports.");
+    const files = [
+        ...(await fs.glob(SCAN_PATTERNS, {
+            cwd: context.workspaceRoot,
+            includeIgnored: true,
+        })),
+    ].sort();
+    const ignoredSources = [
+        ...(await git.ignoredPaths(context.workspaceRoot, files)),
+    ].sort();
+    const ignored = new Set(ignoredSources);
+    const evidence = [];
+    const warnings = [];
+    for (const relativePath of files) {
+        if (ignored.has(relativePath))
+            continue;
+        const absolutePath = path.resolve(context.workspaceRoot, relativePath);
+        try {
+            const content = await fs.readFile(absolutePath);
+            const classification = classifyFile(relativePath, content);
+            if (!classification)
+                continue;
+            const [provider, kind] = classification;
+            if (provider === "repo_metadata" &&
+                path.basename(relativePath) === "package.json") {
+                try {
+                    JSON.parse(content);
+                }
+                catch {
+                    warnings.push(`repo_metadata:failed_to_parse:${relativePath}`);
+                }
+            }
+            evidence.push({
+                provider,
+                kind,
+                label: relativePath,
+                relativePath,
+                absolutePath,
+                content,
+                data: evidenceData(provider, relativePath, content),
+            });
+        }
+        catch {
+            warnings.push(`failed_to_read:${relativePath}`);
+        }
+    }
+    evidence.push(...layoutEvidence(context.workspaceRoot, files, ignored));
+    return { files, ignoredSources, evidence, warnings };
+}

package/dist/operations/autopilot/discovery.d.ts

@@ -0,0 +1,4 @@
+import type { OperationContext } from "../../public/operations/runtime-types.js";
+import { type DiscoveryResult } from "./types.js";
+export declare function discoverAutopilot(context: OperationContext): Promise<DiscoveryResult>;
+//# sourceMappingURL=discovery.d.ts.map

package/dist/operations/autopilot/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/discovery.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAIjF,OAAO,EAGL,KAAK,eAAe,EACrB,MAAM,YAAY,CAAC;AAwEpB,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,CA+C1B"}

package/dist/operations/autopilot/discovery.js

@@ -0,0 +1,100 @@
+import path from "node:path";
+import { getSchemaVersionStatus } from "../../public/schema-version.js";
+import { classifyActivation } from "./activation.js";
+import { scanEvidence } from "./discovery-evidence.js";
+import { AUTOPILOT_PROVIDER_ORDER, } from "./types.js";
+const EXCLUDED_ROOTS = [
+    ".git",
+    ".kb",
+    ".venv",
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+    "target",
+    "third-party",
+    "third_party",
+    "vendor",
+    "vendors",
+    "venv",
+];
+const LANGUAGE_NAMES = {
+    ts: "typescript",
+    tsx: "typescript",
+    mts: "typescript",
+    cts: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    mjs: "javascript",
+    cjs: "javascript",
+    py: "python",
+    rb: "ruby",
+    rs: "rust",
+};
+async function migrationWarning(context) {
+    try {
+        const raw = await context.fs?.readFile(path.join(context.workspaceRoot, ".kb", "config.json"));
+        return getSchemaVersionStatus(JSON.parse(raw ?? "{}") ?? undefined).warning;
+    }
+    catch {
+        return null;
+    }
+}
+function languages(evidence) {
+    return [
+        ...new Set(evidence
+            .filter((item) => item.kind === "source_symbols")
+            .map((item) => {
+            const extension = path.extname(item.label).slice(1);
+            return LANGUAGE_NAMES[extension] ?? extension;
+        })),
+    ].sort();
+}
+function frameworks(evidence) {
+    return [
+        ...new Set(evidence.flatMap((item) => Array.isArray(item.data.frameworks)
+            ? item.data.frameworks.filter((value) => typeof value === "string")
+            : [])),
+    ].sort();
+}
+// implements REQ-mcp-init-kibi-autopilot-v1, REQ-kibi-operation-interface-parity
+export async function discoverAutopilot(context) {
+    const scan = await scanEvidence(context);
+    const ignored = new Set(scan.ignoredSources);
+    const activation = await classifyActivation(context, scan.files.filter((file) => !ignored.has(file)));
+    const evidence = activation.allowCandidateGeneration
+        ? [...scan.evidence]
+        : [];
+    evidence.sort((left, right) => AUTOPILOT_PROVIDER_ORDER.indexOf(left.provider) -
+        AUTOPILOT_PROVIDER_ORDER.indexOf(right.provider) ||
+        left.label.localeCompare(right.label));
+    const providersRun = activation.allowCandidateGeneration
+        ? [...AUTOPILOT_PROVIDER_ORDER]
+        : [];
+    const providerCounts = Object.fromEntries(AUTOPILOT_PROVIDER_ORDER.map((provider) => [
+        provider,
+        evidence.filter((item) => item.provider === provider).length,
+    ]));
+    return {
+        activation,
+        evidence,
+        ignoredSources: scan.ignoredSources,
+        migrationWarning: await migrationWarning(context),
+        summary: {
+            activationState: activation.activationState,
+            activationMode: activation.activationMode,
+            applyBlocked: activation.applyBlocked,
+            reason: activation.reason,
+            ...(activation.handoffMessage
+                ? { handoffMessage: activation.handoffMessage }
+                : {}),
+            providersRun,
+            providerCounts,
+            detectedLanguages: languages(evidence),
+            detectedTestFrameworks: frameworks(evidence),
+            excludedRoots: [...EXCLUDED_ROOTS].sort(),
+            truncated: false,
+            scanWarnings: [...new Set(scan.warnings)].sort(),
+        },
+    };
+}

package/dist/operations/autopilot/generate.d.ts

@@ -0,0 +1,8 @@
+import type { OperationContext } from "../../public/operations/runtime-types.js";
+import type { AutopilotGenerateArgs, AutopilotGenerateResult, Candidate } from "./types.js";
+export declare function selectAutopilotCandidates(input: readonly Candidate[], existingIds: ReadonlySet<string>, entityTypes: readonly string[] | undefined, maximum: number): {
+    readonly candidates: readonly Candidate[];
+    readonly suppressed: readonly Readonly<Record<string, unknown>>[];
+};
+export declare function executeAutopilotGenerate(args: AutopilotGenerateArgs, context: OperationContext): Promise<AutopilotGenerateResult>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/operations/autopilot/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/generate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAIjF,OAAO,KAAK,EACV,qBAAqB,EACrB,uBAAuB,EACvB,SAAS,EACV,MAAM,YAAY,CAAC;AAsBpB,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,EAC1C,OAAO,EAAE,MAAM,GACd;IACD,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,UAAU,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;CACnE,CAiDA;AAiBD,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,qBAAqB,EAC3B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,uBAAuB,CAAC,CAgDlC"}

package/dist/operations/autopilot/generate.js

@@ -0,0 +1,112 @@
+import { loadEntities } from "../../public/operations/discovery-entities.js";
+import { buildAutopilotCandidates } from "./candidates.js";
+import { discoverAutopilot } from "./discovery.js";
+import { presentAutopilot } from "./presentation.js";
+function clamp(value, minimum, maximum) {
+    return Math.max(minimum, Math.min(maximum, value));
+}
+function titleKey(candidate) {
+    return `${candidate.entityType}::${candidate.title.trim().toLowerCase().replace(/\s+/g, " ")}`;
+}
+function firstUpsertId(candidate) {
+    const first = candidate.applyPlan[0];
+    if (typeof first?.id === "string")
+        return first.id;
+    const properties = first?.properties;
+    return properties !== null &&
+        typeof properties === "object" &&
+        "id" in properties &&
+        typeof properties.id === "string"
+        ? properties.id
+        : "";
+}
+export function selectAutopilotCandidates(input, existingIds, entityTypes, maximum) {
+    const allowed = entityTypes && entityTypes.length > 0 ? new Set(entityTypes) : null;
+    const sorted = input
+        .filter((candidate) => allowed?.has(candidate.entityType) ?? true)
+        .sort((left, right) => right.confidence - left.confidence ||
+        left.sourcePath.localeCompare(right.sourcePath))
+        .slice(0, maximum);
+    const typedTitles = new Set(sorted
+        .filter((candidate) => candidate.sourceKind === "typed_markdown")
+        .map(titleKey));
+    const selected = new Map();
+    const suppressed = [];
+    const suppress = (candidate, reason) => {
+        suppressed.push({
+            candidateId: candidate.candidateId,
+            reason,
+            sourcePath: candidate.sourcePath,
+            entityType: candidate.entityType,
+        });
+    };
+    for (const candidate of sorted) {
+        if (existingIds.has(firstUpsertId(candidate))) {
+            suppress(candidate, "entity_exists");
+            continue;
+        }
+        const key = titleKey(candidate);
+        if (candidate.sourceKind === "generic_markdown" && typedTitles.has(key)) {
+            suppress(candidate, "shadowed_by_typed_source");
+            continue;
+        }
+        const previous = selected.get(key);
+        if (!previous) {
+            selected.set(key, candidate);
+            continue;
+        }
+        const keepCandidate = candidate.confidence > previous.confidence ||
+            (candidate.confidence === previous.confidence &&
+                candidate.sourcePath < previous.sourcePath);
+        suppress(keepCandidate ? previous : candidate, "duplicate_title");
+        if (keepCandidate)
+            selected.set(key, candidate);
+    }
+    return { candidates: [...selected.values()], suppressed };
+}
+async function existingEntityIds(context) {
+    if (!context.prolog)
+        return new Set();
+    try {
+        const entities = await loadEntities(context.prolog, {});
+        return new Set(entities.map((entity) => String(entity.id ?? "")).filter(Boolean));
+    }
+    catch {
+        return new Set();
+    }
+}
+// implements REQ-mcp-init-kibi-autopilot-v1, REQ-kibi-operation-interface-parity
+export async function executeAutopilotGenerate(args, context) {
+    const includeGenericMarkdown = args.includeGenericMarkdown ?? true;
+    const minConfidence = clamp(args.minConfidence ?? 0.8, 0.6, 0.95);
+    const maxCandidates = clamp(Math.trunc(args.maxCandidates ?? 50), 1, 200);
+    const [discovery, existingIds] = await Promise.all([
+        discoverAutopilot(context),
+        existingEntityIds(context),
+    ]);
+    const built = discovery.activation.allowCandidateGeneration
+        ? buildAutopilotCandidates(discovery.evidence, existingIds, minConfidence, includeGenericMarkdown)
+        : { candidates: [], sourceOnlySignals: [] };
+    const filteredSignals = args.entityTypes && args.entityTypes.length > 0
+        ? built.sourceOnlySignals.filter((signal) => args.entityTypes?.includes(signal.kind))
+        : built.sourceOnlySignals;
+    const selected = selectAutopilotCandidates(built.candidates.filter((candidate) => candidate.confidence >= minConfidence), existingIds, args.entityTypes, maxCandidates);
+    const ignored = discovery.ignoredSources.map((sourcePath) => ({
+        candidateId: "",
+        reason: "ignored_source",
+        sourcePath,
+        entityType: "",
+    }));
+    return presentAutopilot({
+        root: context.workspaceRoot,
+        activation: discovery.activation,
+        discoverySummary: discovery.summary,
+        migrationWarning: discovery.migrationWarning,
+        ...(args.bootstrapContext
+            ? { bootstrapContext: args.bootstrapContext }
+            : {}),
+        candidates: selected.candidates,
+        sourceOnlySignals: filteredSignals,
+        suppressedCandidates: [...selected.suppressed, ...ignored],
+    });
+}

package/dist/operations/autopilot/guidance-actions.d.ts

@@ -0,0 +1,3 @@
+import type { ActivationPolicy, AutopilotDeclaredContext, Candidate, SourceOnlySignal } from "./types.js";
+export declare function buildActions(root: string, activation: ActivationPolicy, declared: AutopilotDeclaredContext, candidates: readonly Candidate[], signals: readonly SourceOnlySignal[]): readonly Readonly<Record<string, unknown>>[];
+//# sourceMappingURL=guidance-actions.d.ts.map

package/dist/operations/autopilot/guidance-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guidance-actions.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/guidance-actions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAChB,wBAAwB,EACxB,SAAS,EACT,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAgBpB,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,gBAAgB,EAC5B,QAAQ,EAAE,wBAAwB,EAClC,UAAU,EAAE,SAAS,SAAS,EAAE,EAChC,OAAO,EAAE,SAAS,gBAAgB,EAAE,GACnC,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAuE9C"}

package/dist/operations/autopilot/guidance-actions.js

@@ -0,0 +1,79 @@
+import path from "node:path";
+function relative(root, target) {
+    const value = path.relative(root, target);
+    return value.startsWith("..") || path.isAbsolute(value)
+        ? target.split(path.sep).join("/")
+        : value.split(path.sep).join("/");
+}
+function summary(values, limit = 3) {
+    if (values.length === 0)
+        return "workspace evidence";
+    return values.length <= limit
+        ? values.join(", ")
+        : `${values.slice(0, limit).join(", ")} +${values.length - limit} more`;
+}
+export function buildActions(root, activation, declared, candidates, signals) {
+    const result = [];
+    let order = 1;
+    const targets = [
+        ...new Set([
+            ...declared.sourceOfTruthPaths,
+            ...declared.priorityRoots,
+            ...signals.map((signal) => relative(root, signal.sourcePath)),
+        ]),
+    ];
+    result.push({
+        order: order++,
+        kind: "query",
+        description: targets.length > 0
+            ? `Review ${summary(targets)} before authoring or applying bootstrap output.`
+            : "Review workspace evidence and existing KB records before applying bootstrap output.",
+    });
+    if (activation.activationMode === "attached_thin_handoff" ||
+        activation.activationMode === "attached_seeded_handoff") {
+        result.push({
+            order: order++,
+            kind: "handoff",
+            description: "Use kb_search to explore existing KB entities and understand current coverage.",
+        });
+        result.push({
+            order: order++,
+            kind: "handoff",
+            description: "Use kb_query or kb_graph with task-relevant IDs to inspect cited KB context.",
+        });
+        result.push({
+            order: order++,
+            kind: "handoff",
+            description: activation.activationMode === "attached_thin_handoff"
+                ? "Use kb_find_gaps to identify coverage holes and guide incremental KB growth."
+                : "Use kb_coverage to review traceability and identify areas needing attention.",
+        });
+    }
+    if (activation.applyBlocked)
+        result.push({
+            order: order++,
+            kind: "handoff",
+            description: activation.handoffMessage ?? activation.reason,
+        });
+    else if (candidates.length > 0)
+        result.push({
+            order: order++,
+            kind: "upsert",
+            description: `Review and optionally upsert ${candidates.length} safe candidate(s) from deterministic evidence.`,
+            candidateIds: candidates.map((candidate) => candidate.candidateId),
+        });
+    if (signals.length > 0)
+        result.push({
+            order: order++,
+            kind: "handoff",
+            description: `Author ${[...new Set(signals.map((signal) => signal.kind.toUpperCase()))].join("/")} entities manually from source-only evidence.`,
+        });
+    result.push({
+        order,
+        kind: "check",
+        description: declared.verificationAnchors.length > 0
+            ? `After approved kb_upsert calls, run kb_check and verify ${summary(declared.verificationAnchors, 2)}.`
+            : "After approved kb_upsert calls, run kb_check to validate the resulting graph.",
+    });
+    return result;
+}

package/dist/operations/autopilot/guidance.d.ts

@@ -0,0 +1,14 @@
+import type { ActivationPolicy, AutopilotDeclaredContext, Candidate, SourceOnlySignal } from "./types.js";
+export declare function buildGuidance(input: {
+    readonly root: string;
+    readonly activation: ActivationPolicy;
+    readonly declared: AutopilotDeclaredContext;
+    readonly candidates: readonly Candidate[];
+    readonly signals: readonly SourceOnlySignal[];
+    readonly warnings: readonly string[];
+}): {
+    readonly promptBlock: string;
+    readonly confidence: Readonly<Record<string, unknown>>;
+    readonly actions: readonly Readonly<Record<string, unknown>>[];
+};
+//# sourceMappingURL=guidance.d.ts.map

package/dist/operations/autopilot/guidance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guidance.d.ts","sourceRoot":"","sources":["../../../src/operations/autopilot/guidance.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,gBAAgB,EAChB,wBAAwB,EACxB,SAAS,EACT,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAyJpB,wBAAgB,aAAa,CAAC,KAAK,EAAE;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,CAAC;IAC5C,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC9C,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC,GAAG;IACF,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACvD,QAAQ,CAAC,OAAO,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;CAChE,CA0BA"}