@massa-ai/core 1.17.0 → 1.19.0

package/dist/services/file-read/file-metadata.d.ts

@@ -0,0 +1,23 @@
+import type { SymbolGraphService } from "../symbol/symbol-graph.service.js";
+export interface FileMetadata {
+    totalLines: number;
+    language?: string;
+    symbols?: {
+        definitions: number;
+        references: number;
+    };
+    imports?: string[];
+}
+export declare class FileMetadataExtractor {
+    private readonly symbolGraph?;
+    constructor(symbolGraph?: SymbolGraphService | undefined);
+    extractMetadata(content: string, filePath: string, options: {
+        includeSymbols: boolean;
+        includeImports: boolean;
+        projectId?: string;
+        relativePath?: string;
+    }): Promise<FileMetadata>;
+    private detectLanguage;
+    private extractImports;
+}
+//# sourceMappingURL=file-metadata.d.ts.map

package/dist/services/file-read/file-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-metadata.d.ts","sourceRoot":"","sources":["../../../src/services/file-read/file-metadata.ts"],"names":[],"mappings":"AA+BA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAE5E,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE;QACR,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,qBAAa,qBAAqB;IACpB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;gBAAZ,WAAW,CAAC,EAAE,kBAAkB,YAAA;IAEvD,eAAe,CACnB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE;QACP,cAAc,EAAE,OAAO,CAAC;QACxB,cAAc,EAAE,OAAO,CAAC;QACxB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,GACA,OAAO,CAAC,YAAY,CAAC;IAuCxB,OAAO,CAAC,cAAc;IAsCtB,OAAO,CAAC,cAAc;CAwBvB"}

package/dist/services/file-read/file-metadata.js

