@kaelio/ktx 0.4.0 → 0.5.0

package/node_modules/@ktx/context/dist/ingest/memory-flow/schema.d.ts

@@ -1,208 +0,0 @@
-import * as z from 'zod';
-import type { MemoryFlowReplayInput } from './types.js';
-export declare const memoryFlowRunStatusSchema: z.ZodEnum<{
-    error: "error";
-    done: "done";
-    running: "running";
-}>;
-export declare const memoryFlowEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"source_acquired">;
-    adapter: z.ZodString;
-    trigger: z.ZodString;
-    fileCount: z.ZodNumber;
-} & {
-    emittedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"scope_detected">;
-    fingerprint: z.ZodNullable<z.ZodString>;
-} & {
-    emittedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"raw_snapshot_written">;
-    syncId: z.ZodString;
-    rawFileCount: z.ZodNumber;
-} & {
-    emittedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"diff_computed">;
-    added: z.ZodNumber;
-    modified: z.ZodNumber;
-    deleted: z.ZodNumber;
-    unchanged: z.ZodNumber;
-} & {
-    emittedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"chunks_planned">;
-    chunkCount: z.ZodNumber;
-    workUnitCount: z.ZodNumber;
-    evictionCount: z.ZodNumber;
-} & {
-    emittedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"stage_skipped">;
-    stage: z.ZodEnum<{
-        source: "source";
-        workUnits: "workUnits";
-        chunks: "chunks";
-        actions: "actions";
-        gates: "gates";
-        saved: "saved";
-    }>;
-    reason: z.ZodString;
-} & {
-    emittedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"stage_progress">;
-    stage: z.ZodEnum<{
-        source: "source";
-        report: "report";
-        integration: "integration";
-        reconciliation: "reconciliation";
-        finalization: "finalization";
-        wiki_sl_ref_repair: "wiki_sl_ref_repair";
-        final_gates: "final_gates";
-        save: "save";
-        provenance: "provenance";
-    }>;
-    percent: z.ZodNumber;
-    message: z.ZodString;
-    transient: z.ZodOptional<z.ZodBoolean>;
-} & {
-    emittedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"work_unit_started">;
-    unitKey: z.ZodString;
-    skills: z.ZodArray<z.ZodString>;
-    stepBudget: z.ZodNumber;
-} & {
-    emittedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"work_unit_step">;
-    unitKey: z.ZodString;
-    stepIndex: z.ZodNumber;
-    stepBudget: z.ZodNumber;
-} & {
-    emittedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"candidate_action">;
-    unitKey: z.ZodString;
-    target: z.ZodEnum<{
-        wiki: "wiki";
-        sl: "sl";
-    }>;
-    action: z.ZodString;
-    key: z.ZodString;
-} & {
-    emittedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"work_unit_finished">;
-    unitKey: z.ZodString;
-    status: z.ZodEnum<{
-        success: "success";
-        failed: "failed";
-    }>;
-    reason: z.ZodOptional<z.ZodString>;
-} & {
-    emittedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"reconciliation_finished">;
-    conflictCount: z.ZodNumber;
-    fallbackCount: z.ZodNumber;
-} & {
-    emittedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"saved">;
-    commitSha: z.ZodNullable<z.ZodString>;
-    wikiCount: z.ZodNumber;
-    slCount: z.ZodNumber;
-} & {
-    emittedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"provenance_recorded">;
-    rowCount: z.ZodNumber;
-} & {
-    emittedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"report_created">;
-    runId: z.ZodString;
-    reportPath: z.ZodOptional<z.ZodString>;
-} & {
-    emittedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>], "type">;
-export declare const memoryFlowPlannedWorkUnitSchema: z.ZodObject<{
-    unitKey: z.ZodString;
-    rawFiles: z.ZodArray<z.ZodString>;
-    peerFileCount: z.ZodNumber;
-    dependencyCount: z.ZodNumber;
-}, z.core.$strip>;
-export declare const memoryFlowActionDetailSchema: z.ZodObject<{
-    unitKey: z.ZodString;
-    target: z.ZodEnum<{
-        wiki: "wiki";
-        sl: "sl";
-    }>;
-    action: z.ZodEnum<{
-        created: "created";
-        updated: "updated";
-        removed: "removed";
-    }>;
-    key: z.ZodString;
-    summary: z.ZodString;
-    rawFiles: z.ZodArray<z.ZodString>;
-    status: z.ZodEnum<{
-        success: "success";
-        failed: "failed";
-    }>;
-}, z.core.$strip>;
-export declare const memoryFlowDetailSectionsSchema: z.ZodObject<{
-    actions: z.ZodArray<z.ZodObject<{
-        unitKey: z.ZodString;
-        target: z.ZodEnum<{
-            wiki: "wiki";
-            sl: "sl";
-        }>;
-        action: z.ZodEnum<{
-            created: "created";
-            updated: "updated";
-            removed: "removed";
-        }>;
-        key: z.ZodString;
-        summary: z.ZodString;
-        rawFiles: z.ZodArray<z.ZodString>;
-        status: z.ZodEnum<{
-            success: "success";
-            failed: "failed";
-        }>;
-    }, z.core.$strip>>;
-    provenance: z.ZodArray<z.ZodObject<{
-        rawPath: z.ZodString;
-        artifactKind: z.ZodNullable<z.ZodEnum<{
-            wiki: "wiki";
-            sl: "sl";
-        }>>;
-        artifactKey: z.ZodNullable<z.ZodString>;
-        actionType: z.ZodString;
-    }, z.core.$strip>>;
-    transcripts: z.ZodArray<z.ZodObject<{
-        unitKey: z.ZodString;
-        path: z.ZodString;
-        toolCallCount: z.ZodNumber;
-        errorCount: z.ZodNumber;
-        toolNames: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const memoryFlowReplayInputSchema: z.ZodType<MemoryFlowReplayInput>;
-export declare const memoryFlowStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"snapshot">;
-    snapshot: z.ZodType<MemoryFlowReplayInput, unknown, z.core.$ZodTypeInternals<MemoryFlowReplayInput, unknown>>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"closed">;
-    status: z.ZodEnum<{
-        error: "error";
-        done: "done";
-        running: "running";
-    }>;
-    errors: z.ZodArray<z.ZodString>;
-}, z.core.$strip>], "type">;
-export type MemoryFlowStreamEvent = z.infer<typeof memoryFlowStreamEventSchema>;
-export declare function parseMemoryFlowReplayInput(value: unknown): MemoryFlowReplayInput;

