@arnilo/prism-coding-agent 0.0.8 → 0.0.96

package/dist/limits.d.ts

@@ -18,5 +18,81 @@ export declare const DEFAULT_SHELL_TIMEOUT_SECONDS = 600;
 export declare const HARD_SHELL_TIMEOUT_SECONDS = 3600;
 export declare const DEFAULT_MAX_TOTAL_OUTPUT_BYTES: number;
 export declare const HARD_MAX_TOTAL_OUTPUT_BYTES: number;
+/** Repository list/search defaults and hard caps (Phase 4 / review-coverage). */
+export declare const DEFAULT_MAX_REPO_DEPTH = 32;
+export declare const HARD_MAX_REPO_DEPTH = 128;
+export declare const DEFAULT_MAX_REPO_ENTRIES = 10000;
+export declare const HARD_MAX_REPO_ENTRIES = 100000;
+export declare const DEFAULT_MAX_REPO_FILES = 10000;
+export declare const HARD_MAX_REPO_FILES = 100000;
+export declare const DEFAULT_MAX_REPO_RESULTS = 1000;
+export declare const HARD_MAX_REPO_RESULTS = 10000;
+export declare const DEFAULT_MAX_REPO_CONCURRENCY = 8;
+export declare const HARD_MAX_REPO_CONCURRENCY = 32;
+export declare const DEFAULT_MAX_SEARCH_SCAN_BYTES: number;
+export declare const HARD_MAX_SEARCH_SCAN_BYTES: number;
+export declare const DEFAULT_MAX_SEARCH_FILE_BYTES: number;
+export declare const HARD_MAX_SEARCH_FILE_BYTES: number;
+export declare const DEFAULT_MAX_SEARCH_MATCHES = 1000;
+export declare const HARD_MAX_SEARCH_MATCHES = 10000;
+export declare const DEFAULT_MAX_SEARCH_PATTERN_BYTES = 512;
+export declare const HARD_MAX_SEARCH_PATTERN_BYTES = 4096;
+export declare const DEFAULT_MAX_SEARCH_LINE_BYTES: number;
+export declare const HARD_MAX_SEARCH_LINE_BYTES: number;
+export declare const DEFAULT_MAX_SEARCH_CONTEXT_LINES = 5;
+export declare const HARD_MAX_SEARCH_CONTEXT_LINES = 20;
+export declare const DEFAULT_MAX_SEARCH_TIME_MS = 30000;
+export declare const HARD_MAX_SEARCH_TIME_MS = 300000;
+export declare const DEFAULT_BINARY_SNIFF_BYTES = 8192;
+/** Structured Git / named-check / PR-handoff defaults and hard caps (Phase 4). */
+export declare const DEFAULT_MAX_GIT_PATHS = 1000;
+export declare const HARD_MAX_GIT_PATHS = 10000;
+export declare const DEFAULT_MAX_GIT_REF_BYTES = 1024;
+export declare const HARD_MAX_GIT_REF_BYTES = 4096;
+export declare const DEFAULT_MAX_GIT_MESSAGE_BYTES: number;
+export declare const HARD_MAX_GIT_MESSAGE_BYTES: number;
+export declare const DEFAULT_MAX_GIT_OUTPUT_BYTES: number;
+export declare const HARD_MAX_GIT_OUTPUT_BYTES: number;
+export declare const DEFAULT_MAX_GIT_DIFF_LINES = 10000;
+export declare const HARD_MAX_GIT_DIFF_LINES = 100000;
+export declare const DEFAULT_MAX_GIT_CHANGED_FILES = 1000;
+export declare const HARD_MAX_GIT_CHANGED_FILES = 10000;
+export declare const DEFAULT_MAX_GIT_PATCH_BYTES: number;
+export declare const HARD_MAX_GIT_PATCH_BYTES: number;
+export declare const DEFAULT_MAX_GIT_WORKTREES = 4;
+export declare const HARD_MAX_GIT_WORKTREES = 16;
+export declare const DEFAULT_GIT_TIMEOUT_MS = 120000;
+export declare const HARD_GIT_TIMEOUT_MS = 600000;
+export declare const DEFAULT_MAX_CHECK_NAMES = 8;
+export declare const HARD_MAX_CHECK_NAMES = 32;
+export declare const DEFAULT_MAX_CHECK_CONCURRENCY = 1;
+export declare const HARD_MAX_CHECK_CONCURRENCY = 4;
+export declare const DEFAULT_CHECK_TIMEOUT_MS: number;
+export declare const HARD_CHECK_TIMEOUT_MS: number;
+export declare const DEFAULT_MAX_CHECK_DIAGNOSTIC_LINES = 2000;
+export declare const HARD_MAX_CHECK_DIAGNOSTIC_LINES = 100000;
+export declare const DEFAULT_MAX_CHECK_OUTPUT_BYTES: number;
+export declare const HARD_MAX_CHECK_OUTPUT_BYTES: number;
+export declare const DEFAULT_MAX_PR_HANDOFF_BYTES: number;
+export declare const HARD_MAX_PR_HANDOFF_BYTES: number;
+export declare const DEFAULT_MAX_PR_COMMITS = 100;
+export declare const HARD_MAX_PR_COMMITS = 1000;
+/** Durable coding plan / checkpoint metadata defaults and hard caps (Phase 4 Task 4). */
+export declare const DEFAULT_MAX_PLAN_BYTES: number;
+export declare const HARD_MAX_PLAN_BYTES: number;
+export declare const DEFAULT_MAX_TODOS = 1000;
+export declare const HARD_MAX_TODOS = 10000;
+export declare const DEFAULT_MAX_TODO_TEXT_BYTES = 512;
+export declare const HARD_MAX_TODO_TEXT_BYTES = 4096;
+export declare const DEFAULT_MAX_CODING_ARTIFACTS = 16;
+export declare const HARD_MAX_CODING_ARTIFACTS = 64;
+export declare const DEFAULT_MAX_CODING_ARTIFACT_BYTES: number;
+export declare const HARD_MAX_CODING_ARTIFACT_BYTES: number;
+export declare const DEFAULT_MAX_CHECK_SUMMARY_BYTES = 1024;
+export declare const HARD_MAX_CHECK_SUMMARY_BYTES = 8192;
+export declare const DEFAULT_MAX_CODING_CHECKPOINT_BYTES: number;
+export declare const HARD_MAX_CODING_CHECKPOINT_BYTES: number;
 /** Validate one configurable coding resource limit. Invalid values fail instead of clamping. */
 export declare function validateCodingLimit(name: string, value: number, hardCap: number): number;
