@oscharko-dev/keiko-server 0.2.0

package/dist/editor/languageRoutes.js

@@ -0,0 +1,106 @@
+// BFF routes for the deterministic language service (Issue #1198, ADR-0042 D4). `POST
+// /api/editor/language` runs one governed, model-free operation (diagnostics, completion, hover, or
+// symbols) over an in-editor overlay; `GET /api/editor/language/capabilities` advertises the
+// registered providers so the editor can feature-detect. Workspace-root containment reuses the same
+// realpath + deny-list resolution as the files routes (`resolveRoot`), and the overlay path is
+// proven contained before any analysis runs. The success payload is redacted (D9) and the body is
+// already length-capped and control-character-stripped by the orchestrator.
+import { isAbsolute, resolve } from "node:path";
+import { DEFAULT_LANGUAGE_SERVICE_LIMITS, parseLanguageServiceRequest, } from "@oscharko-dev/keiko-contracts";
+import { containedRealPathInfo } from "@oscharko-dev/keiko-workspace";
+import { nodeWorkspaceFs } from "@oscharko-dev/keiko-workspace/internal/fs";
+import { errorBody } from "../routes.js";
+import { FilesError, readJsonObject, resolveRoot, runFilesHandler } from "../files.js";
+import { DENIED_MESSAGE, pathIsDenied } from "../files-deny.js";
+import { describeLanguageCapabilities, runLanguageOperation } from "./languageService.js";
+// The overlay buffer may be up to the document-size cap; allow 64 KiB of JSON envelope on top.
+const MAX_LANGUAGE_BODY_BYTES = DEFAULT_LANGUAGE_SERVICE_LIMITS.maxDocumentBytes + 64 * 1024;
+// Exported for reuse by the completion route (#1199), which maps the same deterministic
+// language-service error codes to HTTP status.
+export const STATUS_BY_CODE = {
+    INVALID_REQUEST: 400,
+    UNSUPPORTED_LANGUAGE: 422,
+    UNSUPPORTED_OPERATION: 422,
+    DOCUMENT_TOO_LARGE: 413,
+    DENIED: 403,
+    TIMED_OUT: 503,
+    CANCELLED: 499,
+};
+function denied() {
+    return new FilesError(403, "DENIED", DENIED_MESSAGE);
+}
+function isRouteResult(value) {
+    return typeof value === "object" && value !== null && "status" in value && "body" in value;
+}
+// Resolves the overlay's absolute path and proves it is contained in the workspace root. An absolute
+// or escaping path, a symlink that escapes, or a denied segment (.git/.ssh/credentials) is rejected
+// before any file is read. Exported for reuse by the completion route (#1199).
+export function resolveOverlayPath(realRoot, relativePath) {
+    if (isAbsolute(relativePath) || pathIsDenied(relativePath)) {
+        throw denied();
+    }
+    const overlayAbsolute = resolve(realRoot, relativePath);
+    try {
+        containedRealPathInfo(nodeWorkspaceFs, realRoot, overlayAbsolute);
+    }
+    catch {
+        throw denied();
+    }
+    return overlayAbsolute;
+}
+// Exported for reuse by the completion route (#1199): aborts in-flight analysis when the client
+// disconnects.
+export function clientAbortSignal(ctx) {
+    const controller = new AbortController();
+    ctx.req.on("close", () => {
+        controller.abort();
+    });
+    if (typeof ctx.res.on === "function") {
+        ctx.res.on("close", () => {
+            if (!ctx.res.writableEnded) {
+                controller.abort();
+            }
+        });
+    }
+    return controller.signal;
+}
+function successBody(outcome) {
+    return { operation: outcome.kind, result: outcome.result };
+}
+function outcomeToResult(outcome, deps) {
+    if (outcome.kind === "error") {
+        return { status: STATUS_BY_CODE[outcome.code], body: errorBody(outcome.code, outcome.message) };
+    }
+    const body = successBody(outcome);
+    // Formatting edits are applied to the user's buffer, not displayed. Redacting the success envelope
+    // would mutate secret-shaped string literals in valid format edits; the formatter result was
+    // already capped by `sanitizeFormatting`, and the route never logs it.
+    return { status: 200, body: outcome.kind === "formatting" ? body : deps.redactor(body) };
+}
+export async function handleEditorLanguage(ctx, deps, options = {}) {
+    const body = await readJsonObject(ctx.req, MAX_LANGUAGE_BODY_BYTES);
+    if (isRouteResult(body)) {
+        return body;
+    }
+    const parsed = parseLanguageServiceRequest(body);
+    if (!parsed.ok) {
+        return { status: 400, body: errorBody("INVALID_REQUEST", parsed.errors.join("; ")) };
+    }
+    const request = parsed.value;
+    return runFilesHandler(async () => {
+        const root = await resolveRoot(deps.store, request.root, deps.redactor);
+        const overlayAbsolutePath = resolveOverlayPath(root.realRoot, request.document.path);
+        const outcome = runLanguageOperation(request, {
+            fs: nodeWorkspaceFs,
+            realRoot: root.realRoot,
+            overlayAbsolutePath,
+            signal: clientAbortSignal(ctx),
+            limits: options.limits,
+            now: options.now,
+        });
+        return outcomeToResult(outcome, deps);
+    });
+}
+export function handleEditorLanguageCapabilities() {
+    return { status: 200, body: describeLanguageCapabilities() };
+}