package/node_modules/@ktx/context/dist/ingest/memory-flow/schema.js

@@ -1,172 +0,0 @@
-import * as z from 'zod';
-export const memoryFlowRunStatusSchema = z.enum(['running', 'done', 'error']);
-const memoryFlowEventTimestampShape = {
-    emittedAt: z.string().datetime().optional(),
-};
-function eventSchema(shape) {
-    return z.object({ ...shape, ...memoryFlowEventTimestampShape });
-}
-const memoryFlowReplayMetadataSchema = z.object({
-    schemaVersion: z.literal(1),
-    mode: z.enum(['full', 'deterministic', 'replay', 'seeded']),
-    origin: z.enum(['captured', 'packaged', 'synthetic-report']),
-    timing: z.enum(['captured', 'synthetic', 'not-captured', 'prebuilt']),
-    capturedAt: z.string().datetime().nullable(),
-    sourceReportId: z.string().min(1).nullable(),
-    sourceReportPath: z.string().min(1).nullable(),
-    fallbackReason: z.string().min(1).nullable(),
-});
-export const memoryFlowEventSchema = z.discriminatedUnion('type', [
-    eventSchema({
-        type: z.literal('source_acquired'),
-        adapter: z.string().min(1),
-        trigger: z.string().min(1),
-        fileCount: z.number().int().min(0),
-    }),
-    eventSchema({ type: z.literal('scope_detected'), fingerprint: z.string().nullable() }),
-    eventSchema({
-        type: z.literal('raw_snapshot_written'),
-        syncId: z.string().min(1),
-        rawFileCount: z.number().int().min(0),
-    }),
-    eventSchema({
-        type: z.literal('diff_computed'),
-        added: z.number().int().min(0),
-        modified: z.number().int().min(0),
-        deleted: z.number().int().min(0),
-        unchanged: z.number().int().min(0),
-    }),
-    eventSchema({
-        type: z.literal('chunks_planned'),
-        chunkCount: z.number().int().min(0),
-        workUnitCount: z.number().int().min(0),
-        evictionCount: z.number().int().min(0),
-    }),
-    eventSchema({
-        type: z.literal('stage_skipped'),
-        stage: z.enum(['source', 'chunks', 'workUnits', 'actions', 'gates', 'saved']),
-        reason: z.string().min(1),
-    }),
-    eventSchema({
-        type: z.literal('stage_progress'),
-        stage: z.enum([
-            'source',
-            'integration',
-            'reconciliation',
-            'finalization',
-            'wiki_sl_ref_repair',
-            'final_gates',
-            'save',
-            'provenance',
-            'report',
-        ]),
-        percent: z.number().min(0).max(100),
-        message: z.string().min(1),
-        transient: z.boolean().optional(),
-    }),
-    eventSchema({
-        type: z.literal('work_unit_started'),
-        unitKey: z.string().min(1),
-        skills: z.array(z.string().min(1)),
-        stepBudget: z.number().int().min(0),
-    }),
-    eventSchema({
-        type: z.literal('work_unit_step'),
-        unitKey: z.string().min(1),
-        stepIndex: z.number().int().min(0),
-        stepBudget: z.number().int().min(0),
-    }),
-    eventSchema({
-        type: z.literal('candidate_action'),
-        unitKey: z.string().min(1),
-        target: z.enum(['wiki', 'sl']),
-        action: z.string().min(1),
-        key: z.string().min(1),
-    }),
-    eventSchema({
-        type: z.literal('work_unit_finished'),
-        unitKey: z.string().min(1),
-        status: z.enum(['success', 'failed']),
-        reason: z.string().optional(),
-    }),
-    eventSchema({
-        type: z.literal('reconciliation_finished'),
-        conflictCount: z.number().int().min(0),
-        fallbackCount: z.number().int().min(0),
-    }),
-    eventSchema({
-        type: z.literal('saved'),
-        commitSha: z.string().nullable(),
-        wikiCount: z.number().int().min(0),
-        slCount: z.number().int().min(0),
-    }),
-    eventSchema({ type: z.literal('provenance_recorded'), rowCount: z.number().int().min(0) }),
-    eventSchema({
-        type: z.literal('report_created'),
-        runId: z.string().min(1),
-        reportPath: z.string().min(1).optional(),
-    }),
-]);
-export const memoryFlowPlannedWorkUnitSchema = z.object({
-    unitKey: z.string().min(1),
-    rawFiles: z.array(z.string()),
-    peerFileCount: z.number().int().min(0),
-    dependencyCount: z.number().int().min(0),
-});
-export const memoryFlowActionDetailSchema = z.object({
-    unitKey: z.string().min(1),
-    target: z.enum(['wiki', 'sl']),
-    action: z.enum(['created', 'updated', 'removed']),
-    key: z.string().min(1),
-    summary: z.string(),
-    rawFiles: z.array(z.string()),
-    status: z.enum(['success', 'failed']),
-});
-const memoryFlowProvenanceDetailSchema = z.object({
-    rawPath: z.string(),
-    artifactKind: z.enum(['sl', 'wiki']).nullable(),
-    artifactKey: z.string().nullable(),
-    actionType: z.string().min(1),
-});
-const memoryFlowTranscriptDetailSchema = z.object({
-    unitKey: z.string().min(1),
-    path: z.string().min(1),
-    toolCallCount: z.number().int().min(0),
-    errorCount: z.number().int().min(0),
-    toolNames: z.array(z.string()),
-});
-export const memoryFlowDetailSectionsSchema = z.object({
-    actions: z.array(memoryFlowActionDetailSchema),
-    provenance: z.array(memoryFlowProvenanceDetailSchema),
-    transcripts: z.array(memoryFlowTranscriptDetailSchema),
-});
-export const memoryFlowReplayInputSchema = z.object({
-    metadata: memoryFlowReplayMetadataSchema.optional(),
-    runId: z.string().min(1),
-    connectionId: z.string().min(1),
-    adapter: z.string().min(1),
-    status: memoryFlowRunStatusSchema,
-    sourceDir: z.string().nullable(),
-    syncId: z.string().min(1),
-    reportId: z.string().min(1).optional(),
-    reportPath: z.string().min(1).optional(),
-    errors: z.array(z.string()),
-    events: z.array(memoryFlowEventSchema),
-    plannedWorkUnits: z.array(memoryFlowPlannedWorkUnitSchema),
-    details: memoryFlowDetailSectionsSchema,
-});
-export const memoryFlowStreamEventSchema = z.discriminatedUnion('type', [
-    z.object({ type: z.literal('snapshot'), snapshot: memoryFlowReplayInputSchema }),
-    z.object({
-        type: z.literal('closed'),
-        status: memoryFlowRunStatusSchema,
-        errors: z.array(z.string()),
-    }),
-]);
-export function parseMemoryFlowReplayInput(value) {
-    const result = memoryFlowReplayInputSchema.safeParse(value);
-    if (!result.success) {
-        throw new Error(`Invalid memory-flow replay input: ${z.prettifyError(result.error)}`);
-    }
-    return result.data;
-}