+/** Validate a non-negative integer limit (0 allowed), still capped. */
+export declare function validateCodingLimitAllowZero(name: string, value: number, hardCap: number): number;

package/dist/limits.js

@@ -18,6 +18,80 @@ export const DEFAULT_SHELL_TIMEOUT_SECONDS = 600;
 export const HARD_SHELL_TIMEOUT_SECONDS = 3_600;
 export const DEFAULT_MAX_TOTAL_OUTPUT_BYTES = 64 * 1024 * 1024;
 export const HARD_MAX_TOTAL_OUTPUT_BYTES = 1024 * 1024 * 1024;
+/** Repository list/search defaults and hard caps (Phase 4 / review-coverage). */
+export const DEFAULT_MAX_REPO_DEPTH = 32;
+export const HARD_MAX_REPO_DEPTH = 128;
+export const DEFAULT_MAX_REPO_ENTRIES = 10_000;
+export const HARD_MAX_REPO_ENTRIES = 100_000;
+export const DEFAULT_MAX_REPO_FILES = 10_000;
+export const HARD_MAX_REPO_FILES = 100_000;
+export const DEFAULT_MAX_REPO_RESULTS = 1_000;
+export const HARD_MAX_REPO_RESULTS = 10_000;
+export const DEFAULT_MAX_REPO_CONCURRENCY = 8;
+export const HARD_MAX_REPO_CONCURRENCY = 32;
+export const DEFAULT_MAX_SEARCH_SCAN_BYTES = 64 * 1024 * 1024;
+export const HARD_MAX_SEARCH_SCAN_BYTES = 1024 * 1024 * 1024;
+export const DEFAULT_MAX_SEARCH_FILE_BYTES = 8 * 1024 * 1024;
+export const HARD_MAX_SEARCH_FILE_BYTES = 64 * 1024 * 1024;
+export const DEFAULT_MAX_SEARCH_MATCHES = 1_000;
+export const HARD_MAX_SEARCH_MATCHES = 10_000;
+export const DEFAULT_MAX_SEARCH_PATTERN_BYTES = 512;
+export const HARD_MAX_SEARCH_PATTERN_BYTES = 4_096;
+export const DEFAULT_MAX_SEARCH_LINE_BYTES = 50 * 1024;
+export const HARD_MAX_SEARCH_LINE_BYTES = 1024 * 1024;
+export const DEFAULT_MAX_SEARCH_CONTEXT_LINES = 5;
+export const HARD_MAX_SEARCH_CONTEXT_LINES = 20;
+export const DEFAULT_MAX_SEARCH_TIME_MS = 30_000;
+export const HARD_MAX_SEARCH_TIME_MS = 300_000;
+export const DEFAULT_BINARY_SNIFF_BYTES = 8_192;
+/** Structured Git / named-check / PR-handoff defaults and hard caps (Phase 4). */
+export const DEFAULT_MAX_GIT_PATHS = 1_000;
+export const HARD_MAX_GIT_PATHS = 10_000;
+export const DEFAULT_MAX_GIT_REF_BYTES = 1_024;
+export const HARD_MAX_GIT_REF_BYTES = 4_096;
+export const DEFAULT_MAX_GIT_MESSAGE_BYTES = 64 * 1024;
+export const HARD_MAX_GIT_MESSAGE_BYTES = 256 * 1024;
+export const DEFAULT_MAX_GIT_OUTPUT_BYTES = 4 * 1024 * 1024;
+export const HARD_MAX_GIT_OUTPUT_BYTES = 64 * 1024 * 1024;
+export const DEFAULT_MAX_GIT_DIFF_LINES = 10_000;
+export const HARD_MAX_GIT_DIFF_LINES = 100_000;
+export const DEFAULT_MAX_GIT_CHANGED_FILES = 1_000;
+export const HARD_MAX_GIT_CHANGED_FILES = 10_000;
+export const DEFAULT_MAX_GIT_PATCH_BYTES = 16 * 1024 * 1024;
+export const HARD_MAX_GIT_PATCH_BYTES = 64 * 1024 * 1024;
+export const DEFAULT_MAX_GIT_WORKTREES = 4;
+export const HARD_MAX_GIT_WORKTREES = 16;
+export const DEFAULT_GIT_TIMEOUT_MS = 120_000;
+export const HARD_GIT_TIMEOUT_MS = 600_000;
+export const DEFAULT_MAX_CHECK_NAMES = 8;
+export const HARD_MAX_CHECK_NAMES = 32;
+export const DEFAULT_MAX_CHECK_CONCURRENCY = 1;
+export const HARD_MAX_CHECK_CONCURRENCY = 4;
+export const DEFAULT_CHECK_TIMEOUT_MS = 10 * 60_000;
+export const HARD_CHECK_TIMEOUT_MS = 60 * 60_000;
+export const DEFAULT_MAX_CHECK_DIAGNOSTIC_LINES = 2_000;
+export const HARD_MAX_CHECK_DIAGNOSTIC_LINES = 100_000;
+export const DEFAULT_MAX_CHECK_OUTPUT_BYTES = 4 * 1024 * 1024;
+export const HARD_MAX_CHECK_OUTPUT_BYTES = 64 * 1024 * 1024;
+export const DEFAULT_MAX_PR_HANDOFF_BYTES = 256 * 1024;
+export const HARD_MAX_PR_HANDOFF_BYTES = 1024 * 1024;
+export const DEFAULT_MAX_PR_COMMITS = 100;
+export const HARD_MAX_PR_COMMITS = 1_000;
+/** Durable coding plan / checkpoint metadata defaults and hard caps (Phase 4 Task 4). */
+export const DEFAULT_MAX_PLAN_BYTES = 256 * 1024;
+export const HARD_MAX_PLAN_BYTES = 1024 * 1024;
+export const DEFAULT_MAX_TODOS = 1_000;
+export const HARD_MAX_TODOS = 10_000;
+export const DEFAULT_MAX_TODO_TEXT_BYTES = 512;
+export const HARD_MAX_TODO_TEXT_BYTES = 4_096;
+export const DEFAULT_MAX_CODING_ARTIFACTS = 16;
+export const HARD_MAX_CODING_ARTIFACTS = 64;
+export const DEFAULT_MAX_CODING_ARTIFACT_BYTES = 256 * 1024 * 1024;
+export const HARD_MAX_CODING_ARTIFACT_BYTES = 2 * 1024 * 1024 * 1024;
+export const DEFAULT_MAX_CHECK_SUMMARY_BYTES = 1_024;
+export const HARD_MAX_CHECK_SUMMARY_BYTES = 8_192;
+export const DEFAULT_MAX_CODING_CHECKPOINT_BYTES = 64 * 1024;
+export const HARD_MAX_CODING_CHECKPOINT_BYTES = 512 * 1024;
 /** Validate one configurable coding resource limit. Invalid values fail instead of clamping. */
 export function validateCodingLimit(name, value, hardCap) {
     if (!Number.isSafeInteger(value) || value < 1 || value > hardCap) {
@@ -25,4 +99,11 @@ export function validateCodingLimit(name, value, hardCap) {
     }
     return value;
 }
+/** Validate a non-negative integer limit (0 allowed), still capped. */
+export function validateCodingLimitAllowZero(name, value, hardCap) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > hardCap) {
+        throw new Error(`${name} must be a non-negative safe integer at most ${hardCap}`);
+    }
+    return value;
+}
 //# sourceMappingURL=limits.js.map