@@ -0,0 +1,127 @@
+/**
+ * @massa-ai/core - File metadata extraction
+ *
+ * Module 5 of the `tools/read_file.ts` extraction (PR-D, T10). Owns the three
+ * private methods `ReadFileTool` used to carry for describing a file's content:
+ * `extractMetadata` (the composer), `detectLanguage` (extension → language) and
+ * `extractImports` (per-language import scan), together with the `FileMetadata`
+ * shape they produce.
+ *
+ * ALL THREE BODIES ARE MOVED VERBATIM, and so is `interface FileMetadata`.
+ *
+ * IT NAMES SymbolGraphService AND MODULE 4 DOES NOT, WHICH IS THE WHOLE POINT
+ * OF THE 4 → 5 EDGE. `design.md` §5.1 records that `readFileWithCache` calls
+ * `extractMetadata` on two of three paths and that `extractMetadata` reaches
+ * `symbolGraph.listDefinitions`, so a direct edge would make the file CONTENT
+ * cache thread a database-backed collaborator through purely to satisfy this
+ * module. `tasks.md` §4.1 decided the mechanism — module 4 takes a
+ * `(content, filePath, options) => Promise<FileMetadata>` callback — and
+ * rejected inverting the call order on measurement rather than on taste: module
+ * 7 pre-computing metadata is eager on all three paths, so every cache HIT
+ * would newly run a `listDefinitions` query. That is a behavior change inside a
+ * behavior-preserving PR, and the callback keeps the laziness and the
+ * legacy-entry write-back exactly where they were.
+ *
+ * INSTANTIATED PER ReadFileTool, on module 3's precedent. `symbolGraph` is the
+ * tool's own optional constructor parameter, forwarded unchanged; a module
+ * singleton would have to pick one graph for every tool ever constructed, and
+ * the parameter is public surface (`design.md` §3.2, 41 construction sites).
+ */
+import { logger } from "@massa-ai/shared";
+import path from "path";
+export class FileMetadataExtractor {
+    symbolGraph;
+    constructor(symbolGraph) {
+        this.symbolGraph = symbolGraph;
+    }
+    async extractMetadata(content, filePath, options) {
+        const lines = content.split("\n");
+        const language = this.detectLanguage(filePath);
+        const metadata = {
+            totalLines: lines.length,
+            language,
+        };
+        // Extract imports if requested
+        if (options.includeImports && language) {
+            metadata.imports = this.extractImports(lines, language);
+        }
+        // Get symbol metadata if symbol graph available
+        if (options.includeSymbols && this.symbolGraph && options.projectId) {
+            try {
+                // Symbol DB stores relative paths — use original relative path for queries
+                const queryPath = options.relativePath || filePath;
+                const { definitions } = await this.symbolGraph.listDefinitions(options.projectId, {
+                    file: queryPath,
+                    limit: 100,
+                });
+                metadata.symbols = {
+                    definitions: definitions.length,
+                    references: 0, // Would need separate query
+                };
+            }
+            catch (error) {
+                logger.debug("Failed to get symbol metadata", { filePath, error });
+            }
+        }
+        return metadata;
+    }
+    detectLanguage(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        const languageMap = {
+            ".ts": "TypeScript",
+            ".tsx": "TypeScript",
+            ".js": "JavaScript",
+            ".jsx": "JavaScript",
+            ".vue": "Vue",
+            ".py": "Python",
+            ".go": "Go",
+            ".rs": "Rust",
+            ".java": "Java",
+            ".cpp": "C++",
+            ".c": "C",
+            ".h": "C",
+            ".hpp": "C++",
+            ".cs": "C#",
+            ".rb": "Ruby",
+            ".php": "PHP",
+            ".swift": "Swift",
+            ".kt": "Kotlin",
+            ".kts": "Kotlin",
+            ".scala": "Scala",
+            ".md": "Markdown",
+            ".json": "JSON",
+            ".yaml": "YAML",
+            ".yml": "YAML",
+            ".xml": "XML",
+            ".html": "HTML",
+            ".css": "CSS",
+            ".scss": "SCSS",
+            ".sql": "SQL",
+            ".sh": "Shell",
+            ".bash": "Shell",
+        };
+        return languageMap[ext];
+    }
+    extractImports(lines, language) {
+        const imports = [];
+        const importPatterns = {
+            TypeScript: /^(import\s+.*?from\s+['"]|import\s+['"])/,
+            JavaScript: /^(import\s+.*?from\s+['"]|import\s+['"]|require\s*\(\s*['"])/,
+            Python: /^(import\s+|from\s+\S+\s+import)/,
+            Go: /^import\s+/,
+            Java: /^import\s+/,
+            Rust: /^use\s+/,
+        };
+        const pattern = importPatterns[language];
+        if (!pattern)
+            return imports;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (pattern.test(trimmed)) {
+                imports.push(trimmed);
+            }
+        }
+        return imports;
+    }
+}
+//# sourceMappingURL=file-metadata.js.map

package/dist/services/file-read/file-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-metadata.js","sourceRoot":"","sources":["../../../src/services/file-read/file-metadata.ts"],"names":[],"mappings":"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"}

package/dist/services/file-read/line-range.d.ts

@@ -0,0 +1,91 @@
+/**
+ * @massa-ai/core - Line range selection
+ *
+ * Module 6 of the `tools/read_file.ts` extraction (PR-D, T11). Owns everything
+ * that turns a request into the slice of a file the caller actually receives:
+ * `calculateRange` (request → range), `adjustRange` (range → range clamped to
+ * the file), `extractLines` (range → line-numbered text), the `ReadRange` shape
+ * they pass around, and the N9 output cap — the `MASSA_AI_READ_FILE_MAX_LINES`
+ * ceiling together with the clipping block that used to sit inside `handle()`.
+ *
+ * FREE FUNCTIONS, NOT A CLASS, and that is a decision rather than a default.
+ * Modules 2-5 are classes because each owns per-tool state — a Map, a
+ * subscription, an injected collaborator. This module owns none: every function
+ * here is pure, and the one piece of state is a process-wide constant read from
+ * the environment. `services/cache/lru-evict.ts` (module 1) is a bare function
+ * for exactly this reason (`design.md` §5.2). A class would also have to be
+ * constructed in `ReadFileTool`'s constructor, which is the one surface C64 is
+ * about, and would falsely imply per-instance state.
+ *
+ * IT IMPORTS NOTHING AT ALL, which is `lru-evict.ts`'s property and is asserted
+ * by this module's own unit test rather than by any tier rule.
+ *
+ * `LineRangeRequest` EXISTS BECAUSE `ReadFileParams` IS MODULE 7's. `design.md`
+ * §5.1 assigns `interface ReadFileParams` to `read-file.service.ts`, which T12
+ * built and which COMPOSES this module — so importing it here would be a 6 → 7
+ * edge against the composition direction. It exists now and the rule is
+ * unchanged. `calculateRange` reads exactly four fields off its argument, so
+ * this module declares those four and `ReadFileParams` satisfies it
+ * structurally. The alternative Design's module table hides is that module 6
+ * silently depends on module 7's type; naming the subset is what keeps 6
+ * standalone. Same shape as the 4 → 5 edge §4.1 decided, which Design handed to
+ * Tasks explicitly — this one it handed to nobody.
+ *
+ * THE CLIPPED PATH RETURNS UNNUMBERED TEXT, AND THAT IS PRESERVED DELIBERATELY.
+ * `extractLines` prefixes every line with a padded line number; the cap does NOT
+ * slice that string — it re-slices the RAW `lines` array and joins it, so a
+ * clipped response loses the prefixes an unclipped one carries. Found by the
+ * Plan Challenge gate's red-team lens before this file was written, and
+ * confirmed by the evidence audit: no test anywhere asserts content on the
+ * clipped path, so composing this as "extract, then slice the extracted text"
+ * would have been a silent behavior change inside a behavior-preserving PR.
+ * `__tests__/line-range.test.ts` pins both branches' exact format. Whether the
+ * asymmetry is intentional is not PR-D's question — it is logged, not fixed
+ * (`spec.md` §6, R-07's precedent).
+ */
+/** An inclusive, 1-indexed line range. `end` may be `Infinity` before adjustment. */
+export interface ReadRange {
+    start: number;
+    end: number;
+}
+/**
+ * The four fields `calculateRange` reads. `ReadFileParams` (module 7, T12)
+ * satisfies this structurally; declaring the subset is what stops module 6
+ * depending on the module that composes it.
+ */
+export interface LineRangeRequest {
+    offset?: number;
+    limit?: number;
+    lineStart?: number;
+    lineEnd?: number;
+}
+/** The result of selecting lines, after the N9 cap has been applied. */
+export interface LineSelection {
+    /** The text served to the caller. Line-numbered unless `clipped`. */
+    content: string;
+    /** `content.split("\n").length` — recomputed after any clipping. */
+    lineCount: number;
+    /** True when the N9 cap trimmed the selection. Surfaces as `source_clipped`. */
+    clipped: boolean;
+}
+export declare function calculateRange(params: LineRangeRequest): ReadRange;
+export declare function adjustRange(range: ReadRange, totalLines: number): ReadRange;
+export declare function extractLines(lines: string[], range: ReadRange): string;
+/**
+ * Extract the requested lines and apply the N9 cap, returning the clipped flag
+ * rather than mutating the caller's locals.
+ *
+ * The two steps ship as one function because they were never separable at the
+ * call site: before this task the cap read and reassigned the very
+ * `selectedContent` and `selectedLineCount` that the `extractLines` call one
+ * line above it had produced, inside `handle()`. Deliberately unnumbered — a
+ * line citation into `read_file.ts` written here would name a revision that no
+ * longer exists the moment this commit lands, and T12 moves that whole region
+ * again (T8b's de-numbering precedent). Splitting them would mean passing
+ * the already-extracted string and its line count back in as parameters, which
+ * duplicates the `.split("\n")` at the call site and adds an argument derivable
+ * from another. `extractLines` stays exported so its own contract is pinnable
+ * independently.
+ */
+export declare function selectLines(lines: string[], range: ReadRange): LineSelection;
+//# sourceMappingURL=line-range.d.ts.map

package/dist/services/file-read/line-range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-range.d.ts","sourceRoot":"","sources":["../../../src/services/file-read/line-range.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AA2BH,qFAAqF;AACrF,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,wEAAwE;AACxE,MAAM,WAAW,aAAa;IAC5B,qEAAqE;IACrE,OAAO,EAAE,MAAM,CAAC;IAChB,oEAAoE;IACpE,SAAS,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,gBAAgB,GAAG,SAAS,CAsBlE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,CAK3E;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAatE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,GAAG,aAAa,CA0B5E"}

package/dist/services/file-read/line-range.js

@@ -0,0 +1,146 @@
+/**
+ * @massa-ai/core - Line range selection
+ *
+ * Module 6 of the `tools/read_file.ts` extraction (PR-D, T11). Owns everything
+ * that turns a request into the slice of a file the caller actually receives:
+ * `calculateRange` (request → range), `adjustRange` (range → range clamped to
+ * the file), `extractLines` (range → line-numbered text), the `ReadRange` shape
+ * they pass around, and the N9 output cap — the `MASSA_AI_READ_FILE_MAX_LINES`
+ * ceiling together with the clipping block that used to sit inside `handle()`.
+ *
+ * FREE FUNCTIONS, NOT A CLASS, and that is a decision rather than a default.
+ * Modules 2-5 are classes because each owns per-tool state — a Map, a
+ * subscription, an injected collaborator. This module owns none: every function
+ * here is pure, and the one piece of state is a process-wide constant read from
+ * the environment. `services/cache/lru-evict.ts` (module 1) is a bare function
+ * for exactly this reason (`design.md` §5.2). A class would also have to be
+ * constructed in `ReadFileTool`'s constructor, which is the one surface C64 is
+ * about, and would falsely imply per-instance state.
+ *
+ * IT IMPORTS NOTHING AT ALL, which is `lru-evict.ts`'s property and is asserted
+ * by this module's own unit test rather than by any tier rule.
+ *
+ * `LineRangeRequest` EXISTS BECAUSE `ReadFileParams` IS MODULE 7's. `design.md`
+ * §5.1 assigns `interface ReadFileParams` to `read-file.service.ts`, which T12
+ * built and which COMPOSES this module — so importing it here would be a 6 → 7
+ * edge against the composition direction. It exists now and the rule is
+ * unchanged. `calculateRange` reads exactly four fields off its argument, so
+ * this module declares those four and `ReadFileParams` satisfies it
+ * structurally. The alternative Design's module table hides is that module 6
+ * silently depends on module 7's type; naming the subset is what keeps 6
+ * standalone. Same shape as the 4 → 5 edge §4.1 decided, which Design handed to
+ * Tasks explicitly — this one it handed to nobody.
+ *
+ * THE CLIPPED PATH RETURNS UNNUMBERED TEXT, AND THAT IS PRESERVED DELIBERATELY.
+ * `extractLines` prefixes every line with a padded line number; the cap does NOT
+ * slice that string — it re-slices the RAW `lines` array and joins it, so a
+ * clipped response loses the prefixes an unclipped one carries. Found by the
+ * Plan Challenge gate's red-team lens before this file was written, and
+ * confirmed by the evidence audit: no test anywhere asserts content on the
+ * clipped path, so composing this as "extract, then slice the extracted text"
+ * would have been a silent behavior change inside a behavior-preserving PR.
+ * `__tests__/line-range.test.ts` pins both branches' exact format. Whether the
+ * asymmetry is intentional is not PR-D's question — it is logged, not fixed
+ * (`spec.md` §6, R-07's precedent).
+ */
+/**
+ * N9: per-read line ceiling on user-facing read_file output. Default 500;
+ * override via `MASSA_AI_READ_FILE_MAX_LINES`. Invalid/negative/zero
+ * values fall back to 500 (treat invalid as unset). When the requested
+ * range exceeds the cap, `selectedContent` is sliced and `source_clipped:
+ * true` is emitted in the same response. The true total line count is
+ * always surfaced as `lineRange.actual.total` so `omitted = total - shown`
+ * is derivable. Internal enrichment paths (SymbolGraphService.readSnippet
+ * /readContext used by go_to_definition) are NOT capped — see
+ * symbol-graph.service.ts for the exclusion comment.
+ *
+ * STILL EVALUATED ONCE AT MODULE LOAD, which is what keeps the move
+ * behavior-preserving. This module is a dependency of `tools/read_file.ts`, so
+ * it now evaluates strictly EARLIER in the graph — but both happen on the first
+ * import of `read_file.ts`, and a module-level const was never re-readable at
+ * call time in either arrangement. Measured: no test can reach this branch.
+ * `apps/tools-api/src/routes/workspace.test.ts:422` does set this variable, but
+ * it drives `workspace.ts`'s own PER-REQUEST copy of the same IIFE for
+ * `symbol_snippet` (a third, separate read of the same name), never this one.
+ */
+const MASSA_AI_READ_FILE_MAX_LINES = (() => {
+    const v = Number(process.env.MASSA_AI_READ_FILE_MAX_LINES);
+    return Number.isFinite(v) && v > 0 ? Math.floor(v) : 500;
+})();
+export function calculateRange(params) {
+    // Priority: lineStart/lineEnd > offset/limit > entire file
+    if (params.lineStart !== undefined && params.lineEnd !== undefined) {
+        return {
+            start: Math.max(1, params.lineStart),
+            end: params.lineEnd,
+        };
+    }
+    if (params.offset !== undefined) {
+        const offset = Math.max(1, params.offset);
+        const limit = params.limit || 1000;
+        return {
+            start: offset,
+            end: offset + limit - 1,
+        };
+    }
+    return {
+        start: 1,
+        end: Infinity,
+    };
+}
+export function adjustRange(range, totalLines) {
+    const start = Math.max(1, Math.min(range.start, totalLines));
+    const end = range.end === Infinity ? totalLines : Math.min(range.end, totalLines);
+    return { start, end };
+}
+export function extractLines(lines, range) {
+    const start = range.start - 1; // Convert to 0-indexed
+    const end = range.end;
+    const selectedLines = lines.slice(start, end);
+    // Add line numbers for context
+    return selectedLines
+        .map((line, index) => {
+        const lineNum = start + index + 1;
+        return `${lineNum.toString().padStart(6, " ")}: ${line}`;
+    })
+        .join("\n");
+}
+/**
+ * Extract the requested lines and apply the N9 cap, returning the clipped flag
+ * rather than mutating the caller's locals.
+ *
+ * The two steps ship as one function because they were never separable at the
+ * call site: before this task the cap read and reassigned the very
+ * `selectedContent` and `selectedLineCount` that the `extractLines` call one
+ * line above it had produced, inside `handle()`. Deliberately unnumbered — a
+ * line citation into `read_file.ts` written here would name a revision that no
+ * longer exists the moment this commit lands, and T12 moves that whole region
+ * again (T8b's de-numbering precedent). Splitting them would mean passing
+ * the already-extracted string and its line count back in as parameters, which
+ * duplicates the `.split("\n")` at the call site and adds an argument derivable
+ * from another. `extractLines` stays exported so its own contract is pinnable
+ * independently.
+ */
+export function selectLines(lines, range) {
+    let content = extractLines(lines, range);
+    let lineCount = content.split("\n").length;
+    // N9: cap user-facing read_file output at MASSA_AI_READ_FILE_MAX_LINES
+    // (default 500). When the adjusted range exceeds the cap, slice the
+    // content and emit `source_clipped: true` in the same response so the
+    // caller knows lines were omitted. `lineRange.actual.total` keeps the
+    // true total line count so `omitted = total - shown` is derivable.
+    //
+    // NOTE the slice is over `lines`, the RAW array — not over `content`, which
+    // `extractLines` has already numbered. That is the pre-existing shape, moved
+    // verbatim: a clipped response is unnumbered where an unclipped one is
+    // numbered. See this file's header.
+    let clipped = false;
+    if (lineCount > MASSA_AI_READ_FILE_MAX_LINES) {
+        const cappedLines = lines.slice(range.start - 1, range.start - 1 + MASSA_AI_READ_FILE_MAX_LINES);
+        content = cappedLines.join("\n");
+        lineCount = content.split("\n").length;
+        clipped = true;
+    }
+    return { content, lineCount, clipped };
+}
+//# sourceMappingURL=line-range.js.map

package/dist/services/file-read/line-range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-range.js","sourceRoot":"","sources":["../../../src/services/file-read/line-range.ts"],"names":[],"mappings":"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"}

package/dist/services/file-read/path-containment.d.ts

@@ -0,0 +1,49 @@
+import type { ProjectRootCache } from "./project-root-cache.js";
+export declare class PathContainment {
+    private readonly projectRoots;
+    constructor(projectRoots: ProjectRootCache);
+    /**
+     * Resolve a filePath to an absolute path.
+     *
+     * Resolution rules:
+     *  - Absolute path → returned verbatim (still normalized via path.resolve, but base-independent).
+     *  - `projectId` present → resolved against the workspace `project_path`. If the
+     *    workspace lookup fails (no root), this returns null (ambiguous).
+     *  - No `projectId` AND relative `filePath` → returns null. We deliberately do NOT
+     *    fall back to `path.resolve(filePath)` against process.cwd(), because a
+     *    relative path arriving without a projectId is ambiguous and historically
+     *    read from the server's cwd (COVERAGE finding #3). Callers must provide an
+     *    absolute path or a projectId.
+     *
+     * Returns null to signal an ambiguous/unsatisfiable path so `handle()` can map it
+     * to a distinct, clear error instead of the generic "Failed to read file" catch.
+     */
+    resolveFilePath(filePath: string, projectId?: string): Promise<string | null>;
+    /**
+     * Wave 5 FR-12 / AD-W5-006: filesystem-side path containment.
+     *
+     * An absolute path is allowed iff it resolves under one of:
+     *   1. the project root (workspace lookup for projectId, when provided)
+     *   2. process.cwd()
+     *   3. an entry in MASSA_AI_READ_FILE_ROOTS (colon-separated env)
+     *
+     * Project root + cwd are ALWAYS allowed. Outside → teaching error listing
+     * valid roots only (no host path enumeration). The check uses path.relative
+     * to detect traversal out of a root (a result starting with ".." or an
+     * absolute path on another drive means outside).
+     *
+     * The env allowlist is read at CALL TIME (not config-load time) so test
+     * suites and runtime operators can set it without restarting the process.
+     * config.readFile.extraRoots mirrors the same env for introspection.
+     *
+     * Returns { allowed: true } on success, or { allowed: false, error } with a
+     * Wave-4-N6-style teaching error listing the valid roots.
+     */
+    checkPathContainment(absoluteFilePath: string, projectId?: string): Promise<{
+        allowed: true;
+    } | {
+        allowed: false;
+        error: string;
+    }>;
+}
+//# sourceMappingURL=path-containment.d.ts.map

package/dist/services/file-read/path-containment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-containment.d.ts","sourceRoot":"","sources":["../../../src/services/file-read/path-containment.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,YAAY;gBAAZ,YAAY,EAAE,gBAAgB;IAE3D;;;;;;;;;;;;;;;OAeG;IACG,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAmBnF;;;;;;;;;;;;;;;;;;;OAmBG;IACG,oBAAoB,CACxB,gBAAgB,EAAE,MAAM,EACxB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC;QAAE,OAAO,EAAE,IAAI,CAAA;KAAE,GAAG;QAAE,OAAO,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAuClE"}

package/dist/services/file-read/path-containment.js

@@ -0,0 +1,128 @@
+/**
+ * @massa-ai/core - Path resolution and filesystem containment
+ *
+ * Module 2 of the `tools/read_file.ts` extraction (PR-D, T9). Holds the two
+ * security-sensitive path functions `ReadFileTool` used to carry as private
+ * methods: `resolveFilePath` (absolute / projectId / ambiguous) and
+ * `checkPathContainment` (Wave 5 FR-12 / AD-W5-006).
+ *
+ * BOTH BODIES ARE MOVED VERBATIM. RFS-01's gate is structural and cannot tell a
+ * correct delegate from a widened one (RFS-01 AC-6), and `check-core-layering`
+ * cannot either, so this module's only real sensor is its tests —
+ * `__tests__/read-file-containment-shapes.test.ts` (RFS-06, the three mutation
+ * shapes all seven pre-existing containment tests fail to kill) plus
+ * `__tests__/path-containment.test.ts`. Neither the containment predicate nor
+ * the teaching-error text may drift here; RFS-06 AC-2 pins the latter.
+ *
+ * It takes the project-root cache as a constructor dependency. `design.md` §5.1
+ * names the 2 → 3 edge as real and one-directional — "module 2 cannot be
+ * constructed without module 3" — but chooses no mechanism, unlike the 4 → 5
+ * edge it hands to Tasks explicitly (`tasks.md` §4.1). Constructor injection is
+ * chosen over a `getProjectRoot` callback because the two are behaviorally
+ * indistinguishable here (module 3 caches, so neither adds a lookup) and the
+ * direct edge is the one §5.1 describes; the callback shape exists in §4.1/§4.2
+ * to stop a module NAMING a heavy collaborator, and module 3 is neither heavy
+ * nor a type this module would otherwise avoid.
+ */
+import { sanitizeFilePath } from "@massa-ai/shared";
+import path from "path";
+export class PathContainment {
+    projectRoots;
+    constructor(projectRoots) {
+        this.projectRoots = projectRoots;
+    }
+    /**
+     * Resolve a filePath to an absolute path.
+     *
+     * Resolution rules:
+     *  - Absolute path → returned verbatim (still normalized via path.resolve, but base-independent).
+     *  - `projectId` present → resolved against the workspace `project_path`. If the
+     *    workspace lookup fails (no root), this returns null (ambiguous).
+     *  - No `projectId` AND relative `filePath` → returns null. We deliberately do NOT
+     *    fall back to `path.resolve(filePath)` against process.cwd(), because a
+     *    relative path arriving without a projectId is ambiguous and historically
+     *    read from the server's cwd (COVERAGE finding #3). Callers must provide an
+     *    absolute path or a projectId.
+     *
+     * Returns null to signal an ambiguous/unsatisfiable path so `handle()` can map it
+     * to a distinct, clear error instead of the generic "Failed to read file" catch.
+     */
+    async resolveFilePath(filePath, projectId) {
+        if (path.isAbsolute(filePath)) {
+            return path.resolve(filePath);
+        }
+        if (projectId) {
+            const root = await this.projectRoots.getProjectRoot(projectId);
+            if (root) {
+                // Wave 5 FR-12: strip ../ traversal tokens from relative paths before
+                // resolving under the project root. sanitizeFilePath removes ../ and
+                // ..\ segments so a crafted relative path can't escape the root.
+                const cleaned = sanitizeFilePath(filePath);
+                return path.resolve(root, cleaned);
+            }
+            return null;
+        }
+        // Relative path with no projectId — do not guess against cwd.
+        return null;
+    }
+    /**
+     * Wave 5 FR-12 / AD-W5-006: filesystem-side path containment.
+     *
+     * An absolute path is allowed iff it resolves under one of:
+     *   1. the project root (workspace lookup for projectId, when provided)
+     *   2. process.cwd()
+     *   3. an entry in MASSA_AI_READ_FILE_ROOTS (colon-separated env)
+     *
+     * Project root + cwd are ALWAYS allowed. Outside → teaching error listing
+     * valid roots only (no host path enumeration). The check uses path.relative
+     * to detect traversal out of a root (a result starting with ".." or an
+     * absolute path on another drive means outside).
+     *
+     * The env allowlist is read at CALL TIME (not config-load time) so test
+     * suites and runtime operators can set it without restarting the process.
+     * config.readFile.extraRoots mirrors the same env for introspection.
+     *
+     * Returns { allowed: true } on success, or { allowed: false, error } with a
+     * Wave-4-N6-style teaching error listing the valid roots.
+     */
+    async checkPathContainment(absoluteFilePath, projectId) {
+        // Collect valid roots. Project root is included only when actually
+        // resolvable (workspace lookup succeeds); cwd is always available.
+        const roots = [];
+        if (projectId) {
+            const root = await this.projectRoots.getProjectRoot(projectId);
+            if (root)
+                roots.push(path.resolve(root));
+        }
+        roots.push(path.resolve(process.cwd()));
+        // Read the env allowlist at call time so tests/operators can set it
+        // without restarting the process. Colon-separated (POSIX-style).
+        const envRoots = (process.env.MASSA_AI_READ_FILE_ROOTS ?? "")
+            .split(":")
+            .map((s) => s.trim())
+            .filter((s) => s.length > 0);
+        for (const extra of envRoots) {
+            roots.push(path.resolve(extra));
+        }
+        const target = path.resolve(absoluteFilePath);
+        for (const root of roots) {
+            const rel = path.relative(root, target);
+            // Inside iff rel does not start with ".." and is not absolute (cross-drive).
+            if (rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel)) {
+                return { allowed: true };
+            }
+            // Exact root match (rel === "") is also inside.
+            if (rel === "")
+                return { allowed: true };
+        }
+        // Outside all roots → teaching error listing valid roots only.
+        const validRootsList = roots.map((r) => `  - ${r}`).join("\n");
+        return {
+            allowed: false,
+            error: `read_file path containment: "${target}" is outside the allowed roots.\n` +
+                `Valid roots (project root + cwd + MASSA_AI_READ_FILE_ROOTS):\n${validRootsList}\n` +
+                `Provide a filePath that resolves under one of these roots.`,
+        };
+    }
+}
+//# sourceMappingURL=path-containment.js.map