package/dist/editor/languageSanitize.d.ts

@@ -0,0 +1,8 @@
+import type { LanguageCompletionResult, LanguageDiagnosticsResult, LanguageFormattingResult, LanguageHoverResult, LanguageServiceLimits, LanguageSymbolResult } from "@oscharko-dev/keiko-contracts";
+import type { LanguageDiagnosticsRaw, LanguageFormattingRaw, LanguageSymbolsRaw } from "./languageProvider.js";
+export declare function sanitizeDiagnostics(raw: LanguageDiagnosticsRaw, limits: LanguageServiceLimits): LanguageDiagnosticsResult;
+export declare function sanitizeCompletion(result: LanguageCompletionResult, limits: LanguageServiceLimits): LanguageCompletionResult;
+export declare function sanitizeHover(result: LanguageHoverResult, limits: LanguageServiceLimits): LanguageHoverResult;
+export declare function sanitizeSymbols(raw: LanguageSymbolsRaw, limits: LanguageServiceLimits): LanguageSymbolResult;
+export declare function sanitizeFormatting(raw: LanguageFormattingRaw, limits: LanguageServiceLimits): LanguageFormattingResult;
+//# sourceMappingURL=languageSanitize.d.ts.map

package/dist/editor/languageSanitize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"languageSanitize.d.ts","sourceRoot":"","sources":["../../src/editor/languageSanitize.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAEV,wBAAwB,EAExB,yBAAyB,EAEzB,wBAAwB,EACxB,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EACV,sBAAsB,EACtB,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAoB/B,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,sBAAsB,EAC3B,MAAM,EAAE,qBAAqB,GAC5B,yBAAyB,CAM3B;AAsBD,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,wBAAwB,EAChC,MAAM,EAAE,qBAAqB,GAC5B,wBAAwB,CAO1B;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,mBAAmB,EAC3B,MAAM,EAAE,qBAAqB,GAC5B,mBAAmB,CAMrB;AAiBD,wBAAgB,eAAe,CAC7B,GAAG,EAAE,kBAAkB,EACvB,MAAM,EAAE,qBAAqB,GAC5B,oBAAoB,CAMtB;AAQD,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,qBAAqB,EAC1B,MAAM,EAAE,qBAAqB,GAC5B,wBAAwB,CAmB1B"}

package/dist/editor/languageSanitize.js