package/node_modules/@ktx/context/dist/ingest/memory-flow/visuals.d.ts

@@ -1,20 +0,0 @@
-import type { MemoryFlowColumnId, MemoryFlowDisplayStatus, MemoryFlowViewModel } from './types.js';
-export interface MemoryFlowStatusBadge {
-    label: '..' | '>>' | 'OK' | '!!' | 'XX';
-    text: 'waiting' | 'active' | 'complete' | 'warning' | 'failed';
-}
-export interface MemoryFlowVisualColumn {
-    id: MemoryFlowColumnId;
-    title: string;
-    status: MemoryFlowDisplayStatus;
-    badge: MemoryFlowStatusBadge;
-    pulse: boolean;
-}
-export interface MemoryFlowVisualModel {
-    columns: MemoryFlowVisualColumn[];
-    connectorLine: string;
-    pulseColumnId: MemoryFlowColumnId;
-}
-export declare function memoryFlowStatusBadge(status: MemoryFlowDisplayStatus): MemoryFlowStatusBadge;
-export declare function buildMemoryFlowVisualModel(view: MemoryFlowViewModel): MemoryFlowVisualModel;
-export declare function renderMemoryFlowConnectorLine(view: MemoryFlowViewModel): string;

package/node_modules/@ktx/context/dist/ingest/memory-flow/visuals.js

