@dotdotgod/context 0.6.2 → 0.6.4

package/README.md

@@ -79,7 +79,7 @@ This bounded retrieval keeps indexed runtime material separate from maintained p
 
 ## Structural Ingestion
 
-Local `index` accepts one project-contained regular text file or directory. A file is limited to **25 MiB**. Directory defaults allow at most depth 16, 10,000 visited entries, 1,000 indexed files, 25 MiB per file, and 100 MiB in aggregate; callers may configure the traversal limits explicitly.
+Local `index` accepts one regular text file or explicitly requested directory, including external paths. Project roots are defaults, not access boundaries. A file is limited to **25 MiB**. Directory defaults allow at most depth 16, 10,000 visited entries, 1,000 indexed files, 25 MiB per file, and 100 MiB in aggregate; callers may configure the traversal limits explicitly.
 
 Directory ingestion:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdotgod/context",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "Local-first MCP execution, indexing, and retrieval runtime for dotdotgod adapters.",
   "type": "module",
   "license": "Elastic-2.0",
@@ -28,7 +28,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.2",
     "zod": "^3.25.76",
-    "@dotdotgod/cli": "0.6.2"
+    "@dotdotgod/cli": "0.6.4"
   },
   "engines": {
     "node": ">=22.5.0"

package/src/directory-ingestion.mjs

@@ -1,5 +1,5 @@
 import { closeSync, constants, fstatSync, lstatSync, openSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
-import { isAbsolute, relative, resolve, sep } from 'node:path';
+import { relative, resolve, sep } from 'node:path';
 
 const DEFAULT_LIMITS = Object.freeze({
   maxDepth: 16,
@@ -9,11 +9,6 @@ const DEFAULT_LIMITS = Object.freeze({
   maxAggregateBytes: 100 * 1024 * 1024,
 });
 
-function inside(base, target) {
-  const rel = relative(base, target);
-  return rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
-}
-
 function relativePath(base, target) {
   return relative(base, target).split(sep).join('/');
 }
@@ -72,10 +67,7 @@ function snapshot(path, target, stat, symlink) {
 export function walkDirectoryManifest(options = {}) {
   const root = realpathSync(resolve(options.root || process.cwd()));
   const requested = resolve(root, options.path ?? '.');
-  if (!inside(root, requested)) throw new Error(`Directory escapes project root: ${options.path}`);
-  if (lstatSync(requested).isSymbolicLink()) throw new Error(`Directory symlinks are not followed: ${options.path ?? '.'}`);
   const directory = realpathSync(requested);
-  if (!inside(root, directory)) throw new Error(`Directory escapes project root: ${options.path}`);
   if (!statSync(directory).isDirectory()) throw new Error(`Not a directory: ${options.path ?? '.'}`);
 
   const policy = normalizeOptions(options);
@@ -113,7 +105,6 @@ export function walkDirectoryManifest(options = {}) {
         let targetStat;
         try {
           target = realpathSync(absolutePath);
-          if (!inside(root, target)) { skip(path, 'symlink-outside-root'); continue; }
           targetStat = statSync(target);
         } catch { skip(path, 'symlink-unresolvable'); continue; }
         if (targetStat.isDirectory()) { skip(path, 'directory-symlink'); continue; }
@@ -152,9 +143,7 @@ function matchesIdentity(stat, identity) {
 }
 
 export function verifyManifestFile(entry, root) {
-  const base = realpathSync(resolve(root));
   const target = realpathSync(entry.absolutePath);
-  if (!inside(base, target)) throw new Error(`Manifest file escapes project root: ${entry.path}`);
   const stat = statSync(target);
   if (!stat.isFile()) throw new Error(`Manifest entry is not a regular file: ${entry.path}`);
   if (!matchesIdentity(stat, entry.identity ?? {})) throw new Error(`Manifest file changed before indexing: ${entry.path}`);

package/src/index.d.ts

@@ -1,6 +1,6 @@
 export function formatToolMarkdown(name: string, value: unknown): string;
 export type ContextScope = 'transient' | 'session' | 'project';
-export type DirectoryReason = 'excluded-path' | 'extension-filter' | 'file-byte-limit' | 'file-count-limit' | 'aggregate-byte-limit' | 'visited-entry-limit' | 'depth-limit' | 'file-symlink' | 'directory-symlink' | 'symlink-outside-root' | 'symlink-unresolvable' | 'special-file' | 'directory-read-failed' | 'entry-stat-failed' | 'index-failed';
+export type DirectoryReason = 'excluded-path' | 'extension-filter' | 'file-byte-limit' | 'file-count-limit' | 'aggregate-byte-limit' | 'visited-entry-limit' | 'depth-limit' | 'file-symlink' | 'directory-symlink' | 'symlink-unresolvable' | 'special-file' | 'directory-read-failed' | 'entry-stat-failed' | 'index-failed';
 export interface EnvironmentPolicy { mode: 'inherit-filtered-v1' | 'allowlist-v1'; platform: 'win32' | 'darwin' | 'posix'; allowedNames?: string[]; filteredNames: string[] }
 export interface DirectoryManifestEntry { path: string; absolutePath: string; size: number; identity: { dev: number; ino: number; size: number; mtimeMs: number }; symlink: boolean }
 export interface DirectoryManifest { root: string; directory: string; files: DirectoryManifestEntry[]; skipped: Array<{ path: string; reason: DirectoryReason }>; failed: Array<{ path: string; reason: DirectoryReason; error?: string }>; aborted: boolean; truncated: boolean; visitedEntries: number; aggregateBytes: number }

package/src/paths.mjs

@@ -1,23 +1,16 @@
 import { realpathSync } from 'node:fs';
-import { isAbsolute, relative, resolve } from 'node:path';
+import { resolve } from 'node:path';
 
-function assertWithinRoot(base, target, candidate) {
-  const rel = relative(base, target);
-  if (rel === '..' || rel.startsWith(`..${process.platform === 'win32' ? '\\' : '/'}`) || isAbsolute(rel)) {
-    throw new Error(`Path escapes project root: ${candidate}`);
-  }
-}
+// Legacy export names: root is a relative-path default, not an access boundary.
 
 export function resolveWithinRoot(root, candidate = '.') {
   const base = resolve(root || process.cwd());
   const target = resolve(base, candidate);
-  assertWithinRoot(base, target, candidate);
   return target;
 }
 
 export function resolveExistingWithinRoot(root, candidate = '.') {
   const base = realpathSync(resolve(root || process.cwd()));
   const target = realpathSync(resolveWithinRoot(base, candidate));
-  assertWithinRoot(base, target, candidate);
   return target;
 }