@oscharko-dev/keiko 0.2.0-beta.2 → 0.2.0-beta.4

package/node_modules/@oscharko-dev/keiko-server/dist/files.js

@@ -1,15 +1,21 @@
 // Read-only filesystem browser for the desktop Files widget. The browser receives
-// only metadata or redacted preview content; every request is contained inside a
-// registered project root after realpath resolution.
-import { lstat, opendir, open, readFile, realpath, stat } from "node:fs/promises";
+// preview or editor content; every request is contained inside a selected root after
+// realpath resolution.
+import { lstat, opendir, open, readFile, realpath, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, isAbsolute, join, parse as parsePath, posix as pathPosix, relative, resolve, } from "node:path";
-import { compileIgnore, isIgnored } from "@oscharko-dev/keiko-workspace";
+import { redact } from "@oscharko-dev/keiko-security";
 import { DENIED_MESSAGE, pathIsDenied } from "./files-deny.js";
 import { errorBody } from "./routes.js";
 const MAX_DIRECTORY_ENTRIES = 1_000;
 const MAX_TEXT_PREVIEW_BYTES = 1_000_000;
 const MAX_IMAGE_PREVIEW_BYTES = 3_000_000;
-const MAX_IGNORED_SCAN_ENTRIES = 10_000;
+const staticFilesMetadataRedactor = (value) => typeof value === "string" ? redact(value) : value;
+class BodyTooLargeError extends Error {
+    constructor() {
+        super("request body too large");
+        this.name = "BodyTooLargeError";
+    }
+}
 class FilesError extends Error {
     status;
     code;
@@ -33,6 +39,12 @@ async function runFilesHandler(work) {
         throw error;
     }
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRouteResult(value) {
+    return isRecord(value) && typeof value.status === "number" && "body" in value;
+}
 async function resolveDirectory(candidate) {
     let resolved;
     try {
@@ -50,15 +62,27 @@ async function resolveDirectory(candidate) {
 function projectFor(store, projectId) {
     return store.listProjects().find((project) => project.path === projectId);
 }
-function rootNameIsDenied(rootPath) {
-    return pathIsDenied(basename(rootPath));
+function rootPathIsDenied(rootPath) {
+    return pathIsDenied(rootPath);
 }
-async function resolveRegisteredRoot(project) {
-    if (rootNameIsDenied(project.path)) {
+function assertMetadataSafe(value, redactor) {
+    const redacted = redactor(value);
+    if (typeof redacted === "string" && redacted !== value) {
+        throw new FilesError(403, "DENIED", DENIED_MESSAGE);
+    }
+}
+function metadataIsSafe(value, redactor) {
+    const redacted = redactor(value);
+    return typeof redacted !== "string" || redacted === value;
+}
+async function resolveRegisteredRoot(project, redactor) {
+    assertMetadataSafe(project.path, redactor);
+    if (rootPathIsDenied(project.path)) {
         throw new FilesError(403, "DENIED", DENIED_MESSAGE);
     }
     const realRoot = await resolveDirectory(project.path);
-    if (rootNameIsDenied(realRoot)) {
+    assertMetadataSafe(realRoot, redactor);
+    if (rootPathIsDenied(realRoot)) {
         throw new FilesError(403, "DENIED", DENIED_MESSAGE);
     }
     return { root: project.path, realRoot };
@@ -70,27 +94,29 @@ async function resolveRegisteredRoot(project) {
 // innocuous). Browse and connect therefore accept the identical set of roots. The deny check runs
 // once on the raw input and again on the realpath, so a symlink whose target lands in a denied
 // location is caught after resolution.
-async function resolveArbitraryRoot(rootInput) {
+async function resolveArbitraryRoot(rootInput, redactor) {
     if (!isAbsolute(rootInput)) {
         throw new FilesError(400, "BAD_ROOT", "The root must be an absolute directory path.");
     }
+    assertMetadataSafe(rootInput, redactor);
     if (pathIsDenied(rootInput)) {
         throw new FilesError(403, "DENIED", DENIED_MESSAGE);
     }
     const realRoot = await resolveDirectory(rootInput);
+    assertMetadataSafe(realRoot, redactor);
     if (pathIsDenied(realRoot)) {
         throw new FilesError(403, "DENIED", DENIED_MESSAGE);
     }
     return { root: rootInput, realRoot };
 }
-async function resolveRoot(store, rootInput) {
+async function resolveRoot(store, rootInput, redactor) {
     if (rootInput === null || rootInput.trim().length === 0) {
         throw new FilesError(400, "BAD_REQUEST", "The root query parameter is required.");
     }
     const project = projectFor(store, rootInput);
     return project === undefined
-        ? resolveArbitraryRoot(rootInput.trim())
-        : resolveRegisteredRoot(project);
+        ? resolveArbitraryRoot(rootInput.trim(), redactor)
+        : resolveRegisteredRoot(project, redactor);
 }
 function directoryRoots(projectRoot) {
     return [{ label: "Project root", path: projectRoot }];
@@ -142,22 +168,25 @@ function normalizeDirectoryPath(pathInput, registeredRoot, realRoot) {
     }
     return candidate;
 }
-async function resolveDirectoryInsideRoot(store, rootInput, pathInput) {
-    const root = await resolveRoot(store, rootInput);
+async function resolveDirectoryInsideRoot(store, rootInput, pathInput, redactor) {
+    const root = await resolveRoot(store, rootInput, redactor);
     const candidate = normalizeDirectoryPath(pathInput, root.root, root.realRoot);
     const pathValue = await resolveDirectory(candidate);
+    assertMetadataSafe(pathValue, redactor);
     if (!isContained(root.realRoot, pathValue)) {
         throw new FilesError(403, "PATH_ESCAPE", "The requested path is outside the selected project.");
     }
     const relativePath = rootRelativePosixPath(root.realRoot, pathValue);
+    assertMetadataSafe(relativePath, redactor);
     if (pathIsDenied(relativePath)) {
         throw new FilesError(403, "DENIED", DENIED_MESSAGE);
     }
     return { ...root, path: pathValue, relativePath };
 }
-async function resolveInsideRoot(store, rootInput, pathInput) {
-    const root = await resolveRoot(store, rootInput);
+async function resolveInsideRoot(store, rootInput, pathInput, redactor) {
+    const root = await resolveRoot(store, rootInput, redactor);
     const relativePath = normalizeRelativePath(pathInput);
+    assertMetadataSafe(relativePath, redactor);
     // Deny check runs BEFORE realpath so existence of a denied path is not
     // observable via the 403/404 status-code difference. A non-existent denied
     // path returns 403, identical to an existing denied path.
@@ -176,6 +205,7 @@ async function resolveInsideRoot(store, rootInput, pathInput) {
         throw new FilesError(403, "PATH_ESCAPE", "The requested path is outside the selected root.");
     }
     const targetRelativePath = rootRelativePosixPath(root.realRoot, target);
+    assertMetadataSafe(targetRelativePath, redactor);
     if (pathIsDenied(targetRelativePath)) {
         throw new FilesError(403, "DENIED", DENIED_MESSAGE);
     }
@@ -190,7 +220,7 @@ async function resolveInsideRoot(store, rootInput, pathInput) {
         symlink: linkStats.isSymbolicLink(),
     };
 }
-async function directoryEntries(root, pathValue) {
+async function directoryEntries(root, pathValue, redactor) {
     const entries = [];
     const dir = await opendir(pathValue);
     try {
@@ -199,6 +229,8 @@ async function directoryEntries(root, pathValue) {
                 continue;
             const entryPath = join(pathValue, entry.name);
             const relativePath = rootRelativePosixPath(root, entryPath);
+            if (!metadataIsSafe(relativePath, redactor))
+                continue;
             if (pathIsDenied(relativePath))
                 continue;
             entries.push({ name: entry.name, path: entryPath });
@@ -209,12 +241,12 @@ async function directoryEntries(root, pathValue) {
     }
     return entries.sort((a, b) => a.name.localeCompare(b.name));
 }
-export async function listFilesDirectories(store, rootInput, pathInput) {
-    const target = await resolveDirectoryInsideRoot(store, rootInput, pathInput);
+export async function listFilesDirectories(store, rootInput, pathInput, redactor = staticFilesMetadataRedactor) {
+    const target = await resolveDirectoryInsideRoot(store, rootInput, pathInput, redactor);
     return {
         path: target.path,
         parent: parentPath(target.path, target.realRoot),
-        entries: await directoryEntries(target.realRoot, target.path),
+        entries: await directoryEntries(target.realRoot, target.path, redactor),
         roots: directoryRoots(target.root),
     };
 }
@@ -227,8 +259,9 @@ function extensionOf(name) {
     const ext = extname(lower).replace(/^\./u, "");
     return ext.length > 0 ? ext : null;
 }
-async function classifyEntry(root, parentRelativePath, parentNativePath, entry) {
+async function classifyEntry(root, parentRelativePath, parentNativePath, entry, redactor) {
     const childRelativePath = parentRelativePath.length === 0 ? entry.name : `${parentRelativePath}/${entry.name}`;
+    assertMetadataSafe(childRelativePath, redactor);
     const entryPath = join(parentNativePath, entry.name);
     const linkStats = await lstat(entryPath);
     const symlink = linkStats.isSymbolicLink();
@@ -270,57 +303,29 @@ function entryRank(entry) {
 function childRelative(parentRelativePath, name) {
     return parentRelativePath.length === 0 ? name : `${parentRelativePath}/${name}`;
 }
-// Best-effort: read the project root's `.gitignore` if present. Silent failure
-// is intentional — `.gitignore` is tier-2 noise reduction, not a safety
-// boundary (deny-list is tier 1). A missing/unreadable `.gitignore` is "no
-// filter". No long-lived cache: the BFF is stateless across user-selected roots.
-async function loadRootGitignore(rootPath) {
-    let raw;
-    try {
-        raw = await readFile(join(rootPath, ".gitignore"), "utf8");
-    }
-    catch {
-        return null;
-    }
-    const withoutBom = raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw;
-    return compileIgnore(withoutBom.split("\n"));
-}
-function skipEntry(matcher, rel, isDir) {
-    if (pathIsDenied(rel))
-        return "denied";
-    return matcher !== null && isIgnored(matcher, rel, isDir) ? "ignored" : null;
+function skipEntry(rel) {
+    return pathIsDenied(rel);
 }
-async function listTreeEntries(root, relativePath, pathValue, matcher) {
+async function listTreeEntries(root, relativePath, pathValue, redactor) {
     const entries = [];
     const dir = await opendir(pathValue);
     let truncated = false;
-    let ignoredScans = 0;
     try {
         for await (const entry of dir) {
-            // Deny and .gitignore filtering happen BEFORE the truncation counter so
-            // a directory packed with denied entries (e.g. node_modules/**) cannot
-            // exhaust the 1000-entry budget and hide real files behind
-            // `truncated: true`. Deny is applied by the link name (the user only
-            // sees that name) so a symlink whose own name matches a deny pattern is
-            // denied even if its target does not — matches the workspace-layer
-            // semantics.
+            // Deny filtering happens BEFORE the truncation counter so a directory packed with denied
+            // entries (e.g. node_modules/**) cannot exhaust the 1000-entry budget and hide real files
+            // behind `truncated: true`. .gitignore is intentionally not a Files visibility filter:
+            // safe dotfiles and generated files must remain visible and connectable.
             const rel = childRelative(relativePath, entry.name);
-            const skipReason = skipEntry(matcher, rel, entry.isDirectory());
-            if (skipReason === "denied")
+            if (!metadataIsSafe(rel, redactor))
                 continue;
-            if (skipReason === "ignored") {
-                ignoredScans += 1;
-                if (ignoredScans >= MAX_IGNORED_SCAN_ENTRIES) {
-                    truncated = true;
-                    break;
-                }
+            if (skipEntry(rel))
                 continue;
-            }
             if (entries.length >= MAX_DIRECTORY_ENTRIES) {
                 truncated = true;
                 break;
             }
-            entries.push(await classifyEntry(root, relativePath, pathValue, entry));
+            entries.push(await classifyEntry(root, relativePath, pathValue, entry, redactor));
         }
     }
     finally {
@@ -329,16 +334,12 @@ async function listTreeEntries(root, relativePath, pathValue, matcher) {
     entries.sort((a, b) => entryRank(a) - entryRank(b) || a.name.localeCompare(b.name));
     return { entries, truncated };
 }
-export async function readFilesTree(store, rootInput, pathInput) {
-    const target = await resolveInsideRoot(store, rootInput, pathInput);
+export async function readFilesTree(store, rootInput, pathInput, redactor = staticFilesMetadataRedactor) {
+    const target = await resolveInsideRoot(store, rootInput, pathInput, redactor);
     if (!target.stats.isDirectory()) {
         throw new FilesError(400, "NOT_DIRECTORY", "The requested path is not a directory.");
     }
-    // Per-request: read the project root's `.gitignore` once. Best-effort noise
-    // reduction only; the matcher never relaxes the deny list. No long-lived
-    // cache — the BFF must stay stateless across user-selected roots.
-    const ignoreMatcher = await loadRootGitignore(target.realRoot);
-    const listed = await listTreeEntries(target.realRoot, target.relativePath, target.path, ignoreMatcher);
+    const listed = await listTreeEntries(target.realRoot, target.relativePath, target.path, redactor);
     return {
         root: target.root,
         path: target.relativePath,
@@ -439,6 +440,57 @@ async function readPrefix(pathValue, maxBytes) {
         await file.close();
     }
 }
+async function readBody(req, maxBytes) {
+    return new Promise((resolveBody, reject) => {
+        const chunks = [];
+        let total = 0;
+        let capped = false;
+        req.on("data", (chunk) => {
+            total += chunk.length;
+            if (total > maxBytes) {
+                if (!capped) {
+                    capped = true;
+                    chunks.length = 0;
+                    reject(new BodyTooLargeError());
+                    req.resume();
+                }
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => {
+            if (!capped)
+                resolveBody(Buffer.concat(chunks).toString("utf8"));
+        });
+        req.on("error", reject);
+    });
+}
+async function readJsonObject(req, maxBytes) {
+    let raw;
+    try {
+        raw = await readBody(req, maxBytes);
+    }
+    catch (error) {
+        if (error instanceof BodyTooLargeError) {
+            return {
+                status: 413,
+                body: errorBody("PAYLOAD_TOO_LARGE", "Request body exceeds the size limit."),
+            };
+        }
+        throw error;
+    }
+    let parsed;
+    try {
+        parsed = raw.length === 0 ? {} : JSON.parse(raw);
+    }
+    catch {
+        return { status: 400, body: errorBody("BAD_REQUEST", "Request body is not valid JSON.") };
+    }
+    if (!isRecord(parsed)) {
+        return { status: 400, body: errorBody("BAD_REQUEST", "Request body must be a JSON object.") };
+    }
+    return parsed;
+}
 function basePreview(target) {
     const name = basename(target.relativePath);
     const extension = extensionOf(name);
@@ -477,8 +529,58 @@ async function textPreview(target, base, redactor) {
         maxBytes: MAX_TEXT_PREVIEW_BYTES,
     };
 }
-export async function readFilesPreview(store, rootInput, pathInput, redactor) {
-    const target = await resolveInsideRoot(store, rootInput, pathInput);
+async function editableTextContent(target, base) {
+    if (target.stats.size > MAX_TEXT_PREVIEW_BYTES) {
+        throw new FilesError(413, "FILE_TOO_LARGE", `This file is too large to edit here (limit ${String(MAX_TEXT_PREVIEW_BYTES)} bytes).`);
+    }
+    const content = await readFile(target.path, "utf8");
+    return {
+        ...base,
+        content,
+        maxBytes: MAX_TEXT_PREVIEW_BYTES,
+    };
+}
+export async function readFilesContent(store, rootInput, pathInput, redactor = staticFilesMetadataRedactor) {
+    const target = await resolveInsideRoot(store, rootInput, pathInput, redactor);
+    if (!target.stats.isFile()) {
+        throw new FilesError(400, "NOT_FILE", "The requested path is not a file.");
+    }
+    const base = basePreview(target);
+    const prefix = await readPrefix(target.path, Math.min(target.stats.size, 4096));
+    if (!isKnownTextExtension(base.extension) && !isLikelyUtf8Text(prefix.buffer)) {
+        throw new FilesError(400, "UNSUPPORTED_FILE", "This file cannot be edited in the workspace.");
+    }
+    return editableTextContent(target, base);
+}
+export async function writeFilesContent(args) {
+    const target = await resolveInsideRoot(args.store, args.rootInput, args.pathInput, args.redactor ?? staticFilesMetadataRedactor);
+    if (!target.stats.isFile()) {
+        throw new FilesError(400, "NOT_FILE", "The requested path is not a file.");
+    }
+    const base = basePreview(target);
+    const prefix = await readPrefix(target.path, Math.min(target.stats.size, 4096));
+    if (!isKnownTextExtension(base.extension) && !isLikelyUtf8Text(prefix.buffer)) {
+        throw new FilesError(400, "UNSUPPORTED_FILE", "This file cannot be edited in the workspace.");
+    }
+    if (args.expectedModifiedAt !== undefined &&
+        Math.abs(target.stats.mtimeMs - args.expectedModifiedAt) > 1) {
+        throw new FilesError(409, "WRITE_CONFLICT", "This file changed on disk. Reload it before saving again.");
+    }
+    if (Buffer.byteLength(args.content, "utf8") > MAX_TEXT_PREVIEW_BYTES) {
+        throw new FilesError(413, "FILE_TOO_LARGE", `This file is too large to edit here (limit ${String(MAX_TEXT_PREVIEW_BYTES)} bytes).`);
+    }
+    await writeFile(target.path, args.content, "utf8");
+    const updatedStats = await stat(target.path);
+    return {
+        ...base,
+        sizeBytes: updatedStats.size,
+        modifiedAt: updatedStats.mtimeMs,
+        content: args.content,
+        maxBytes: MAX_TEXT_PREVIEW_BYTES,
+    };
+}
+export async function readFilesPreview(store, rootInput, pathInput, redactor = staticFilesMetadataRedactor) {
+    const target = await resolveInsideRoot(store, rootInput, pathInput, redactor);
     if (!target.stats.isFile()) {
         throw new FilesError(400, "NOT_FILE", "The requested path is not a file.");
     }
@@ -497,14 +599,14 @@ export async function handleFilesDirectories(ctx, deps) {
         const requestedPath = ctx.url.searchParams.get("path") ?? undefined;
         return {
             status: 200,
-            body: await listFilesDirectories(deps.store, requestedRoot, requestedPath),
+            body: await listFilesDirectories(deps.store, requestedRoot, requestedPath, deps.redactor),
         };
     });
 }
 export async function handleFilesTree(ctx, deps) {
     return runFilesHandler(async () => ({
         status: 200,
-        body: await readFilesTree(deps.store, ctx.url.searchParams.get("root"), ctx.url.searchParams.get("path")),
+        body: await readFilesTree(deps.store, ctx.url.searchParams.get("root"), ctx.url.searchParams.get("path"), deps.redactor),
     }));
 }
 export async function handleFilesPreview(ctx, deps) {
@@ -513,3 +615,37 @@ export async function handleFilesPreview(ctx, deps) {
         body: await readFilesPreview(deps.store, ctx.url.searchParams.get("root"), ctx.url.searchParams.get("path"), deps.redactor),
     }));
 }
+export async function handleFilesContent(ctx, deps) {
+    return runFilesHandler(async () => {
+        if ((ctx.req.method ?? "GET").toUpperCase() === "GET") {
+            return {
+                status: 200,
+                body: await readFilesContent(deps.store, ctx.url.searchParams.get("root"), ctx.url.searchParams.get("path"), deps.redactor),
+            };
+        }
+        const body = await readJsonObject(ctx.req, MAX_TEXT_PREVIEW_BYTES * 2 + 16_384);
+        if (isRouteResult(body))
+            return body;
+        const rootInput = typeof body.root === "string" ? body.root : null;
+        const pathInput = typeof body.path === "string" ? body.path : null;
+        const content = body.content;
+        if (rootInput === null || pathInput === null || typeof content !== "string") {
+            return {
+                status: 400,
+                body: errorBody("BAD_REQUEST", "root, path, and content are required for a file save request."),
+            };
+        }
+        const expectedModifiedAt = typeof body.expectedModifiedAt === "number" ? body.expectedModifiedAt : undefined;
+        return {
+            status: 200,
+            body: await writeFilesContent({
+                store: deps.store,
+                rootInput,
+                pathInput,
+                content,
+                expectedModifiedAt,
+                redactor: deps.redactor,
+            }),
+        };
+    });
+}

package/node_modules/@oscharko-dev/keiko-server/dist/grounded-answer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grounded-answer.d.ts","sourceRoot":"","sources":["../src/grounded-answer.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAC;CACrC;AAED,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,oBAAoB,CAAC;AAwDlE,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAKrE;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,qBAAqB,GAC7B,oBAAoB,CAgBtB"}
+{"version":3,"file":"grounded-answer.d.ts","sourceRoot":"","sources":["../src/grounded-answer.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAC;CACrC;AAED,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,oBAAoB,CAAC;AA2DlE,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CASrE;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,qBAAqB,GAC7B,oBAAoB,CAgBtB"}

package/node_modules/@oscharko-dev/keiko-server/dist/grounded-answer.js

@@ -1,5 +1,6 @@
 const SAFE_GROUNDED_FALLBACK = "I could not produce a clean grounded answer from the retrieved repository evidence.";
-const ORCHESTRATION_PREFIX_RE = /^(searching for\b|search query\b|we need to call search\b|let'?s search\b|calling search\b|tool call\b|plan\b:)/i;
+const ORCHESTRATION_PREFIX_RE = /^(searching for\b|search query\b|we need to call search\b|let'?s search\b|calling search\b|tool call\b|plan\b:|system prompt\b:|developer prompt\b:|internal planning\b:|internal reasoning\b:|hidden instruction\b:)/i;
+const PROMPT_DISCLOSURE_RE = /^(system prompt\b:|developer prompt\b:|internal planning\b:|internal reasoning\b:|hidden instruction\b:)/i;
 const ARGUMENT_LINE_RE = /^(?:[{[]|["']?(?:path|query|max_results|maxResults|tool|arguments|scope|search)["']?\s*:)/i;
 function isFiniteCount(value) {
     return typeof value === "number" && Number.isFinite(value) && value >= 0;
@@ -42,7 +43,11 @@ function leadingContentIndex(lines) {
 export function sanitizeGroundedAnswerContent(content) {
     const lines = content.split("\n");
     const index = leadingContentIndex(lines);
-    const sanitized = lines.slice(index).join("\n").trim();
+    const sanitized = lines
+        .slice(index)
+        .filter((line) => !PROMPT_DISCLOSURE_RE.test(line.trim()))
+        .join("\n")
+        .trim();
     return sanitized.length > 0 ? sanitized : SAFE_GROUNDED_FALLBACK;
 }
 export function normalizeGroundedAnswerPayload(payload) {

package/node_modules/@oscharko-dev/keiko-server/dist/grounded-context-index.d.ts

@@ -4,6 +4,8 @@ export interface GroundedContextIndexRegistryOptions {
     readonly ttlMs?: number;
     readonly maxEntriesPerScope?: number;
     readonly maxScopes?: number;
+    readonly sweepIntervalMs?: number;
+    readonly autoSweep?: boolean;
 }
 export interface GroundedContextIndexRegistry {
     forScope(scope: SelectedScope, nowMs: () => number): MicroIndex;
@@ -12,6 +14,7 @@ export interface GroundedContextIndexRegistry {
     clearAll(): void;
     sweep(nowMs: () => number): void;
     size(): number;
+    dispose(): void;
 }
 export declare function createGroundedContextIndexRegistry(options?: GroundedContextIndexRegistryOptions): GroundedContextIndexRegistry;
 export declare const groundedContextIndexRegistry: GroundedContextIndexRegistry;

package/node_modules/@oscharko-dev/keiko-server/dist/grounded-context-index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grounded-context-index.d.ts","sourceRoot":"","sources":["../src/grounded-context-index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAC;AACrF,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,+BAA+B,CAAC;AAEvC,MAAM,WAAW,mCAAmC;IAClD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,MAAM,GAAG,UAAU,CAAC;IAChE,iBAAiB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAChD,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,QAAQ,IAAI,IAAI,CAAC;IACjB,KAAK,CAAC,KAAK,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IACjC,IAAI,IAAI,MAAM,CAAC;CAChB;AAuJD,wBAAgB,kCAAkC,CAChD,OAAO,CAAC,EAAE,mCAAmC,GAC5C,4BAA4B,CAwB9B;AAED,eAAO,MAAM,4BAA4B,8BAAuC,CAAC;AAEjF,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,MAAM,GAAG,UAAU,CAEhG;AAED,wBAAgB,0CAA0C,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAEvF;AAED,wBAAgB,uCAAuC,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAEnF;AAED,wBAAgB,8BAA8B,IAAI,IAAI,CAErD"}
+{"version":3,"file":"grounded-context-index.d.ts","sourceRoot":"","sources":["../src/grounded-context-index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAC;AACrF,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,+BAA+B,CAAC;AAEvC,MAAM,WAAW,mCAAmC;IAClD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,MAAM,GAAG,UAAU,CAAC;IAChE,iBAAiB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAChD,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,QAAQ,IAAI,IAAI,CAAC;IACjB,KAAK,CAAC,KAAK,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IACjC,IAAI,IAAI,MAAM,CAAC;IACf,OAAO,IAAI,IAAI,CAAC;CACjB;AAmKD,wBAAgB,kCAAkC,CAChD,OAAO,CAAC,EAAE,mCAAmC,GAC5C,4BAA4B,CAsC9B;AAED,eAAO,MAAM,4BAA4B,8BAAuC,CAAC;AAEjF,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,MAAM,GAAG,UAAU,CAEhG;AAED,wBAAgB,0CAA0C,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAEvF;AAED,wBAAgB,uCAAuC,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAEnF;AAED,wBAAgB,8BAA8B,IAAI,IAAI,CAErD"}

package/node_modules/@oscharko-dev/keiko-server/dist/grounded-context-index.js

@@ -3,21 +3,30 @@
 // and provides deterministic cleanup hooks for chat/project lifecycle changes. Nothing persists.
 import { createHash } from "node:crypto";
 import { createMicroIndex, DEFAULT_MICRO_INDEX, } from "@oscharko-dev/keiko-workflows";
-const DEFAULT_MAX_SCOPES = 128;
+const DEFAULT_MAX_SCOPES = 32;
+const DEFAULT_MAX_ENTRIES_PER_SCOPE = 8;
+const DEFAULT_SWEEP_INTERVAL_MS = 60_000;
 function assertPositiveInteger(name, value) {
     if (!Number.isInteger(value) || value <= 0) {
         throw new RangeError(`${name} must be a positive integer`);
     }
 }
+function optionOrDefault(value, fallback) {
+    return value ?? fallback;
+}
 function resolveOptions(options) {
+    const provided = options ?? {};
     const resolved = {
-        ttlMs: options?.ttlMs ?? DEFAULT_MICRO_INDEX.ttlMs,
-        maxEntriesPerScope: options?.maxEntriesPerScope ?? DEFAULT_MICRO_INDEX.maxEntries,
-        maxScopes: options?.maxScopes ?? DEFAULT_MAX_SCOPES,
+        ttlMs: optionOrDefault(provided.ttlMs, DEFAULT_MICRO_INDEX.ttlMs),
+        maxEntriesPerScope: optionOrDefault(provided.maxEntriesPerScope, DEFAULT_MAX_ENTRIES_PER_SCOPE),
+        maxScopes: optionOrDefault(provided.maxScopes, DEFAULT_MAX_SCOPES),
+        sweepIntervalMs: optionOrDefault(provided.sweepIntervalMs, DEFAULT_SWEEP_INTERVAL_MS),
+        autoSweep: optionOrDefault(provided.autoSweep, true),
     };
     assertPositiveInteger("ttlMs", resolved.ttlMs);
     assertPositiveInteger("maxEntriesPerScope", resolved.maxEntriesPerScope);
     assertPositiveInteger("maxScopes", resolved.maxScopes);
+    assertPositiveInteger("sweepIntervalMs", resolved.sweepIntervalMs);
     return resolved;
 }
 function sha256Hex(value) {
@@ -110,6 +119,14 @@ function clearEntries(entries) {
 export function createGroundedContextIndexRegistry(options) {
     const resolved = resolveOptions(options);
     const entries = new Map();
+    const sweepTimer = resolved.autoSweep
+        ? setInterval(() => {
+            evictExpired(entries, Date.now());
+        }, resolved.sweepIntervalMs)
+        : undefined;
+    if (sweepTimer !== undefined) {
+        sweepTimer.unref();
+    }
     return {
         forScope(scope, nowMs) {
             return getOrCreateScopeIndex(entries, resolved, scope, nowMs);
@@ -129,6 +146,12 @@ export function createGroundedContextIndexRegistry(options) {
         size() {
             return entries.size;
         },
+        dispose() {
+            if (sweepTimer !== undefined) {
+                clearInterval(sweepTimer);
+            }
+            clearEntries(entries);
+        },
     };
 }
 export const groundedContextIndexRegistry = createGroundedContextIndexRegistry();

package/node_modules/@oscharko-dev/keiko-server/dist/grounded-handoff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grounded-handoff.d.ts","sourceRoot":"","sources":["../src/grounded-handoff.ts"],"names":[],"mappings":"AAmBA,OAAO,EAA2B,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AAYxE,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAof7D,wBAAsB,6BAA6B,CACjD,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CAOtB"}
+{"version":3,"file":"grounded-handoff.d.ts","sourceRoot":"","sources":["../src/grounded-handoff.ts"],"names":[],"mappings":"AAmBA,OAAO,EAA2B,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AAYxE,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AA4hB7D,wBAAsB,6BAA6B,CACjD,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,WAAW,CAAC,CAOtB"}