@arnilo/prism-coding-agent 0.2.4 → 0.2.5

package/dist/language/framing.d.ts

@@ -14,10 +14,18 @@ export declare function encodeLspFrame(message: unknown): Buffer;
  * Rejects malformed headers, non-decimal Content-Length, and oversized bodies.
  */
 export declare class LspFrameReader {
-    private buf;
+    private chunks;
+    private offset;
+    private retained;
+    private cachedBodyStart;
+    private cachedContentLength;
     private readonly maxMessageBytes;
     constructor(maxMessageBytes: number);
     /** Push stdout/stderr chunk; return complete parsed JSON values (order preserved). */
     push(chunk: Buffer): unknown[];
+    /** Copy `n` unconsumed bytes starting at absolute unconsumed offset `start` (no advance). */
+    private peekAt;
+    /** Advance the unconsumed cursor by `n` (drop fully-consumed chunks). */
+    private drop;
     private tryParseOne;
 }

package/dist/language/framing.js

@@ -21,7 +21,20 @@ export function encodeLspFrame(message) {
  * Rejects malformed headers, non-decimal Content-Length, and oversized bodies.
  */
 export class LspFrameReader {
-    buf = Buffer.alloc(0);
+    // ponytail: chunk-array accumulator — O(1) append per push, no whole-buffer re-concat
+    // (the 0.2.4 `this.buf = Buffer.concat([this.buf, chunk])` was O(input * chunks)).
+    // A completed frame copies only its header+body region (bounded by maxMessageBytes),
+    // so total copying is O(input). The header separator scan peeks min(retained, 64KiB)
+    // per unparsed frame; for the rare many-frames-per-large-chunk case that is a 64KiB-
+    // per-frame copy (linear, 64x constant) — upgrade to a streaming separator search
+    // if pipelined-frame throughput matters. A separator beyond the 64KiB header bound
+    // is rejected (stricter DoS guard than 0.2.4, which accepted it; no test exercises
+    // >64KiB headers — the bound exists precisely to reject unbounded header growth).
+    chunks = [];
+    offset = 0; // consumed prefix bytes in chunks[0]
+    retained = 0; // total unconsumed bytes
+    cachedBodyStart = -1; // -1 = header not yet parsed; else body starts at this absolute unconsumed offset
+    cachedContentLength = 0;
     maxMessageBytes;
     constructor(maxMessageBytes) {
         this.maxMessageBytes = maxMessageBytes;
@@ -30,7 +43,8 @@ export class LspFrameReader {
     push(chunk) {
         if (chunk.length === 0)
             return [];
-        this.buf = Buffer.concat([this.buf, chunk]);
+        this.chunks.push(chunk);
+        this.retained += chunk.length;
         const out = [];
         for (;;) {
             const parsed = this.tryParseOne();
@@ -40,26 +54,84 @@ export class LspFrameReader {
         }
         return out;
     }
+    /** Copy `n` unconsumed bytes starting at absolute unconsumed offset `start` (no advance). */
+    peekAt(start, n) {
+        const out = Buffer.allocUnsafe(n);
+        let written = 0;
+        let i = 0;
+        let off = this.offset;
+        let skip = start;
+        while (skip > 0) {
+            const c = this.chunks[i];
+            const avail = c.length - off;
+            if (skip >= avail) {
+                skip -= avail;
+                i++;
+                off = 0;
+            }
+            else {
+                off += skip;
+                skip = 0;
+            }
+        }
+        while (written < n) {
+            const c = this.chunks[i];
+            const take = Math.min(c.length - off, n - written);
+            c.copy(out, written, off, off + take);
+            written += take;
+            i++;
+            off = 0;
+        }
+        return out;
+    }
+    /** Advance the unconsumed cursor by `n` (drop fully-consumed chunks). */
+    drop(n) {
+        let remaining = n;
+        while (remaining > 0 && this.chunks.length > 0) {
+            const first = this.chunks[0];
+            const avail = first.length - this.offset;
+            if (remaining >= avail) {
+                remaining -= avail;
+                this.chunks.shift();
+                this.offset = 0;
+            }
+            else {
+                this.offset += remaining;
+                remaining = 0;
+            }
+        }
+        this.retained -= n;
+    }
     tryParseOne() {
-        const sep = indexOfHeaderSep(this.buf);
-        if (sep < 0) {
+        if (this.retained === 0)
+            return undefined;
+        const headerBound = Math.min(this.maxMessageBytes, 64 * 1024);
+        if (this.cachedBodyStart < 0) {
             // Bound header scan buffer so a missing separator cannot grow forever.
-            if (this.buf.length > Math.min(this.maxMessageBytes, 64 * 1024)) {
-                throw new LspFrameError("ERR_PRISM_LSP_FRAMING", "LSP header exceeds bound without separator");
+            const scanLen = Math.min(this.retained, headerBound);
+            const view = this.peekAt(0, scanLen);
+            const sep = indexOfHeaderSep(view);
+            if (sep < 0) {
+                if (this.retained > headerBound) {
+                    throw new LspFrameError("ERR_PRISM_LSP_FRAMING", "LSP header exceeds bound without separator");
+                }
+                return undefined;
             }
-            return undefined;
-        }
-        const headerText = this.buf.subarray(0, sep).toString("ascii");
-        const contentLength = parseContentLength(headerText);
-        if (contentLength > this.maxMessageBytes) {
-            throw new LspFrameError("ERR_PRISM_LSP_LIMIT", `LSP message body ${contentLength} exceeds maxMessageBytes ${this.maxMessageBytes}`);
+            const headerText = view.subarray(0, sep).toString("ascii");
+            const contentLength = parseContentLength(headerText);
+            if (contentLength > this.maxMessageBytes) {
+                throw new LspFrameError("ERR_PRISM_LSP_LIMIT", `LSP message body ${contentLength} exceeds maxMessageBytes ${this.maxMessageBytes}`);
+            }
+            this.cachedBodyStart = sep + 4;
+            this.cachedContentLength = contentLength;
         }
-        const bodyStart = sep + 4;
-        const bodyEnd = bodyStart + contentLength;
-        if (this.buf.length < bodyEnd)
+        const bodyEnd = this.cachedBodyStart + this.cachedContentLength;
+        if (this.retained < bodyEnd)
             return undefined;
-        const body = this.buf.subarray(bodyStart, bodyEnd);
-        this.buf = this.buf.subarray(bodyEnd);
+        const body = this.peekAt(this.cachedBodyStart, this.cachedContentLength);
+        this.drop(bodyEnd);
+        this.cachedBodyStart = -1;
+        this.cachedContentLength = 0;
         let value;
         try {
             value = JSON.parse(body.toString("utf8"));

package/dist/repository/glob.d.ts

@@ -0,0 +1,4 @@
+import type { RepositoryGlobRequest, RepositoryGlobResult, ResolvedRepositoryLimits } from "./types.js";
+import type { RepositoryWalk } from "./walk.js";
+export declare function globLocal(request: RepositoryGlobRequest, defaults: ResolvedRepositoryLimits, walk: RepositoryWalk): Promise<RepositoryGlobResult>;
+/** Local filesystem repository operations (default backend). */

package/dist/repository/glob.js

@@ -0,0 +1,143 @@
+/** Repository glob family (0.2.5 plan 025 Task 1 split).
+ * Moved verbatim from repository.ts; public surface unchanged behind the barrel. */
+import { HARD_MAX_REPO_DEPTH, HARD_MAX_REPO_ENTRIES, HARD_MAX_REPO_RESULTS, validateCodingLimit, validateCodingLimitAllowZero, } from "../limits.js";
+import { expandGlobBraces, matchGlobPattern, validateGlobPattern } from "../glob-match.js";
+import { lstat } from "node:fs/promises";
+import { RepositoryError } from "./types.js";
+import { resolveRepoPath } from "./path.js";
+export async function globLocal(request, defaults, walk) {
+    try {
+        validateGlobPattern(request.pattern, defaults.maxPatternBytes, { braceExpansion: request.braceExpansion === true });
+    }
+    catch (error) {
+        throw new RepositoryError(error instanceof Error ? error.message : String(error));
+    }
+    // Opt-in bounded brace expansion: textual alternatives only (never touches the
+    // filesystem); bounds enforced by expandGlobBraces (max alternatives / bytes).
+    const patterns = request.braceExpansion === true ? expandGlobBraces(request.pattern) : [request.pattern];
+    const resolved = await resolveRepoPath(request.root, request.path);
+    const maxResults = validateCodingLimit("maxResults", request.maxResults ?? defaults.maxResults, HARD_MAX_REPO_RESULTS);
+    const offset = validateCodingLimitAllowZero("offset", request.offset ?? 0, HARD_MAX_REPO_ENTRIES);
+    const maxDepth = validateCodingLimit("maxDepth", request.maxDepth ?? defaults.maxDepth, HARD_MAX_REPO_DEPTH);
+    const exclude = new Set(request.exclude ?? defaults.exclude);
+    const deadlineAt = request.deadlineMs !== undefined ? Date.now() + request.deadlineMs : Date.now() + defaults.maxTimeMs;
+    const collected = [];
+    let scannedEntries = 0;
+    let scannedFiles = 0;
+    let seen = 0;
+    let truncated = false;
+    let truncatedBy = null;
+    const matchesAnyPattern = (relativePath) => {
+        for (const p of patterns) {
+            if (matchGlobPattern(p, relativePath))
+                return true;
+        }
+        return false;
+    };
+    const maybeCollect = (relativePath) => {
+        if (!matchesAnyPattern(relativePath))
+            return false;
+        if (seen < offset) {
+            seen++;
+            return false;
+        }
+        if (collected.length >= maxResults) {
+            truncated = true;
+            truncatedBy = "results";
+            return true;
+        }
+        collected.push(relativePath);
+        seen++;
+        return truncated;
+    };
+    try {
+        const startStat = await lstat(resolved.absolute);
+        if (!startStat.isDirectory()) {
+            scannedEntries = 1;
+            if (startStat.isFile()) {
+                scannedFiles = 1;
+                if (matchesAnyPattern(resolved.relative)) {
+                    if (offset === 0 && maxResults > 0)
+                        collected.push(resolved.relative);
+                    else if (offset === 0 && maxResults === 0) {
+                        truncated = true;
+                        truncatedBy = "results";
+                    }
+                }
+            }
+            return {
+                paths: collected,
+                truncated,
+                truncatedBy,
+                scannedEntries,
+                scannedFiles,
+                offset,
+                nextOffset: undefined,
+            };
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new RepositoryError(`cannot open path: ${message}`);
+    }
+    try {
+        for await (const event of walk(resolved.rootReal, resolved.absolute, {
+            maxDepth,
+            maxEntries: defaults.maxEntries,
+            maxFiles: defaults.maxFiles,
+            exclude,
+            includeHidden: request.includeHidden === true,
+            signal: request.signal,
+            deadlineAt,
+        })) {
+            if (event.type === "limit") {
+                truncated = true;
+                truncatedBy = event.truncatedBy;
+                break;
+            }
+            scannedEntries++;
+            if (event.entry.kind === "file")
+                scannedFiles++;
+            if (event.entry.kind !== "file")
+                continue;
+            if (maybeCollect(event.entry.path))
+                break;
+        }
+    }
+    catch (error) {
+        if (error instanceof RepositoryError && error.message === "Operation aborted") {
+            return {
+                paths: collected,
+                truncated: true,
+                truncatedBy: "abort",
+                scannedEntries,
+                scannedFiles,
+                offset,
+                nextOffset: collected.length > 0 || offset > 0 ? offset + collected.length : undefined,
+            };
+        }
+        if (error instanceof RepositoryError && error.message === "Repository operation exceeded time limit") {
+            return {
+                paths: collected,
+                truncated: true,
+                truncatedBy: "time",
+                scannedEntries,
+                scannedFiles,
+                offset,
+                nextOffset: offset + collected.length,
+            };
+        }
+        throw error;
+    }
+    return {
+        paths: collected,
+        truncated,
+        truncatedBy,
+        scannedEntries,
+        scannedFiles,
+        offset,
+        nextOffset: truncated ? offset + collected.length : undefined,
+    };
+}
+/** Local filesystem repository operations (default backend). */
+//# sourceMappingURL=glob.js.map

package/dist/repository/list.d.ts

@@ -0,0 +1,3 @@
+import type { RepositoryListRequest, RepositoryListResult, ResolvedRepositoryLimits } from "./types.js";
+import type { RepositoryWalk } from "./walk.js";
+export declare function listLocal(request: RepositoryListRequest, defaults: ResolvedRepositoryLimits, walk: RepositoryWalk): Promise<RepositoryListResult>;

package/dist/repository/list.js

@@ -0,0 +1,119 @@
+/** Repository list family (0.2.5 plan 025 Task 1 split).
+ * Moved verbatim from repository.ts; public surface unchanged behind the barrel. */
+import { HARD_MAX_REPO_DEPTH, HARD_MAX_REPO_ENTRIES, HARD_MAX_REPO_RESULTS, validateCodingLimit, validateCodingLimitAllowZero, } from "../limits.js";
+import { lstat } from "node:fs/promises";
+import { RepositoryError } from "./types.js";
+import { resolveRepoPath } from "./path.js";
+export async function listLocal(request, defaults, walk) {
+    const resolved = await resolveRepoPath(request.root, request.path);
+    const maxResults = validateCodingLimit("maxResults", request.maxResults ?? defaults.maxResults, HARD_MAX_REPO_RESULTS);
+    const offset = validateCodingLimitAllowZero("offset", request.offset ?? 0, HARD_MAX_REPO_ENTRIES);
+    const maxDepth = validateCodingLimit("maxDepth", request.maxDepth ?? defaults.maxDepth, HARD_MAX_REPO_DEPTH);
+    const exclude = new Set(request.exclude ?? defaults.exclude);
+    const deadlineAt = request.deadlineMs !== undefined ? Date.now() + request.deadlineMs : Date.now() + defaults.maxTimeMs;
+    const collected = [];
+    let scannedEntries = 0;
+    let scannedFiles = 0;
+    let seen = 0;
+    let truncated = false;
+    let truncatedBy = null;
+    // Single-file start: return that entry when it falls within the page window.
+    try {
+        const startStat = await lstat(resolved.absolute);
+        if (!startStat.isDirectory()) {
+            let kind = "other";
+            if (startStat.isSymbolicLink())
+                kind = "symlink";
+            else if (startStat.isFile())
+                kind = "file";
+            const entry = kind === "file" ? { path: resolved.relative, kind, size: startStat.size } : { path: resolved.relative, kind };
+            scannedEntries = 1;
+            scannedFiles = kind === "file" ? 1 : 0;
+            if (offset === 0 && maxResults > 0)
+                collected.push(entry);
+            else if (offset === 0 && maxResults === 0) {
+                truncated = true;
+                truncatedBy = "results";
+            }
+            return {
+                entries: collected,
+                truncated,
+                truncatedBy,
+                scannedEntries,
+                scannedFiles,
+                offset,
+                nextOffset: undefined,
+            };
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new RepositoryError(`cannot open path: ${message}`);
+    }
+    try {
+        for await (const event of walk(resolved.rootReal, resolved.absolute, {
+            maxDepth,
+            maxEntries: defaults.maxEntries,
+            maxFiles: defaults.maxFiles,
+            exclude,
+            includeHidden: request.includeHidden === true,
+            signal: request.signal,
+            deadlineAt,
+        })) {
+            if (event.type === "limit") {
+                truncated = true;
+                truncatedBy = event.truncatedBy;
+                break;
+            }
+            scannedEntries++;
+            if (event.entry.kind === "file")
+                scannedFiles++;
+            if (seen < offset) {
+                seen++;
+                continue;
+            }
+            if (collected.length >= maxResults) {
+                truncated = true;
+                truncatedBy = "results";
+                break;
+            }
+            collected.push(event.entry);
+            seen++;
+        }
+    }
+    catch (error) {
+        if (error instanceof RepositoryError && error.message === "Operation aborted") {
+            return {
+                entries: collected,
+                truncated: true,
+                truncatedBy: "abort",
+                scannedEntries,
+                scannedFiles,
+                offset,
+                nextOffset: collected.length > 0 || offset > 0 ? offset + collected.length : undefined,
+            };
+        }
+        if (error instanceof RepositoryError && error.message === "Repository operation exceeded time limit") {
+            return {
+                entries: collected,
+                truncated: true,
+                truncatedBy: "time",
+                scannedEntries,
+                scannedFiles,
+                offset,
+                nextOffset: offset + collected.length,
+            };
+        }
+        throw error;
+    }
+    return {
+        entries: collected,
+        truncated,
+        truncatedBy,
+        scannedEntries,
+        scannedFiles,
+        offset,
+        nextOffset: truncated ? offset + collected.length : undefined,
+    };
+}
+//# sourceMappingURL=list.js.map

package/dist/repository/operations.d.ts

@@ -0,0 +1,5 @@
+/** Repository operations family (0.2.5 plan 025 Task 1 split).
+ * Moved verbatim from repository.ts; public surface unchanged behind the barrel. */
+import type { RepositoryLimitOptions, RepositoryOperations } from "./types.js";
+import type { RepositoryWalk } from "./walk.js";
+export declare function createLocalRepositoryOperations(limits?: RepositoryLimitOptions, walk?: RepositoryWalk): RepositoryOperations;

package/dist/repository/operations.js

@@ -0,0 +1,14 @@
+import { resolveRepositoryLimits } from "./types.js";
+import { walkRepository } from "./walk.js";
+import { globLocal } from "./glob.js";
+import { listLocal } from "./list.js";
+import { searchLocal } from "./search.js";
+export function createLocalRepositoryOperations(limits, walk = walkRepository) {
+    const resolved = resolveRepositoryLimits(limits);
+    return {
+        list: (request) => listLocal(request, resolved, walk),
+        search: (request) => searchLocal(request, resolved, walk),
+        glob: (request) => globLocal(request, resolved, walk),
+    };
+}
+//# sourceMappingURL=operations.js.map

package/dist/repository/path.d.ts

@@ -0,0 +1,18 @@
+import type { Dirent } from "node:fs";
+import type { RepoEntryKind } from "./types.js";
+export declare function toRepoRelative(root: string, absolutePath: string): string;
+export declare function isPathInsideRoot(root: string, target: string): boolean;
+/**
+ * Resolve a list/search start path under the workspace root.
+ * Symlink escapes fail closed after realpath when the path exists.
+ */
+export declare function resolveRepoPath(root: string, inputPath: string | undefined): Promise<{
+    absolute: string;
+    relative: string;
+    rootReal: string;
+}>;
+export declare function shouldSkipName(name: string, includeHidden: boolean, exclude: ReadonlySet<string>): boolean;
+export declare function kindFromDirent(dirent: Dirent): RepoEntryKind;
+export declare function assertNotAborted(signal: AbortSignal | undefined): void;
+export declare function assertDeadline(deadlineAt: number | undefined): void;
+export declare function isBinaryBuffer(buffer: Buffer): boolean;

package/dist/repository/path.js

@@ -0,0 +1,91 @@
+/** Repository path family (0.2.5 plan 025 Task 1 split).
+ * Moved verbatim from repository.ts; public surface unchanged behind the barrel. */
+import { DEFAULT_BINARY_SNIFF_BYTES } from "../limits.js";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { realpath } from "node:fs/promises";
+import { resolveToCwd } from "../path-utils.js";
+import { RepositoryError } from "./types.js";
+export function toRepoRelative(root, absolutePath) {
+    const rel = relative(root, absolutePath);
+    if (rel === "")
+        return ".";
+    return rel.split(sep).join("/");
+}
+export function isPathInsideRoot(root, target) {
+    const from = resolve(root);
+    const to = resolve(target);
+    if (to === from)
+        return true;
+    const rel = relative(from, to);
+    return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+/**
+ * Resolve a list/search start path under the workspace root.
+ * Symlink escapes fail closed after realpath when the path exists.
+ */
+export async function resolveRepoPath(root, inputPath) {
+    const rootResolved = resolve(root);
+    let rootReal;
+    try {
+        rootReal = await realpath(rootResolved);
+    }
+    catch {
+        throw new RepositoryError(`workspace root is missing or unreadable: ${rootResolved}`);
+    }
+    if (!inputPath || inputPath === "." || inputPath === "./") {
+        return { absolute: rootReal, relative: ".", rootReal };
+    }
+    const candidate = resolveToCwd(inputPath, rootReal);
+    if (!isPathInsideRoot(rootReal, candidate)) {
+        throw new RepositoryError(`path escapes workspace root: ${inputPath}`);
+    }
+    try {
+        const real = await realpath(candidate);
+        if (!isPathInsideRoot(rootReal, real)) {
+            throw new RepositoryError(`path resolves outside workspace root: ${inputPath}`);
+        }
+        return { absolute: real, relative: toRepoRelative(rootReal, real), rootReal };
+    }
+    catch (error) {
+        if (error instanceof RepositoryError)
+            throw error;
+        // ENOENT: allow listing a missing path to fail later with a clear error.
+        return { absolute: candidate, relative: toRepoRelative(rootReal, candidate), rootReal };
+    }
+}
+export function shouldSkipName(name, includeHidden, exclude) {
+    if (name === "." || name === "..")
+        return true;
+    if (exclude.has(name))
+        return true;
+    if (!includeHidden && name.startsWith("."))
+        return true;
+    return false;
+}
+export function kindFromDirent(dirent) {
+    if (dirent.isSymbolicLink())
+        return "symlink";
+    if (dirent.isDirectory())
+        return "directory";
+    if (dirent.isFile())
+        return "file";
+    return "other";
+}
+export function assertNotAborted(signal) {
+    if (signal?.aborted)
+        throw new RepositoryError("Operation aborted");
+}
+export function assertDeadline(deadlineAt) {
+    if (deadlineAt !== undefined && Date.now() >= deadlineAt) {
+        throw new RepositoryError("Repository operation exceeded time limit");
+    }
+}
+export function isBinaryBuffer(buffer) {
+    const length = Math.min(buffer.length, DEFAULT_BINARY_SNIFF_BYTES);
+    for (let i = 0; i < length; i++) {
+        if (buffer[i] === 0)
+            return true;
+    }
+    return false;
+}
+//# sourceMappingURL=path.js.map

package/dist/repository/search.d.ts

@@ -0,0 +1,9 @@
+import type { RepositorySearchRequest, RepositorySearchResult, ResolvedRepositoryLimits } from "./types.js";
+import type { RepositoryWalk } from "./walk.js";
+export declare function compileSearchPattern(query: string, caseSensitive: boolean, maxPatternBytes: number): {
+    testLine: (line: string) => {
+        column: number;
+    } | null;
+    patternBytes: number;
+};
+export declare function searchLocal(request: RepositorySearchRequest, defaults: ResolvedRepositoryLimits, walk: RepositoryWalk): Promise<RepositorySearchResult>;