@@ -1,44 +0,0 @@
-export function memoryFlowStatusBadge(status) {
-    if (status === 'active')
-        return { label: '>>', text: 'active' };
-    if (status === 'complete')
-        return { label: 'OK', text: 'complete' };
-    if (status === 'warning')
-        return { label: '!!', text: 'warning' };
-    if (status === 'failed')
-        return { label: 'XX', text: 'failed' };
-    return { label: '..', text: 'waiting' };
-}
-function firstColumnWithStatus(columns, status) {
-    return columns.find((column) => column.status === status);
-}
-function lastCompletedColumn(columns) {
-    return [...columns].reverse().find((column) => column.status === 'complete') ?? columns[0];
-}
-function selectPulseColumn(columns) {
-    return (firstColumnWithStatus(columns, 'active') ??
-        firstColumnWithStatus(columns, 'warning') ??
-        firstColumnWithStatus(columns, 'failed') ??
-        lastCompletedColumn(columns));
-}
-function renderColumn(column) {
-    return `${column.badge.label} ${column.title}`;
-}
-export function buildMemoryFlowVisualModel(view) {
-    const pulseColumn = selectPulseColumn(view.columns);
-    const columns = view.columns.map((column) => ({
-        id: column.id,
-        title: column.title,
-        status: column.status,
-        badge: memoryFlowStatusBadge(column.status),
-        pulse: column.id === pulseColumn.id,
-    }));
-    return {
-        columns,
-        connectorLine: columns.map(renderColumn).join(' -> '),
-        pulseColumnId: pulseColumn.id,
-    };
-}
-export function renderMemoryFlowConnectorLine(view) {
-    return buildMemoryFlowVisualModel(view).connectorLine;
-}

package/node_modules/@ktx/context/dist/ingest/metabase-mapping.d.ts

@@ -1,2 +0,0 @@
-export { computeMetabaseMappingDrift, computeMetabaseMappingPhysicalMismatches, discoverMetabaseDatabases, findBestMatch, METABASE_ENGINE_TO_CONNECTION_TYPE, refreshMetabaseMapping, validateMappingPhysicalMatch, validateMetabaseMappings, } from './adapters/metabase/mapping.js';
-export type { AutoMatchCandidate, AutoMatchResult as MetabaseAutoMatchResult, DiscoveredMetabaseDatabase, KtxConnectionPhysicalInfo, MappingPhysicalInfo, MappingRefreshReport, MetabaseMappedConnectionType, MetabaseMappingDrift, MetabaseMappingValidationResult, PhysicalMismatch, PhysicalMismatchInput, } from './adapters/metabase/mapping.js';