package/dist/list.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `repo_list` tool: bounded native repository listing.
+ */
+import type { ExecutionPolicy, ToolDefinition } from "@arnilo/prism";
+import { type RepositoryLimitOptions, type RepositoryOperations } from "./repository.js";
+export interface ListToolOptions {
+    executionPolicy?: ExecutionPolicy;
+    operations?: RepositoryOperations;
+    repository?: RepositoryLimitOptions;
+    maxDepth?: number;
+    maxResults?: number;
+    exclude?: readonly string[];
+}
+export declare function createRepoListTool(cwd: string, options?: ListToolOptions): ToolDefinition;

package/dist/list.js

@@ -0,0 +1,144 @@
+import { enforceExecutionPolicy } from "./execution-policy.js";
+import { createLocalRepositoryOperations, resolveRepositoryLimits, RepositoryError, } from "./repository.js";
+import { HARD_MAX_REPO_DEPTH, HARD_MAX_REPO_RESULTS, validateCodingLimit, validateCodingLimitAllowZero } from "./limits.js";
+function errorResult(toolCallId, message) {
+    return {
+        toolCallId,
+        name: "repo_list",
+        content: [{ type: "text", text: message }],
+        error: { message },
+    };
+}
+function formatListText(result) {
+    if (result.entries.length === 0) {
+        return result.truncated
+            ? `[truncated by ${result.truncatedBy ?? "limit"} before any entries]`
+            : "(no entries)";
+    }
+    const lines = result.entries.map((entry) => {
+        const size = entry.size !== undefined ? `\t${entry.size}` : "";
+        return `${entry.kind}\t${entry.path}${size}`;
+    });
+    if (result.truncated) {
+        const next = result.nextOffset !== undefined ? ` Use offset=${result.nextOffset} to continue.` : "";
+        lines.push(`[truncated by ${result.truncatedBy ?? "limit"}.${next}]`);
+    }
+    return lines.join("\n");
+}
+export function createRepoListTool(cwd, options) {
+    const limits = resolveRepositoryLimits({
+        ...options?.repository,
+        maxDepth: options?.maxDepth ?? options?.repository?.maxDepth,
+        maxResults: options?.maxResults ?? options?.repository?.maxResults,
+        exclude: options?.exclude ?? options?.repository?.exclude,
+    });
+    const ops = options?.operations ?? createLocalRepositoryOperations(limits);
+    return {
+        name: "repo_list",
+        description: `List repository entries under the workspace with deterministic relative paths. Skips hidden names and excluded basenames (default: ${limits.exclude.join(", ")}) unless overridden. Does not follow symlinks. Results paginate with offset/maxResults (default ${limits.maxResults}). Depth default ${limits.maxDepth}.`,
+        parameters: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Workspace-relative directory or file to list (default: workspace root)",
+                },
+                includeHidden: {
+                    type: "boolean",
+                    description: "Include dotfile/dotdir names (default false). Excluded basenames still apply.",
+                },
+                maxDepth: {
+                    type: "number",
+                    description: `Maximum directory depth to descend (default ${limits.maxDepth}, hard ${HARD_MAX_REPO_DEPTH})`,
+                },
+                maxResults: {
+                    type: "number",
+                    description: `Maximum entries returned in this page (default ${limits.maxResults}, hard ${HARD_MAX_REPO_RESULTS})`,
+                },
+                offset: {
+                    type: "number",
+                    description: "Number of entries to skip before retaining results (default 0)",
+                },
+            },
+            additionalProperties: false,
+        },
+        async execute(args, context) {
+            const toolCallId = context.toolCallId;
+            if (context.signal?.aborted)
+                return errorResult(toolCallId, "Operation aborted");
+            const path = typeof args.path === "string" ? args.path : undefined;
+            const includeHidden = args.includeHidden === true;
+            let maxDepth;
+            let maxResults;
+            let offset = 0;
+            try {
+                if (args.maxDepth !== undefined) {
+                    maxDepth = validateCodingLimit("maxDepth", args.maxDepth, HARD_MAX_REPO_DEPTH);
+                }
+                if (args.maxResults !== undefined) {
+                    maxResults = validateCodingLimit("maxResults", args.maxResults, HARD_MAX_REPO_RESULTS);
+                }
+                if (args.offset !== undefined) {
+                    offset = validateCodingLimitAllowZero("offset", args.offset, limits.maxEntries);
+                }
+            }
+            catch (error) {
+                return errorResult(toolCallId, error instanceof Error ? error.message : String(error));
+            }
+            const policyCheck = await enforceExecutionPolicy(options?.executionPolicy, {
+                kind: "repo_list",
+                operation: "list",
+                paths: [path ? path : cwd],
+                risk: "low",
+                metadata: {
+                    includeHidden,
+                    maxDepth,
+                    maxResults,
+                    offset,
+                    sessionId: context.sessionId,
+                    runId: context.runId,
+                    signal: context.signal,
+                },
+            }, toolCallId, "repo_list");
+            if (!policyCheck.allowed)
+                return policyCheck.result;
+            try {
+                const result = await ops.list({
+                    root: cwd,
+                    path,
+                    includeHidden,
+                    exclude: limits.exclude,
+                    maxDepth: maxDepth ?? limits.maxDepth,
+                    maxResults: maxResults ?? limits.maxResults,
+                    offset,
+                    signal: context.signal,
+                    deadlineMs: limits.maxTimeMs,
+                });
+                return {
+                    toolCallId,
+                    name: "repo_list",
+                    content: [{ type: "text", text: formatListText(result) }],
+                    metadata: {
+                        truncated: result.truncated,
+                        truncatedBy: result.truncatedBy,
+                        offset: result.offset,
+                        nextOffset: result.nextOffset,
+                        returned: result.entries.length,
+                        scannedEntries: result.scannedEntries,
+                        scannedFiles: result.scannedFiles,
+                        entries: result.entries,
+                    },
+                };
+            }
+            catch (error) {
+                const message = error instanceof RepositoryError
+                    ? error.message
+                    : error instanceof Error
+                        ? error.message
+                        : String(error);
+                return errorResult(toolCallId, message);
+            }
+        },
+    };
+}
+//# sourceMappingURL=list.js.map