@@ -0,0 +1,101 @@
+// Browser-display sanitisation for language-service results (Issue #1198 AC: "results are capped and
+// sanitized for browser display"). Every string that crosses to the browser is stripped of bidi,
+// zero-width, and control characters (reusing the contracts text-safety primitive) and clipped to
+// the per-field length cap, so a hostile or pathological buffer cannot smuggle terminal escapes,
+// direction overrides, or unbounded payloads into the editor. Redaction of secret-shaped strings is
+// applied separately by the BFF live-payload redactor.
+import { stripUnsafeFormatChars } from "@oscharko-dev/keiko-contracts/text-safety";
+function clip(value, max) {
+    const safe = stripUnsafeFormatChars(value);
+    return safe.length > max ? safe.slice(0, max) : safe;
+}
+function sanitizeDiagnostic(diagnostic, limits) {
+    return {
+        range: diagnostic.range,
+        severity: diagnostic.severity,
+        message: clip(diagnostic.message, limits.maxMessageChars),
+        source: clip(diagnostic.source, limits.maxLabelChars),
+        ...(diagnostic.code !== undefined ? { code: clip(diagnostic.code, limits.maxLabelChars) } : {}),
+    };
+}
+export function sanitizeDiagnostics(raw, limits) {
+    const capped = raw.diagnostics.slice(0, limits.maxDiagnostics);
+    return {
+        diagnostics: capped.map((diagnostic) => sanitizeDiagnostic(diagnostic, limits)),
+        truncated: raw.truncated || raw.diagnostics.length > capped.length,
+    };
+}
+function sanitizeCompletionItem(item, limits) {
+    return {
+        label: clip(item.label, limits.maxLabelChars),
+        kind: item.kind,
+        ...(item.detail !== undefined ? { detail: clip(item.detail, limits.maxDetailChars) } : {}),
+        ...(item.documentation !== undefined
+            ? { documentation: clip(item.documentation, limits.maxDocumentationChars) }
+            : {}),
+        // insertText can carry a full snippet (for example an auto-import edit), so it uses the more
+        // permissive detail cap rather than the short label cap.
+        ...(item.insertText !== undefined
+            ? { insertText: clip(item.insertText, limits.maxDetailChars) }
+            : {}),
+        ...(item.sortText !== undefined ? { sortText: clip(item.sortText, limits.maxLabelChars) } : {}),
+    };
+}
+export function sanitizeCompletion(result, limits) {
+    const capped = result.items.slice(0, limits.maxCompletionItems);
+    return {
+        items: capped.map((item) => sanitizeCompletionItem(item, limits)),
+        isIncomplete: result.isIncomplete,
+        truncated: result.truncated || result.items.length > capped.length,
+    };
+}
+export function sanitizeHover(result, limits) {
+    const contents = result.contents === null ? null : clip(result.contents, limits.maxHoverChars);
+    return {
+        contents,
+        ...(result.range !== undefined ? { range: result.range } : {}),
+    };
+}
+function sanitizeSymbol(symbol, limits) {
+    return {
+        name: clip(symbol.name, limits.maxLabelChars),
+        kind: symbol.kind,
+        range: symbol.range,
+        ...(symbol.detail !== undefined ? { detail: clip(symbol.detail, limits.maxDetailChars) } : {}),
+        ...(symbol.containerName !== undefined
+            ? { containerName: clip(symbol.containerName, limits.maxLabelChars) }
+            : {}),
+    };
+}
+export function sanitizeSymbols(raw, limits) {
+    const capped = raw.symbols.slice(0, limits.maxSymbols);
+    return {
+        symbols: capped.map((symbol) => sanitizeSymbol(symbol, limits)),
+        truncated: raw.truncated || raw.symbols.length > capped.length,
+    };
+}
+// Formatting edits are APPLIED to the buffer, not rendered, so — unlike the display surfaces above —
+// their `newText` is left byte-faithful: stripping format characters would silently mutate the
+// user's own code (for example characters inside a string literal) when they format. The bounds are
+// the edit-count cap plus defensive per-edit and aggregate byte ceilings (the document-size
+// envelope); over-budget edits are dropped rather than clipped, since clipping a reformat edit would
+// corrupt the buffer, and the edits are non-overlapping so dropping one leaves the rest valid.
+export function sanitizeFormatting(raw, limits) {
+    const capped = raw.edits.slice(0, limits.maxFormattingEdits);
+    // Measure UTF-8 bytes so the per-edit ceiling matches the `maxDocumentBytes` byte budget rather
+    // than UTF-16 code units (which would under-count multi-byte content).
+    const withinLength = [];
+    let totalBytes = 0;
+    for (const edit of capped) {
+        const byteLength = Buffer.byteLength(edit.newText, "utf8");
+        if (byteLength > limits.maxDocumentBytes || totalBytes + byteLength > limits.maxDocumentBytes) {
+            continue;
+        }
+        withinLength.push(edit);
+        totalBytes += byteLength;
+    }
+    return {
+        edits: withinLength,
+        truncated: raw.truncated || raw.edits.length > capped.length || withinLength.length < capped.length,
+    };
+}

package/dist/editor/languageService.d.ts