package/node_modules/@ktx/context/dist/ingest/metabase-mapping.js

@@ -1 +0,0 @@
-export { computeMetabaseMappingDrift, computeMetabaseMappingPhysicalMismatches, discoverMetabaseDatabases, findBestMatch, METABASE_ENGINE_TO_CONNECTION_TYPE, refreshMetabaseMapping, validateMappingPhysicalMatch, validateMetabaseMappings, } from './adapters/metabase/mapping.js';

package/node_modules/@ktx/context/dist/ingest/page-triage/index.d.ts

@@ -1,2 +0,0 @@
-export type { PageTriageEvidenceChunk, PageTriageReport, PageTriageRunArgs, PageTriageServiceDeps, PageTriageSettings, PageTriageStorePort, } from './page-triage.service.js';
-export { PageTriageService } from './page-triage.service.js';

package/node_modules/@ktx/context/dist/ingest/page-triage/index.js

@@ -1 +0,0 @@
-export { PageTriageService } from './page-triage.service.js';

package/node_modules/@ktx/context/dist/ingest/page-triage/page-triage.service.d.ts

@@ -1,84 +0,0 @@
-import { type KtxLogger } from '../../core/index.js';
-import type { KtxLlmRuntimePort } from '../../llm/index.js';
-import type { PromptService } from '../../prompts/index.js';
-import type { InsertContextCandidateInput } from '../context-candidates/index.js';
-import type { JsonValue } from '../ports.js';
-import type { DiffSet, SourceAdapter, TriageLane } from '../types.js';
-export interface PageTriageReport {
-    pageCount: number;
-    skip: number;
-    light: number;
-    full: number;
-    classifierFailures: number;
-    lightExtractionFailures: number;
-}
-interface PageTriageRunResult {
-    enabled: boolean;
-    report?: PageTriageReport;
-    fullRawPaths: Set<string>;
-    warnings: string[];
-}
-export interface PageTriageRunArgs {
-    stagedDir: string;
-    runId: string;
-    connectionId: string;
-    sourceKey: string;
-    syncId: string;
-    jobId: string;
-    diffSet: DiffSet;
-    adapter: Pick<SourceAdapter, 'triageSupported' | 'getTriageSignals'>;
-}
-export interface PageTriageEvidenceChunk {
-    chunkId: string;
-    headingPath: string[];
-    ordinal: number;
-    content: string;
-    stableCitationKey: string;
-    citation: JsonValue;
-    rawPath: string;
-    title: string;
-    path: string;
-    url: string | null;
-    lastEditedAt: Date | null;
-}
-export interface PageTriageStorePort {
-    setDocumentTriageLane(runId: string, rawPath: string, lane: TriageLane): Promise<number>;
-    listDocumentChunksForLightExtraction(runId: string, rawPath: string): Promise<PageTriageEvidenceChunk[]>;
-    insertCandidate(input: InsertContextCandidateInput): Promise<unknown>;
-}
-export interface PageTriageSettings {
-    enabled: boolean;
-    maxConcurrency: number;
-    lightExtractionEnabled: boolean;
-    classifierModel: string | null;
-    lightExtractionMaxCandidates: number;
-}
-export interface PageTriageServiceDeps {
-    store: PageTriageStorePort;
-    llmRuntime: KtxLlmRuntimePort;
-    settings: PageTriageSettings;
-    promptService: PromptService;
-    logger?: KtxLogger;
-}
-export declare class PageTriageService {
-    private readonly deps;
-    private readonly logger;
-    constructor(deps: PageTriageServiceDeps);
-    triageRun(args: PageTriageRunArgs): Promise<PageTriageRunResult>;
-    private triageDocument;
-    private getSignals;
-    private extractLightCandidates;
-    private validEvidenceChunkIds;
-    private evidenceRefs;
-    private syncIdFromCitation;
-    private callModel;
-    private buildClassifierSystem;
-    private buildClassifierUser;
-    private buildLightExtractionSystem;
-    private buildLightExtractionUser;
-    private parseJson;
-    private stableCandidateKey;
-    private collectChangedDocuments;
-    private toRawPath;
-}
-export {};