@massa-ai/core 1.16.0 → 1.18.0

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":"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"}

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"}

package/dist/services/file-read/project-root-cache.js

@@ -0,0 +1,78 @@
+/**
+ * @massa-ai/core - Project root cache
+ *
+ * Module 3 of the `tools/read_file.ts` extraction (PR-D, T9). Owns the
+ * projectId → canonical project-root path cache that `ReadFileTool` used to
+ * carry as a private field, together with the `indexing:started` subscription
+ * that refreshes it and the LRU cap that bounds it.
+ *
+ * INSTANTIATED PER ReadFileTool, never as a module singleton. Each tool
+ * instance owned its own Map before the move — measured 41 construction sites
+ * across 9 files, 39 of them in tests — so a shared instance would leak cached
+ * roots between independently-constructed tools. That is a behavior change, and
+ * this extraction is behavior-preserving by contract (RFS-02 AC-1).
+ *
+ * ROOT_CACHE_TTL IS DECLARED AND READ NOWHERE, and that is carried across
+ * deliberately rather than repaired. It is the pre-existing state, measured by
+ * `__tests__/read-file-project-root-rename-pin.test.ts` (RFS-02 AC-4): past
+ * 300 s the project root still does not re-resolve, so this cache is
+ * LRU-bounded only and a committed rename leaves it serving the pre-rename
+ * root. PR-D logs that defect and does not fix it — enforcing the TTL here
+ * would be a behavior change inside a behavior-preserving PR.
+ */
+import { logger } from "@massa-ai/shared";
+import { evictOldest } from "../cache/lru-evict.js";
+import { eventBus } from "../events/event-bus.js";
+import { workspaceManager } from "../workspace/workspace-manager.js";
+export class ProjectRootCache {
+    projectRootCache = new Map();
+    ROOT_CACHE_TTL = 300000; // 5 minutes
+    /**
+     * 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.
+     */
+    PROJECT_ROOT_CACHE_MAX_ENTRIES = 512;
+    constructor() {
+        // The API keeps one ReadFileTool instance for the process lifetime. A
+        // guarded reset/reindex may legitimately move the same projectId to a new
+        // canonical root, so refresh the cached root as soon as ETL announces the
+        // new run. Without this, relative reads keep resolving against the prior
+        // workspace path until the API restarts.
+        eventBus.subscribe("indexing:started", ({ projectId, projectPath }) => {
+            this.projectRootCache.delete(projectId);
+            evictOldest(this.projectRootCache, this.PROJECT_ROOT_CACHE_MAX_ENTRIES - 1);
+            this.projectRootCache.set(projectId, projectPath);
+        });
+    }
+    async getProjectRoot(projectId) {
+        const cached = this.projectRootCache.get(projectId);
+        if (cached !== undefined) {
+            // LRU touch: promote this key to most-recently-used.
+            this.projectRootCache.delete(projectId);
+            this.projectRootCache.set(projectId, cached);
+            return cached;
+        }
+        try {
+            const workspace = await workspaceManager.getWorkspace(projectId);
+            if (workspace?.project_path) {
+                evictOldest(this.projectRootCache, this.PROJECT_ROOT_CACHE_MAX_ENTRIES - 1);
+                this.projectRootCache.set(projectId, workspace.project_path);
+                return workspace.project_path;
+            }
+        }
+        catch (error) {
+            logger.warn("Failed to look up project root", { projectId, error: error.message });
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=project-root-cache.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"project-root-cache.js","sourceRoot":"","sources":["../../../src/services/file-read/project-root-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAErE,MAAM,OAAO,gBAAgB;IACnB,gBAAgB,GAAwB,IAAI,GAAG,EAAE,CAAC;IACzC,cAAc,GAAG,MAAM,CAAC,CAAC,YAAY;IACtD;;;;;;;;;;;;OAYG;IACc,8BAA8B,GAAG,GAAG,CAAC;IAEtD;QACE,sEAAsE;QACtE,0EAA0E;QAC1E,0EAA0E;QAC1E,yEAAyE;QACzE,yCAAyC;QACzC,QAAQ,CAAC,SAAS,CAAC,kBAAkB,EAAE,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE,EAAE,EAAE;YACpE,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;YACxC,WAAW,CAAC,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,8BAA8B,GAAG,CAAC,CAAC,CAAC;YAC5E,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,SAAiB;QACpC,MAAM,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACpD,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,qDAAqD;YACrD,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;YACxC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;YAC7C,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,MAAM,gBAAgB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;YACjE,IAAI,SAAS,EAAE,YAAY,EAAE,CAAC;gBAC5B,WAAW,CAAC,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,8BAA8B,GAAG,CAAC,CAAC,CAAC;gBAC5E,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;gBAC7D,OAAO,SAAS,CAAC,YAAY,CAAC;YAChC,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,IAAI,CAAC,gCAAgC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAG,KAAe,CAAC,OAAO,EAAE,CAAC,CAAC;QAChG,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;CACF"}

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

@@ -0,0 +1,68 @@
+import { SymbolGraphService } from "../symbol/symbol-graph.service.js";
+/**
+ * The `read_file` request. Moved verbatim from `tools/read_file.ts`, which
+ * exported exactly one symbol (`ReadFileTool`), so this interface was
+ * module-local before the move and `services/file-read/` is not re-exported from
+ * `services/index.ts` — the move adds **0** names to `@massa-ai/core`'s published
+ * surface.
+ *
+ * `line-range.ts` declares its own four-field `LineRangeRequest` rather than
+ * importing this, and the two MUST NOT be unified (C66): module 6 is composed by
+ * module 7, so importing this there is a 6 -> 7 edge against the composition
+ * direction. `ReadFileParams` satisfies `LineRangeRequest` structurally, so
+ * `calculateRange(p)` below needs no adapter and no call-site change.
+ */
+export interface ReadFileParams {
+    filePath: string;
+    projectId?: string;
+    offset?: number;
+    limit?: number;
+    lineStart?: number;
+    lineEnd?: number;
+    compress?: boolean;
+    targetRatio?: number;
+    format?: "json" | "toon";
+    includeSymbols?: boolean;
+    includeImports?: boolean;
+    fields?: string[];
+}
+/** The six values `handle()`'s prelude used to derive above its own `try`. */
+export interface ReadFileOptions {
+    shouldCompress: boolean;
+    targetRatio: number;
+    format: "json" | "toon";
+    fields?: string[];
+    includeSymbols: boolean;
+    includeImports: boolean;
+}
+/**
+ * A denial carries the exact error string the handler used to return inline; a
+ * success carries the assembled result the handler used to pass straight to
+ * `serializeToolResponse`. `data` is `unknown` because that value is built with
+ * `any` below — see `read()`.
+ */
+export type ReadFileOutcome = {
+    ok: false;
+    error: string;
+} | {
+    ok: true;
+    data: unknown;
+};
+/**
+ * Read the six option fields, in the order and at the call position `handle()`
+ * used. Order is load-bearing only for a `params` whose property getters throw
+ * selectively; position is load-bearing for `null`/`undefined`, which must keep
+ * throwing out of `handle()` rather than being caught. See this file's header.
+ */
+export declare function readFileOptions(p: ReadFileParams): ReadFileOptions;
+export declare class ReadFileService {
+    private compressor;
+    private symbolGraph?;
+    private projectRoots;
+    private pathContainment;
+    private fileMetadata;
+    private fileContent;
+    constructor(symbolGraph?: SymbolGraphService);
+    read(p: ReadFileParams, options: ReadFileOptions): Promise<ReadFileOutcome>;
+}
+//# sourceMappingURL=read-file.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"read-file.service.d.ts","sourceRoot":"","sources":["../../../src/services/file-read/read-file.service.ts"],"names":[],"mappings":"AAqDA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAEvE;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,8EAA8E;AAC9E,MAAM,WAAW,eAAe;IAC9B,cAAc,EAAE,OAAO,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;CACzB;AAED;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GACvB;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC5B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAEhC;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,cAAc,GAAG,eAAe,CAQlE;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,UAAU,CAAiB;IACnC,OAAO,CAAC,WAAW,CAAC,CAAqB;IACzC,OAAO,CAAC,YAAY,CAAmB;IACvC,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,YAAY,CAAwB;IAC5C,OAAO,CAAC,WAAW,CAAmB;gBAE1B,WAAW,CAAC,EAAE,kBAAkB;IAgCtC,IAAI,CAAC,CAAC,EAAE,cAAc,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;CAqJlF"}