package/dist/services/file-read/path-containment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-containment.js","sourceRoot":"","sources":["../../../src/services/file-read/path-containment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,IAAI,MAAM,MAAM,CAAC;AAGxB,MAAM,OAAO,eAAe;IACG;IAA7B,YAA6B,YAA8B;QAA9B,iBAAY,GAAZ,YAAY,CAAkB;IAAG,CAAC;IAE/D;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,eAAe,CAAC,QAAgB,EAAE,SAAkB;QACxD,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC9B,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAChC,CAAC;QACD,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;YAC/D,IAAI,IAAI,EAAE,CAAC;gBACT,sEAAsE;gBACtE,qEAAqE;gBACrE,iEAAiE;gBACjE,MAAM,OAAO,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAC;gBAC3C,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;YACrC,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;QACD,8DAA8D;QAC9D,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,KAAK,CAAC,oBAAoB,CACxB,gBAAwB,EACxB,SAAkB;QAElB,mEAAmE;QACnE,mEAAmE;QACnE,MAAM,KAAK,GAAa,EAAE,CAAC;QAC3B,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;YAC/D,IAAI,IAAI;gBAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;QAC3C,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QACxC,oEAAoE;QACpE,iEAAiE;QACjE,MAAM,QAAQ,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,wBAAwB,IAAI,EAAE,CAAC;aAC1D,KAAK,CAAC,GAAG,CAAC;aACV,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;aACpB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAC/B,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;YAC7B,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;QAClC,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;QAC9C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YACxC,6EAA6E;YAC7E,IAAI,GAAG,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;gBACjE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;YAC3B,CAAC;YACD,gDAAgD;YAChD,IAAI,GAAG,KAAK,EAAE;gBAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;QAC3C,CAAC;QACD,+DAA+D;QAC/D,MAAM,cAAc,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/D,OAAO;YACL,OAAO,EAAE,KAAK;YACd,KAAK,EACH,gCAAgC,MAAM,mCAAmC;gBACzE,iEAAiE,cAAc,IAAI;gBACnF,4DAA4D;SAC/D,CAAC;IACJ,CAAC;CACF"}