@@ -0,0 +1,36 @@
+import { type LanguageCompletionResult, type LanguageDiagnosticsResult, type LanguageFormattingResult, type LanguageHoverResult, type LanguageServiceCapabilities, type LanguageServiceErrorCode, type LanguageServiceLimits, type LanguageServiceRequest, type LanguageSymbolResult } from "@oscharko-dev/keiko-contracts";
+import type { WorkspaceFs } from "@oscharko-dev/keiko-workspace";
+import { type LanguageProviderRegistry } from "./languageProvider.js";
+export declare function languageServiceRegistry(): LanguageProviderRegistry;
+export declare function describeLanguageCapabilities(registry?: LanguageProviderRegistry): LanguageServiceCapabilities;
+export type LanguageServiceOutcome = {
+    readonly kind: "diagnostics";
+    readonly result: LanguageDiagnosticsResult;
+} | {
+    readonly kind: "completion";
+    readonly result: LanguageCompletionResult;
+} | {
+    readonly kind: "hover";
+    readonly result: LanguageHoverResult;
+} | {
+    readonly kind: "symbols";
+    readonly result: LanguageSymbolResult;
+} | {
+    readonly kind: "formatting";
+    readonly result: LanguageFormattingResult;
+} | {
+    readonly kind: "error";
+    readonly code: LanguageServiceErrorCode;
+    readonly message: string;
+};
+export interface RunLanguageOperationOptions {
+    readonly fs: WorkspaceFs;
+    readonly realRoot: string;
+    readonly overlayAbsolutePath: string;
+    readonly limits?: LanguageServiceLimits | undefined;
+    readonly signal?: AbortSignal | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly registry?: LanguageProviderRegistry | undefined;
+}
+export declare function runLanguageOperation(request: LanguageServiceRequest, options: RunLanguageOperationOptions): LanguageServiceOutcome;
+//# sourceMappingURL=languageService.d.ts.map

package/dist/editor/languageService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"languageService.d.ts","sourceRoot":"","sources":["../../src/editor/languageService.ts"],"names":[],"mappings":"AAOA,OAAO,EAEL,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACxB,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EAE1B,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAEjE,OAAO,EAIL,KAAK,wBAAwB,EAC9B,MAAM,uBAAuB,CAAC;AAsB/B,wBAAgB,uBAAuB,IAAI,wBAAwB,CAElE;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,GAAE,wBAA0C,GACnD,2BAA2B,CAK7B;AAED,MAAM,MAAM,sBAAsB,GAC9B;IAAE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,yBAAyB,CAAA;CAAE,GAC5E;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAA;CAAE,GAC1E;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAA;CAAE,GAChE;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAA;CAAE,GACnE;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAA;CAAE,GAC1E;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAElG,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC;IAEzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,SAAS,CAAC;IACpD,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,QAAQ,CAAC,EAAE,wBAAwB,GAAG,SAAS,CAAC;CAC1D;AAsCD,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,sBAAsB,EAC/B,OAAO,EAAE,2BAA2B,GACnC,sBAAsB,CAsCxB"}

package/dist/editor/languageService.js

