aiforcecli-local 0.1.0

package/src/workspace.js

@@ -0,0 +1,297 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const DEFAULT_IGNORES = new Set([
+  '.git',
+  '.aiforce-local',
+  'node_modules',
+  'dist',
+  'build',
+  'coverage',
+  '.next',
+  '.venv',
+  'venv',
+]);
+
+const MAX_FILE_BYTES = 1_000_000;
+const MAX_SEARCH_FILES = 2_000;
+const MAX_SEARCH_MATCHES = 200;
+
+export class WorkspaceError extends Error {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = 'WorkspaceError';
+  }
+}
+
+export class Workspace {
+  static async open(root) {
+    const resolved = path.resolve(root);
+    const realRoot = await fs.realpath(resolved).catch(() => null);
+    if (!realRoot) throw new WorkspaceError(`Repository directory does not exist: ${resolved}`);
+    const stat = await fs.stat(realRoot);
+    if (!stat.isDirectory()) throw new WorkspaceError(`Repository path is not a directory: ${realRoot}`);
+    return new Workspace(realRoot);
+  }
+
+  constructor(root) {
+    this.root = root;
+    this.changes = new Map();
+  }
+
+  async listFiles(relativePath = '.', { maxDepth = 6, maxFiles = 500 } = {}) {
+    const start = await this.#resolve(relativePath, { mustExist: true });
+    const stat = await fs.stat(start.absolute);
+    if (!stat.isDirectory()) throw new WorkspaceError(`Not a directory: ${start.relative}`);
+
+    const files = [];
+    const walk = async (directory, depth) => {
+      if (depth > maxDepth || files.length >= maxFiles) return;
+      const entries = await fs.readdir(directory, { withFileTypes: true });
+      entries.sort((a, b) => a.name.localeCompare(b.name));
+      for (const entry of entries) {
+        if (files.length >= maxFiles || DEFAULT_IGNORES.has(entry.name)) continue;
+        if (entry.isFile() && isSensitiveFile(entry.name)) continue;
+        const absolute = path.join(directory, entry.name);
+        if (entry.isSymbolicLink()) continue;
+        if (entry.isDirectory()) await walk(absolute, depth + 1);
+        else if (entry.isFile()) files.push(this.#displayPath(absolute));
+      }
+    };
+    await walk(start.absolute, 0);
+    return { files, truncated: files.length >= maxFiles };
+  }
+
+  async readFile(relativePath, { startLine = 1, endLine = 400 } = {}) {
+    if (!Number.isInteger(startLine) || !Number.isInteger(endLine) || startLine < 1 || endLine < startLine) {
+      throw new WorkspaceError('Line range must use positive integers with end_line >= start_line.');
+    }
+    if (endLine - startLine > 1_000) throw new WorkspaceError('A single read is limited to 1,000 lines.');
+    const target = await this.#resolve(relativePath, { mustExist: true });
+    const stat = await fs.stat(target.absolute);
+    if (!stat.isFile()) throw new WorkspaceError(`Not a file: ${target.relative}`);
+    if (stat.size > MAX_FILE_BYTES) throw new WorkspaceError(`File exceeds ${MAX_FILE_BYTES} byte read limit: ${target.relative}`);
+    const content = await fs.readFile(target.absolute, 'utf8');
+    const lines = content.split(/\r?\n/);
+    return {
+      path: target.relative,
+      startLine,
+      endLine: Math.min(endLine, lines.length),
+      totalLines: lines.length,
+      content: lines.slice(startLine - 1, endLine).join('\n'),
+    };
+  }
+
+  async searchText(query, relativePath = '.') {
+    if (typeof query !== 'string' || !query.trim()) throw new WorkspaceError('Search query is required.');
+    if (query.length > 500) throw new WorkspaceError('Search query is limited to 500 characters.');
+    const { files, truncated: fileLimitReached } = await this.listFiles(relativePath, {
+      maxDepth: 20,
+      maxFiles: MAX_SEARCH_FILES,
+    });
+    const matches = [];
+    for (const file of files) {
+      if (matches.length >= MAX_SEARCH_MATCHES) break;
+      const absolute = path.join(this.root, file);
+      const stat = await fs.stat(absolute).catch(() => null);
+      if (!stat?.isFile() || stat.size > MAX_FILE_BYTES) continue;
+      let content;
+      try {
+        content = await fs.readFile(absolute, 'utf8');
+      } catch {
+        continue;
+      }
+      if (content.includes('\0')) continue;
+      for (const [index, line] of content.split(/\r?\n/).entries()) {
+        if (line.toLowerCase().includes(query.toLowerCase())) {
+          matches.push({ path: file, line: index + 1, text: line.slice(0, 500) });
+          if (matches.length >= MAX_SEARCH_MATCHES) break;
+        }
+      }
+    }
+    return {
+      matches,
+      truncated: fileLimitReached || matches.length >= MAX_SEARCH_MATCHES,
+    };
+  }
+
+  async createFile(relativePath, content) {
+    this.#validateContent(content);
+    const target = await this.#resolve(relativePath, { mustExist: false, forWrite: true });
+    if (await exists(target.absolute)) throw new WorkspaceError(`File already exists: ${target.relative}`);
+    await fs.mkdir(path.dirname(target.absolute), { recursive: true });
+    await fs.writeFile(target.absolute, content, { encoding: 'utf8', flag: 'wx' });
+    this.#track(target.relative, null, content);
+    return { path: target.relative, created: true, bytes: Buffer.byteLength(content) };
+  }
+
+  async replaceText(relativePath, oldText, newText, { replaceAll = false } = {}) {
+    if (typeof oldText !== 'string' || !oldText) throw new WorkspaceError('old_text must be a non-empty string.');
+    this.#validateContent(newText);
+    const target = await this.#resolve(relativePath, { mustExist: true, forWrite: true });
+    const stat = await fs.stat(target.absolute);
+    if (!stat.isFile()) throw new WorkspaceError(`Not a file: ${target.relative}`);
+    if (stat.size > MAX_FILE_BYTES) throw new WorkspaceError(`File exceeds ${MAX_FILE_BYTES} byte edit limit: ${target.relative}`);
+    const content = await fs.readFile(target.absolute, 'utf8');
+    const occurrences = countOccurrences(content, oldText);
+    if (occurrences === 0) throw new WorkspaceError(`old_text was not found in ${target.relative}.`);
+    if (!replaceAll && occurrences !== 1) {
+      throw new WorkspaceError(`old_text occurs ${occurrences} times in ${target.relative}; provide more context or set replace_all.`);
+    }
+    const updated = replaceAll ? content.split(oldText).join(newText) : content.replace(oldText, newText);
+    this.#validateContent(updated);
+    await fs.writeFile(target.absolute, updated, 'utf8');
+    this.#track(target.relative, content, updated);
+    return { path: target.relative, replacements: replaceAll ? occurrences : 1, bytes: Buffer.byteLength(updated) };
+  }
+
+  changeSummary() {
+    return [...this.changes.entries()].map(([file, change]) => ({
+      path: file,
+      status: change.original === null ? 'created' : 'modified',
+      ...lineDelta(change.original, change.current),
+    }));
+  }
+
+  formatChanges({ maxCharacters = 20_000 } = {}) {
+    let output = '';
+    for (const [file, change] of this.changes) {
+      const patch = compactDiff(file, change.original, change.current);
+      if (output.length + patch.length > maxCharacters) {
+        output += '\n... diff output truncated ...\n';
+        break;
+      }
+      output += `${output ? '\n' : ''}${patch}`;
+    }
+    return output;
+  }
+
+  async #resolve(input, { mustExist, forWrite = false }) {
+    if (typeof input !== 'string' || !input.trim()) throw new WorkspaceError('A relative repository path is required.');
+    if (path.isAbsolute(input)) throw new WorkspaceError('Absolute paths are not allowed.');
+    const normalized = input.replaceAll('\\', '/');
+    const segments = normalized.split('/').filter(Boolean);
+    if (segments.includes('.git')) throw new WorkspaceError('Access to .git is not allowed.');
+    if (segments.length && isSensitiveFile(segments.at(-1))) throw new WorkspaceError('Access to credential or secret files is not allowed.');
+    if (forWrite && segments.some((segment) => DEFAULT_IGNORES.has(segment))) {
+      throw new WorkspaceError('Writes to ignored metadata or dependency directories are not allowed.');
+    }
+
+    const absolute = path.resolve(this.root, input);
+    this.#assertInside(absolute);
+    if (mustExist) {
+      const real = await fs.realpath(absolute).catch(() => null);
+      if (!real) throw new WorkspaceError(`Path does not exist: ${this.#displayPath(absolute)}`);
+      this.#assertInside(real);
+      return { absolute: real, relative: this.#displayPath(real) };
+    }
+
+    const parent = await nearestExistingParent(path.dirname(absolute));
+    const realParent = await fs.realpath(parent);
+    this.#assertInside(realParent);
+    return { absolute, relative: this.#displayPath(absolute) };
+  }
+
+  #assertInside(absolute) {
+    const relative = path.relative(this.root, absolute);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+      throw new WorkspaceError('Path escapes the selected repository.');
+    }
+  }
+
+  #displayPath(absolute) {
+    const relative = path.relative(this.root, absolute);
+    return relative ? relative.split(path.sep).join('/') : '.';
+  }
+
+  #validateContent(content) {
+    if (typeof content !== 'string') throw new WorkspaceError('File content must be text.');
+    if (Buffer.byteLength(content) > MAX_FILE_BYTES) throw new WorkspaceError(`File content exceeds ${MAX_FILE_BYTES} bytes.`);
+    if (content.includes('\0')) throw new WorkspaceError('Binary file content is not supported.');
+  }
+
+  #track(file, before, after) {
+    const existing = this.changes.get(file);
+    this.changes.set(file, { original: existing ? existing.original : before, current: after });
+  }
+}
+
+async function nearestExistingParent(start) {
+  let current = start;
+  while (!(await exists(current))) {
+    const parent = path.dirname(current);
+    if (parent === current) throw new WorkspaceError('Cannot resolve a writable parent directory.');
+    current = parent;
+  }
+  return current;
+}
+
+async function exists(target) {
+  return fs.access(target).then(() => true, () => false);
+}
+
+function countOccurrences(content, search) {
+  let count = 0;
+  let offset = 0;
+  while ((offset = content.indexOf(search, offset)) !== -1) {
+    count += 1;
+    offset += search.length;
+  }
+  return count;
+}
+
+function lineDelta(original, current) {
+  if (original === null) return { addedLines: current ? current.split(/\r?\n/).length : 0, removedLines: 0 };
+  const before = original.split(/\r?\n/);
+  const after = current.split(/\r?\n/);
+  let prefix = 0;
+  while (prefix < before.length && prefix < after.length && before[prefix] === after[prefix]) prefix += 1;
+  let suffix = 0;
+  while (
+    suffix < before.length - prefix &&
+    suffix < after.length - prefix &&
+    before[before.length - 1 - suffix] === after[after.length - 1 - suffix]
+  ) suffix += 1;
+  return {
+    addedLines: after.length - prefix - suffix,
+    removedLines: before.length - prefix - suffix,
+  };
+}
+
+function compactDiff(file, original, current) {
+  if (original === null) {
+    return `--- /dev/null\n+++ b/${file}\n@@ created @@\n${current.split(/\r?\n/).map((line) => `+${line}`).join('\n')}\n`;
+  }
+  const before = original.split(/\r?\n/);
+  const after = current.split(/\r?\n/);
+  let prefix = 0;
+  while (prefix < before.length && prefix < after.length && before[prefix] === after[prefix]) prefix += 1;
+  let suffix = 0;
+  while (
+    suffix < before.length - prefix &&
+    suffix < after.length - prefix &&
+    before[before.length - 1 - suffix] === after[after.length - 1 - suffix]
+  ) suffix += 1;
+  const beforeSlice = before.slice(prefix, before.length - suffix);
+  const afterSlice = after.slice(prefix, after.length - suffix);
+  const contextStart = Math.max(0, prefix - 2);
+  const contextBefore = before.slice(contextStart, prefix);
+  const contextAfter = suffix ? after.slice(after.length - suffix, Math.min(after.length, after.length - suffix + 2)) : [];
+  return [
+    `--- a/${file}`,
+    `+++ b/${file}`,
+    `@@ -${prefix + 1},${beforeSlice.length} +${prefix + 1},${afterSlice.length} @@`,
+    ...contextBefore.map((line) => ` ${line}`),
+    ...beforeSlice.map((line) => `-${line}`),
+    ...afterSlice.map((line) => `+${line}`),
+    ...contextAfter.map((line) => ` ${line}`),
+    '',
+  ].join('\n');
+}
+
+function isSensitiveFile(name) {
+  const lower = name.toLowerCase();
+  if (lower === '.env' || (lower.startsWith('.env.') && !['.env.example', '.env.sample', '.env.template'].includes(lower))) return true;
+  if (['.npmrc', '.pypirc', '.netrc', 'id_rsa', 'id_ed25519', 'credentials.json'].includes(lower)) return true;
+  return lower.endsWith('.pem') || lower.endsWith('.key');
+}