package/dist/services/file-read/project-root-cache.d.ts

@@ -0,0 +1,21 @@
+export declare class ProjectRootCache {
+    private projectRootCache;
+    private readonly ROOT_CACHE_TTL;
+    /**
+     * Maximum entries retained in the cache. Without a cap, an adversarial caller
+     * cycling distinct projectIds grows the map for the process lifetime. Map
+     * preserves INSERTION order in JS; we promote a key to most-recently-used on
+     * GET via delete+set, and evict the oldest key on SET while over the cap.
+     *
+     * Before the extraction this bound was read from `ReadFileTool`'s own
+     * FILE_CACHE_MAX_ENTRIES, which belongs to the file CONTENT cache and which
+     * T10 moved to `file-content-cache.ts`. Both were 512 and neither ever read
+     * the other's value, so naming the bound here retains the same number at the
+     * same call positions.
+     * Mirrors SymbolGraphService.PROJECT_ROOT_CACHE_MAX_ENTRIES.
+     */
+    private readonly PROJECT_ROOT_CACHE_MAX_ENTRIES;
+    constructor();
+    getProjectRoot(projectId: string): Promise<string | null>;
+}
+//# sourceMappingURL=project-root-cache.d.ts.map

package/dist/services/file-read/project-root-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-root-cache.d.ts","sourceRoot":"","sources":["../../../src/services/file-read/project-root-cache.ts"],"names":[],"mappings":"AA2BA,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,gBAAgB,CAAkC;IAC1D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAU;IACzC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,QAAQ,CAAC,8BAA8B,CAAO;;IAehD,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;CAqBhE"}