@@ -0,0 +1,93 @@
+// The deterministic language-service orchestrator (Issue #1198, ADR-0042 D4). It is the single
+// governed, model-free entry point: it resolves the request's language to a provider, enforces the
+// document-size and wall-clock bounds, runs the requested operation under a deadline/abort
+// cancellation token, and sanitises every result for browser display. It never calls a model and
+// never routes through the Model Gateway. Provider registration is the only thing that changes to
+// add a language (#1213), so this orchestrator stays language-agnostic.
+import { DEFAULT_LANGUAGE_SERVICE_LIMITS, LANGUAGE_SERVICE_SCHEMA_VERSION, } from "@oscharko-dev/keiko-contracts";
+import { createDeadlineCancellation, isCancellation } from "./languageCancellation.js";
+import { createLanguageProviderRegistry, } from "./languageProvider.js";
+import { createTypescriptLanguageProvider } from "./typescriptLanguageProvider.js";
+import { createBuiltinTextLanguageProvider, createJsonLanguageProvider, unavailableExternalLspDescriptors, } from "./builtinLanguageProviders.js";
+import { sanitizeCompletion, sanitizeDiagnostics, sanitizeFormatting, sanitizeHover, sanitizeSymbols, } from "./languageSanitize.js";
+// Providers are stateless and deterministic, so a single shared instance is safe. External LSP
+// descriptors are advertised as unavailable until a workspace-contained executable is configured.
+const defaultRegistry = createLanguageProviderRegistry([createTypescriptLanguageProvider(), createJsonLanguageProvider(), createBuiltinTextLanguageProvider()], unavailableExternalLspDescriptors());
+export function languageServiceRegistry() {
+    return defaultRegistry;
+}
+export function describeLanguageCapabilities(registry = defaultRegistry) {
+    return {
+        schemaVersion: LANGUAGE_SERVICE_SCHEMA_VERSION,
+        providers: registry.describe(),
+    };
+}
+function errorOutcome(code, message) {
+    return { kind: "error", code, message };
+}
+function runOperation(request, provider, ctx, limits) {
+    switch (request.operation) {
+        case "diagnostics":
+            return {
+                kind: "diagnostics",
+                result: sanitizeDiagnostics(provider.getDiagnostics(ctx), limits),
+            };
+        case "completion":
+            return {
+                kind: "completion",
+                result: sanitizeCompletion(provider.getCompletions(ctx, request.position), limits),
+            };
+        case "hover":
+            return {
+                kind: "hover",
+                result: sanitizeHover(provider.getHover(ctx, request.position), limits),
+            };
+        case "symbols":
+            return { kind: "symbols", result: sanitizeSymbols(provider.getSymbols(ctx), limits) };
+        case "formatting":
+            return {
+                kind: "formatting",
+                result: sanitizeFormatting(provider.getFormatting(ctx, request.options), limits),
+            };
+    }
+}
+export function runLanguageOperation(request, options) {
+    const limits = options.limits ?? DEFAULT_LANGUAGE_SERVICE_LIMITS;
+    const registry = options.registry ?? defaultRegistry;
+    if (Buffer.byteLength(request.document.text, "utf8") > limits.maxDocumentBytes) {
+        return errorOutcome("DOCUMENT_TOO_LARGE", "The document exceeds the analysis size limit.");
+    }
+    const provider = registry.resolve(request.document.languageId);
+    if (provider === undefined) {
+        return errorOutcome("UNSUPPORTED_LANGUAGE", "No deterministic provider serves this language.");
+    }
+    if (!provider.descriptor.operations.includes(request.operation)) {
+        return errorOutcome("UNSUPPORTED_OPERATION", "The provider does not serve this operation.");
+    }
+    const cancellation = createDeadlineCancellation({
+        signal: options.signal,
+        deadlineMs: limits.deadlineMs,
+        now: options.now,
+    });
+    const ctx = {
+        fs: options.fs,
+        root: options.realRoot,
+        overlayPath: options.overlayAbsolutePath,
+        overlayText: request.document.text,
+        languageId: request.document.languageId,
+        limits,
+        cancellation,
+    };
+    try {
+        cancellation.throwIfCancellationRequested();
+        return runOperation(request, provider, ctx, limits);
+    }
+    catch (error) {
+        if (isCancellation(error)) {
+            return cancellation.reason() === "timeout"
+                ? errorOutcome("TIMED_OUT", "Analysis exceeded the time budget.")
+                : errorOutcome("CANCELLED", "The request was cancelled.");
+        }
+        throw error;
+    }
+}

package/dist/editor/languageServiceHost.d.ts

@@ -0,0 +1,14 @@
+import { type LanguageServiceLimits } from "@oscharko-dev/keiko-contracts";
+import type { WorkspaceFs } from "@oscharko-dev/keiko-workspace";
+import ts from "typescript";
+export interface ContainedHostOptions {
+    readonly fs: WorkspaceFs;
+    readonly realRoot: string;
+    readonly overlayPath: string;
+    readonly overlayText: string;
+    readonly languageId: string;
+    readonly cancellation: ts.HostCancellationToken;
+    readonly limits?: LanguageServiceLimits | undefined;
+}
+export declare function createContainedLanguageServiceHost(options: ContainedHostOptions): ts.LanguageServiceHost;
+//# sourceMappingURL=languageServiceHost.d.ts.map

package/dist/editor/languageServiceHost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"languageServiceHost.d.ts","sourceRoot":"","sources":["../../src/editor/languageServiceHost.ts"],"names":[],"mappings":"AAUA,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,WAAW,EAAiB,MAAM,+BAA+B,CAAC;AAEhF,OAAO,EAAE,MAAM,YAAY,CAAC;AAG5B,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,EAAE,CAAC,qBAAqB,CAAC;IAChD,QAAQ,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,SAAS,CAAC;CACrD;AAgPD,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,oBAAoB,GAC5B,EAAE,CAAC,mBAAmB,CAiDxB"}