package/dist/repository.d.ts

@@ -0,0 +1,119 @@
+export type RepoEntryKind = "file" | "directory" | "symlink" | "other";
+export interface RepoListEntry {
+    readonly path: string;
+    readonly kind: RepoEntryKind;
+    readonly size?: number;
+}
+export interface RepositoryListResult {
+    readonly entries: readonly RepoListEntry[];
+    readonly truncated: boolean;
+    readonly truncatedBy: "results" | "entries" | "files" | "depth" | "time" | "abort" | null;
+    readonly scannedEntries: number;
+    readonly scannedFiles: number;
+    readonly nextOffset?: number;
+    readonly offset: number;
+}
+export interface RepositorySearchMatch {
+    readonly path: string;
+    readonly line: number;
+    readonly column: number;
+    readonly text: string;
+    readonly before: readonly string[];
+    readonly after: readonly string[];
+}
+export interface RepositorySearchResult {
+    readonly matches: readonly RepositorySearchMatch[];
+    readonly truncated: boolean;
+    readonly truncatedBy: "matches" | "scan" | "file" | "entries" | "files" | "depth" | "time" | "abort" | "pattern" | null;
+    readonly scannedBytes: number;
+    readonly scannedFiles: number;
+    readonly scannedEntries: number;
+    readonly filesSkippedBinary: number;
+    readonly filesSkippedOversize: number;
+}
+export interface ResolvedRepositoryLimits {
+    readonly maxDepth: number;
+    readonly maxEntries: number;
+    readonly maxFiles: number;
+    readonly maxResults: number;
+    readonly maxConcurrency: number;
+    readonly maxScanBytes: number;
+    readonly maxFileBytes: number;
+    readonly maxMatches: number;
+    readonly maxPatternBytes: number;
+    readonly maxLineBytes: number;
+    readonly maxContextLines: number;
+    readonly maxTimeMs: number;
+    readonly binarySniffBytes: number;
+    readonly exclude: readonly string[];
+}
+export interface RepositoryLimitOptions {
+    readonly maxDepth?: number;
+    readonly maxEntries?: number;
+    readonly maxFiles?: number;
+    readonly maxResults?: number;
+    readonly maxConcurrency?: number;
+    readonly maxScanBytes?: number;
+    readonly maxFileBytes?: number;
+    readonly maxMatches?: number;
+    readonly maxPatternBytes?: number;
+    readonly maxLineBytes?: number;
+    readonly maxContextLines?: number;
+    readonly maxTimeMs?: number;
+    /** Basename denylist skipped during descent (default `.git`, `node_modules`, `dist`). */
+    readonly exclude?: readonly string[];
+}
+export interface RepositoryListRequest {
+    readonly root: string;
+    readonly path?: string;
+    readonly includeHidden?: boolean;
+    readonly exclude?: readonly string[];
+    readonly maxDepth?: number;
+    readonly maxResults?: number;
+    readonly offset?: number;
+    readonly signal?: AbortSignal;
+    readonly deadlineMs?: number;
+}
+export interface RepositorySearchRequest {
+    readonly root: string;
+    readonly query: string;
+    readonly path?: string;
+    readonly mode?: "literal" | "regex";
+    readonly caseSensitive?: boolean;
+    readonly includeHidden?: boolean;
+    readonly exclude?: readonly string[];
+    readonly context?: number;
+    readonly maxMatches?: number;
+    readonly signal?: AbortSignal;
+    readonly deadlineMs?: number;
+}
+export interface RepositoryOperations {
+    list(request: RepositoryListRequest): Promise<RepositoryListResult>;
+    search(request: RepositorySearchRequest): Promise<RepositorySearchResult>;
+}
+export declare const DEFAULT_REPO_EXCLUDE: readonly string[];
+export declare class RepositoryError extends Error {
+    readonly code = "ERR_PRISM_REPOSITORY";
+    constructor(message: string);
+}
+export declare function resolveRepositoryLimits(options?: RepositoryLimitOptions): ResolvedRepositoryLimits;
+/** Normalize a workspace-relative path to stable forward-slash form. */
+export declare function toRepoRelative(root: string, absolutePath: string): string;
+/**
+ * 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 isBinaryBuffer(buffer: Buffer): boolean;
+export declare function compileSearchPattern(query: string, mode: "literal" | "regex", caseSensitive: boolean, maxPatternBytes: number): {
+    testLine: (line: string) => {
+        column: number;
+    } | null;
+    patternBytes: number;
+};
+/** Local filesystem repository operations (default backend). */
+export declare function createLocalRepositoryOperations(limits?: RepositoryLimitOptions): RepositoryOperations;