@arnilo/prism-coding-agent 0.0.8 → 0.0.11

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;