package/dist/editor/languageServiceHost.js

@@ -0,0 +1,242 @@
+// A workspace-contained TypeScript LanguageServiceHost (Issue #1198, ADR-0042 D4). Every file the
+// language service reads is forced through one of three gates: (1) the in-memory overlay buffer for
+// the document under analysis, (2) the TypeScript compiler's own default-library directory (its
+// runtime lib.*.d.ts, which is not workspace content), or (3) the audited WorkspaceFs port behind a
+// realpath containment check, so the language service can never read a path outside the registered
+// workspace root — including via a symlink. tsconfig discovery resolves the nearest config inside
+// the root and follows `extends` through the same gate; it never enumerates the whole project.
+import { Buffer } from "node:buffer";
+import { dirname, resolve } from "node:path";
+import { DEFAULT_LANGUAGE_SERVICE_LIMITS, } from "@oscharko-dev/keiko-contracts";
+import { containedRealPathInfo } from "@oscharko-dev/keiko-workspace";
+import ts from "typescript";
+import { pathIsDenied } from "../files-deny.js";
+function normalizeSlashes(value) {
+    return value.replace(/\\/g, "/");
+}
+// True when `fileName` is the TypeScript compiler's own default-library directory or a file inside
+// it. The path is resolved first so a `..`-bearing path (for example `<libDir>/../../etc/passwd`)
+// can never masquerade as a lib path via a raw prefix match and bypass workspace containment.
+function isWithinLibDir(libDir, fileName) {
+    const normalized = normalizeSlashes(resolve(fileName));
+    return normalized === libDir || normalized.startsWith(`${libDir}/`);
+}
+const CASE_SENSITIVE = ts.sys.useCaseSensitiveFileNames;
+function defaultCompilerOptions() {
+    return {
+        allowJs: true,
+        checkJs: false,
+        jsx: ts.JsxEmit.ReactJSX,
+        target: ts.ScriptTarget.ES2022,
+        module: ts.ModuleKind.ESNext,
+        moduleResolution: ts.ModuleResolutionKind.Bundler,
+        lib: ["lib.es2022.full.d.ts"],
+        allowNonTsExtensions: true,
+        allowImportingTsExtensions: true,
+        noEmit: true,
+        skipLibCheck: true,
+        skipDefaultLibCheck: true,
+        strict: false,
+    };
+}
+function throwIfLanguageServiceCancelled(cancellation) {
+    if (!cancellation.isCancellationRequested())
+        return;
+    // TypeScript catches this exact class while cancelling language-service work.
+    // eslint-disable-next-line @typescript-eslint/only-throw-error
+    throw new ts.OperationCanceledException();
+}
+function cacheContainedReal(state, key, value) {
+    state.containedRealCache.set(key, value);
+    return value;
+}
+function resolveContainedReal(state, fileName) {
+    throwIfLanguageServiceCancelled(state.cancellation);
+    const key = normalizeSlashes(resolve(fileName));
+    if (state.containedRealCache.has(key)) {
+        return state.containedRealCache.get(key);
+    }
+    if (state.workspacePathProbes >= state.limits.maxWorkspaceReadFiles) {
+        return cacheContainedReal(state, key, undefined);
+    }
+    state.workspacePathProbes += 1;
+    try {
+        const info = containedRealPathInfo(state.fs, state.realRoot, fileName);
+        return cacheContainedReal(state, key, pathIsDenied(info.realRelative) ? undefined : info.path);
+    }
+    catch {
+        return cacheContainedReal(state, key, undefined);
+    }
+}
+function workspaceReadAllowedByStat(state, stat) {
+    return (stat.isFile &&
+        stat.size <= state.limits.maxWorkspaceReadFileBytes &&
+        state.workspaceReadFiles < state.limits.maxWorkspaceReadFiles &&
+        state.workspaceReadBytes + stat.size <= state.limits.maxWorkspaceReadBytes);
+}
+function readBoundedWorkspaceFile(state, real) {
+    const cached = state.workspaceReadCache.get(real);
+    if (cached !== undefined)
+        return cached;
+    throwIfLanguageServiceCancelled(state.cancellation);
+    let stat;
+    try {
+        stat = state.fs.stat(real);
+    }
+    catch {
+        return undefined;
+    }
+    if (!workspaceReadAllowedByStat(state, stat))
+        return undefined;
+    let content;
+    try {
+        content = state.fs.readFileUtf8(real);
+    }
+    catch {
+        return undefined;
+    }
+    const bytes = Buffer.byteLength(content, "utf8");
+    if (bytes > state.limits.maxWorkspaceReadFileBytes)
+        return undefined;
+    if (state.workspaceReadBytes + bytes > state.limits.maxWorkspaceReadBytes)
+        return undefined;
+    state.workspaceReadFiles += 1;
+    state.workspaceReadBytes += bytes;
+    state.workspaceReadCache.set(real, content);
+    return content;
+}
+// Builds a containment-aware reader closure set shared by the config parser and the host. A path is
+// readable only if it is the overlay, a compiler lib file, or contained inside the workspace root.
+function createContainedReaders(fs, realRoot, overlayPath, overlayText, libDir, cancellation, limits) {
+    const overlay = normalizeSlashes(overlayPath);
+    const isLibPath = (fileName) => isWithinLibDir(libDir, fileName);
+    const state = {
+        fs,
+        realRoot,
+        libDir,
+        cancellation,
+        limits,
+        containedRealCache: new Map(),
+        workspaceReadCache: new Map(),
+        workspacePathProbes: 0,
+        workspaceReadBytes: 0,
+        workspaceReadFiles: 0,
+    };
+    const containedReal = (fileName) => resolveContainedReal(state, fileName);
+    const readFile = (fileName) => {
+        throwIfLanguageServiceCancelled(cancellation);
+        if (normalizeSlashes(fileName) === overlay)
+            return overlayText;
+        if (isLibPath(fileName)) {
+            try {
+                return fs.readFileUtf8(fileName);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        const real = containedReal(fileName);
+        if (real === undefined)
+            return undefined;
+        return readBoundedWorkspaceFile(state, real);
+    };
+    const fileExists = (fileName) => {
+        throwIfLanguageServiceCancelled(cancellation);
+        if (normalizeSlashes(fileName) === overlay)
+            return true;
+        if (isLibPath(fileName))
+            return fs.exists(fileName);
+        const real = containedReal(fileName);
+        return real !== undefined && fs.exists(real);
+    };
+    return { readFile, fileExists, containedReal };
+}
+// Resolves the compiler options for the overlay: the nearest tsconfig inside the root (following
+// `extends` through the contained reader, never enumerating files) merged over safe defaults.
+function resolveCompilerOptions(fs, realRoot, overlayPath, readers) {
+    const defaults = defaultCompilerOptions();
+    const configPath = ts.findConfigFile(dirname(overlayPath), readers.fileExists, "tsconfig.json");
+    if (configPath === undefined || readers.containedReal(configPath) === undefined) {
+        return defaults;
+    }
+    const configFile = ts.readConfigFile(configPath, (path) => readers.readFile(path));
+    if (configFile.error !== undefined || typeof configFile.config !== "object") {
+        return defaults;
+    }
+    const parseHost = {
+        useCaseSensitiveFileNames: CASE_SENSITIVE,
+        // Only the options matter for single-document analysis; never enumerate the project.
+        readDirectory: () => [],
+        fileExists: readers.fileExists,
+        readFile: readers.readFile,
+    };
+    const parsed = ts.parseJsonConfigFileContent(configFile.config, parseHost, dirname(configPath));
+    return {
+        ...defaults,
+        ...parsed.options,
+        allowJs: true,
+        allowNonTsExtensions: true,
+        noEmit: true,
+    };
+}
+function containedDirectoryExists(fs, readers, libDir, directory) {
+    if (isWithinLibDir(libDir, directory))
+        return fs.exists(directory);
+    const real = readers.containedReal(directory);
+    return real !== undefined && fs.exists(real);
+}
+function containedDirectories(fs, readers, libDir, limits, directory) {
+    // The compiler's own lib directory enumerates directly; everything else goes through the
+    // realpath containment gate, mirroring containedDirectoryExists so the two never diverge.
+    const real = isWithinLibDir(libDir, directory) ? directory : readers.containedReal(directory);
+    if (real === undefined)
+        return [];
+    try {
+        return fs
+            .readDir(real)
+            .filter((entry) => entry.isDirectory)
+            .slice(0, limits.maxWorkspaceReadFiles)
+            .map((entry) => resolve(real, entry.name));
+    }
+    catch {
+        return [];
+    }
+}
+export function createContainedLanguageServiceHost(options) {
+    const { fs, realRoot, overlayPath, overlayText, cancellation } = options;
+    const limits = options.limits ?? DEFAULT_LANGUAGE_SERVICE_LIMITS;
+    const libDir = normalizeSlashes(dirname(ts.getDefaultLibFilePath(defaultCompilerOptions())));
+    const readers = createContainedReaders(fs, realRoot, overlayPath, overlayText, libDir, cancellation, limits);
+    const compilerOptions = resolveCompilerOptions(fs, realRoot, overlayPath, readers);
+    const overlay = normalizeSlashes(overlayPath);
+    return {
+        getCompilationSettings: () => compilerOptions,
+        getScriptFileNames: () => [overlayPath],
+        getScriptVersion: (fileName) => normalizeSlashes(fileName) === overlay ? "overlay" : "0",
+        getScriptSnapshot: (fileName) => {
+            const content = readers.readFile(fileName);
+            return content === undefined ? undefined : ts.ScriptSnapshot.fromString(content);
+        },
+        getCurrentDirectory: () => realRoot,
+        getDefaultLibFileName: (compilerOpts) => ts.getDefaultLibFilePath(compilerOpts),
+        fileExists: readers.fileExists,
+        readFile: readers.readFile,
+        directoryExists: (directory) => containedDirectoryExists(fs, readers, libDir, directory),
+        getDirectories: (directory) => containedDirectories(fs, readers, libDir, limits, directory),
+        realpath: (path) => {
+            // Only resolve symlinks for the compiler lib dir or paths proven contained; never realpath an
+            // out-of-root path (it would confirm existence of files outside the workspace).
+            if (isWithinLibDir(libDir, path)) {
+                try {
+                    return fs.realPath(path);
+                }
+                catch {
+                    return path;
+                }
+            }
+            return readers.containedReal(path) ?? path;
+        },
+        getCancellationToken: () => cancellation,
+        useCaseSensitiveFileNames: () => CASE_SENSITIVE,
+    };
+}

package/dist/editor/localKnowledgeRetrieval.d.ts

@@ -0,0 +1,21 @@
+import type { RetrievalReference } from "@oscharko-dev/keiko-contracts";
+import type { ChatLocalKnowledgeScope } from "@oscharko-dev/keiko-contracts/bff-wire";
+import type { KnowledgeStore } from "@oscharko-dev/keiko-local-knowledge";
+import type { UiHandlerDeps } from "../deps.js";
+import type { RouteResult } from "../routes.js";
+export type EditorLocalKnowledgeOutcome = {
+    readonly kind: "ok";
+    readonly references: readonly RetrievalReference[];
+    readonly noEvidence: boolean;
+    readonly reason: string | undefined;
+} | {
+    readonly kind: "conflict";
+    readonly routeResult: RouteResult;
+} | {
+    readonly kind: "not-ready";
+    readonly reason: string;
+    readonly message: string;
+};
+export declare function buildLocalKnowledgeScope(capsuleId: string | undefined, capsuleSetId: string | undefined): ChatLocalKnowledgeScope | undefined;
+export declare function retrieveEditorLocalKnowledge(deps: UiHandlerDeps, store: KnowledgeStore, scope: ChatLocalKnowledgeScope, queryText: string, signal: AbortSignal): Promise<EditorLocalKnowledgeOutcome>;
+//# sourceMappingURL=localKnowledgeRetrieval.d.ts.map

package/dist/editor/localKnowledgeRetrieval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localKnowledgeRetrieval.d.ts","sourceRoot":"","sources":["../../src/editor/localKnowledgeRetrieval.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAGV,kBAAkB,EACnB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,wCAAwC,CAAC;AAEtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAOhD,MAAM,MAAM,2BAA2B,GACnC;IACE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,UAAU,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACnD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;CAAE,GAChE;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAItF,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,YAAY,EAAE,MAAM,GAAG,SAAS,GAC/B,uBAAuB,GAAG,SAAS,CAQrC;AAED,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,uBAAuB,EAC9B,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,2BAA2B,CAAC,CA2BtC"}