nova-terminal-assistant 0.1.0

package/src/core/tools/impl/ListDirectoryTool.ts

@@ -0,0 +1,142 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import type { ToolHandler, ToolHandlerInput, ToolHandlerOutput } from '../../types/tools.js';
+import { ToolError } from '../../types/errors.js';
+
+/** Maximum entries to return before truncating with guidance */
+const MAX_ENTRIES = 500;
+
+export const listDirectoryHandler: ToolHandler = async (input: ToolHandlerInput): Promise<ToolHandlerOutput> => {
+  const { dirPath, recursive = false, includeHidden = false, pattern, depth, limit } = input.params as {
+    dirPath: string;
+    recursive?: boolean;
+    includeHidden?: boolean;
+    pattern?: string;
+    depth?: number;
+    limit?: number;
+  };
+
+  const resolvedPath = path.resolve(dirPath);
+  const maxEntries = limit || MAX_ENTRIES;
+
+  try {
+    const stat = await fs.stat(resolvedPath);
+    if (!stat.isDirectory()) {
+      throw new ToolError(`Path is not a directory: ${dirPath}`, 'list_directory', undefined, { 
+        code: 'NOT_DIRECTORY',
+        suggestion: `Use read_file to read a file, or specify a directory path.`
+      });
+    }
+
+    const entries: Array<{ name: string; path: string; isDirectory: boolean; size: number }> = [];
+    let totalFound = 0;
+    let truncated = false;
+
+    async function walk(currentDir: string, currentDepth: number): Promise<void> {
+      if (depth !== undefined && currentDepth > depth) return;
+
+      const items = await fs.readdir(currentDir, { withFileTypes: true });
+
+      for (const item of items) {
+        if (!includeHidden && item.name.startsWith('.')) continue;
+
+        if (pattern && !matchGlob(item.name, pattern)) continue;
+
+        totalFound++;
+
+        if (entries.length >= maxEntries) {
+          truncated = true;
+          continue; // Keep counting but don't add more entries
+        }
+
+        const fullPath = path.join(currentDir, item.name);
+        let size = 0;
+
+        if (item.isFile()) {
+          try {
+            const itemStat = await fs.stat(fullPath);
+            size = itemStat.size;
+          } catch {
+            // Skip files we can't stat
+          }
+        }
+
+        entries.push({
+          name: item.name,
+          path: fullPath,
+          isDirectory: item.isDirectory(),
+          size,
+        });
+
+        if (recursive && item.isDirectory()) {
+          await walk(fullPath, currentDepth + 1);
+        }
+      }
+    }
+
+    await walk(resolvedPath, 0);
+
+    const output = entries
+      .map((entry) => {
+        const type = entry.isDirectory ? 'DIR ' : 'FILE';
+        const sizeStr = entry.isDirectory ? '        ' : String(entry.size).padStart(8);
+        return `${type} ${sizeStr}  ${entry.path}`;
+      })
+      .join('\n');
+
+    const dirCount = entries.filter((e) => e.isDirectory).length;
+    const fileCount = entries.length - dirCount;
+
+    // Build content with truncation guidance
+    let content = output;
+    
+    if (truncated) {
+      content += `\n\n[TRUNCATED: Showing ${entries.length} of ${totalFound} items.]`;
+      content += `\n[To see more, use one of these approaches:]`;
+      content += `\n  • Use pattern filter: list_directory with pattern="*.ts"`;
+      content += `\n  • Increase limit: list_directory with limit=1000`;
+      content += `\n  • Use non-recursive: list_directory with recursive=false`;
+      content += `\n  • Search specific files: search_file with pattern="**/*.ts"`;
+    } else {
+      content += `\n\n${entries.length} item(s): ${fileCount} file(s), ${dirCount} director${dirCount === 1 ? 'y' : 'ies'}`;
+    }
+
+    return {
+      content,
+      metadata: {
+        path: resolvedPath,
+        totalEntries: entries.length,
+        totalFound: totalFound,
+        truncated,
+        files: fileCount,
+        directories: dirCount,
+        suggestion: truncated ? 'Use pattern, limit, or non-recursive mode to narrow results' : undefined,
+      },
+    };
+  } catch (err) {
+    if (err instanceof ToolError) throw err;
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === 'ENOENT') {
+      throw new ToolError(`Directory not found: ${dirPath}`, 'list_directory', undefined, { 
+        code,
+        suggestion: `Check the path exists. Use list_directory "." to see current directory.`
+      });
+    }
+    if (code === 'EACCES') {
+      throw new ToolError(`Permission denied: ${dirPath}`, 'list_directory', undefined, { 
+        code,
+        suggestion: `Check directory permissions or try a different path.`
+      });
+    }
+    throw new ToolError(`Failed to list directory: ${(err as Error).message}`, 'list_directory');
+  }
+};
+
+function matchGlob(name: string, pattern: string): boolean {
+  // Simple glob matching: * matches any chars, ? matches single char
+  const regexStr = pattern
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*/g, '.*')
+    .replace(/\?/g, '.');
+  return new RegExp(`^${regexStr}$`, 'i').test(name);
+}

package/src/core/tools/impl/MemoryTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryTool.d.ts","sourceRoot":"","sources":["MemoryTool.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAuC,MAAM,sBAAsB,CAAC;AAmC7F,eAAO,MAAM,iBAAiB,EAAE,WAkC/B,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,WA2BhC,CAAC"}

package/src/core/tools/impl/MemoryTool.ts

@@ -0,0 +1,102 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import type { ToolHandler, ToolHandlerInput, ToolHandlerOutput } from '../../types/tools.js';
+
+interface MemoryStore {
+  _data: Record<string, { value: string; expires?: number; tags?: string[]; createdAt: number }>;
+}
+
+function getMemoryPath(scope: string): string {
+  const homeDir = os.homedir();
+  switch (scope) {
+    case 'global':
+      return path.join(homeDir, '.nova', 'memory.json');
+    case 'project':
+      return path.join(process.cwd(), '.nova', 'memory.json');
+    case 'session':
+    default:
+      return path.join(os.tmpdir(), 'nova-memory', `session-${process.pid}.json`);
+  }
+}
+
+async function loadStore(scope: string): Promise<MemoryStore> {
+  const filePath = getMemoryPath(scope);
+  try {
+    const data = await fs.readFile(filePath, 'utf-8');
+    return JSON.parse(data) as MemoryStore;
+  } catch {
+    return { _data: {} };
+  }
+}
+
+async function saveStore(scope: string, store: MemoryStore): Promise<void> {
+  const filePath = getMemoryPath(scope);
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, JSON.stringify(store, null, 2), 'utf-8');
+}
+
+export const memoryReadHandler: ToolHandler = async (input: ToolHandlerInput): Promise<ToolHandlerOutput> => {
+  const { key, scope = 'session' } = input.params as { key: string; scope?: string };
+
+  const store = await loadStore(scope);
+  const entry = store._data[key];
+
+  if (!entry) {
+    return {
+      content: `No memory entry found for key: "${key}" (scope: ${scope})`,
+      metadata: { key, scope, found: false },
+    };
+  }
+
+  // Check TTL
+  if (entry.expires && Date.now() > entry.expires) {
+    delete store._data[key];
+    await saveStore(scope, store);
+    return {
+      content: `Memory entry "${key}" has expired`,
+      metadata: { key, scope, found: false, expired: true },
+    };
+  }
+
+  return {
+    content: entry.value,
+    metadata: {
+      key,
+      scope,
+      found: true,
+      tags: entry.tags,
+      createdAt: entry.createdAt,
+      expires: entry.expires,
+    },
+  };
+};
+
+export const memoryWriteHandler: ToolHandler = async (input: ToolHandlerInput): Promise<ToolHandlerOutput> => {
+  const { key, value, scope = 'session', ttl, tags } = input.params as {
+    key: string;
+    value: string;
+    scope?: string;
+    ttl?: number;
+    tags?: string[];
+  };
+
+  const store = await loadStore(scope);
+  const exists = !!store._data[key];
+
+  store._data[key] = {
+    value,
+    expires: ttl ? Date.now() + ttl : undefined,
+    tags,
+    createdAt: exists ? (store._data[key]?.createdAt ?? Date.now()) : Date.now(),
+  };
+
+  await saveStore(scope, store);
+
+  return {
+    content: exists
+      ? `Updated memory entry "${key}" (scope: ${scope})`
+      : `Created memory entry "${key}" (scope: ${scope})`,
+    metadata: { key, scope, updated: exists, ttl, tags },
+  };
+};

package/src/core/tools/impl/ReadFileTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadFileTool.d.ts","sourceRoot":"","sources":["ReadFileTool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAuC,MAAM,sBAAsB,CAAC;AAG7F,eAAO,MAAM,eAAe,EAAE,WAoD7B,CAAC"}

package/src/core/tools/impl/ReadFileTool.ts

@@ -0,0 +1,58 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import type { ToolHandler, ToolHandlerInput, ToolHandlerOutput } from '../../types/tools.js';
+import { ToolError } from '../../types/errors.js';
+
+export const readFileHandler: ToolHandler = async (input: ToolHandlerInput): Promise<ToolHandlerOutput> => {
+  const { filePath, offset, limit, encoding = 'utf-8' } = input.params as {
+    filePath: string;
+    offset?: number;
+    limit?: number;
+    encoding?: BufferEncoding;
+  };
+
+  try {
+    const resolvedPath = path.resolve(filePath);
+    const content = await fs.readFile(resolvedPath, { encoding });
+    const lines = content.split('\n');
+
+    let selectedLines = lines;
+    let lineInfo = '';
+
+    if (offset !== undefined || limit !== undefined) {
+      const start = offset !== undefined ? Math.max(0, offset - 1) : 0; // 1-based to 0-based
+      const end = limit !== undefined ? start + limit : lines.length;
+      selectedLines = lines.slice(start, end);
+      lineInfo = ` (lines ${start + 1}-${Math.min(end, lines.length)} of ${lines.length})`;
+    }
+
+    const output = selectedLines.map((line, i) => {
+      const lineNum = offset !== undefined ? offset + i : i + 1;
+      const numStr = String(lineNum).padStart(6, ' ');
+      return `${numStr}: ${line}`;
+    }).join('\n');
+
+    return {
+      content: output,
+      metadata: {
+        path: resolvedPath,
+        totalLines: lines.length,
+        encoding,
+        size: Buffer.byteLength(content, encoding),
+        lineRange: lineInfo || 'full file',
+      },
+    };
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === 'ENOENT') {
+      throw new ToolError(`File not found: ${filePath}`, 'read_file', undefined, { code });
+    }
+    if (code === 'EACCES') {
+      throw new ToolError(`Permission denied: ${filePath}`, 'read_file', undefined, { code });
+    }
+    if (code === 'EISDIR') {
+      throw new ToolError(`Path is a directory, not a file: ${filePath}`, 'read_file', undefined, { code });
+    }
+    throw new ToolError(`Failed to read file: ${(err as Error).message}`, 'read_file');
+  }
+};

package/src/core/tools/impl/SearchContentTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SearchContentTool.d.ts","sourceRoot":"","sources":["SearchContentTool.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAuC,MAAM,sBAAsB,CAAC;AAK7F,eAAO,MAAM,oBAAoB,EAAE,WAqFlC,CAAC"}

package/src/core/tools/impl/SearchContentTool.ts

@@ -0,0 +1,94 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import path from 'node:path';
+import type { ToolHandler, ToolHandlerInput, ToolHandlerOutput } from '../../types/tools.js';
+import { ToolError } from '../../types/errors.js';
+
+const execFileAsync = promisify(execFile);
+
+export const searchContentHandler: ToolHandler = async (input: ToolHandlerInput): Promise<ToolHandlerOutput> => {
+  const {
+    pattern,
+    directory,
+    filePattern,
+    caseSensitive = false,
+    includeHidden = false,
+    maxResults = 50,
+    contextBefore = 0,
+    contextAfter = 0,
+    multiline = false,
+  } = input.params as {
+    pattern: string;
+    directory: string;
+    filePattern?: string;
+    caseSensitive?: boolean;
+    includeHidden?: boolean;
+    maxResults?: number;
+    contextBefore?: number;
+    contextAfter?: number;
+    multiline?: boolean;
+  };
+
+  const resolvedDir = path.resolve(directory);
+
+  try {
+    // Validate regex
+    new RegExp(pattern);
+
+    const args: string[] = [
+      '--no-heading',
+      '--color', 'never',
+      '--max-count', String(maxResults),
+      '-C', String(Math.max(contextBefore, contextAfter)),
+    ];
+
+    if (!caseSensitive) args.push('-i');
+    if (includeHidden) args.push('--hidden');
+    if (multiline) args.push('-U', '--multiline-dotall');
+    if (filePattern) args.push('--glob', filePattern);
+
+    // Add common ignores
+    const ignoreArgs = ['--glob', '!node_modules/**', '--glob', '!.git/**', '--glob', '!dist/**', '--glob', '!build/**'];
+    args.push(...ignoreArgs);
+
+    args.push('--', pattern, resolvedDir);
+
+    const { stdout, stderr } = await execFileAsync('rg', args, {
+      timeout: 15000,
+      maxBuffer: 10 * 1024 * 1024, // 10MB
+    });
+
+    if (!stdout.trim()) {
+      return {
+        content: `No matches found for pattern "${pattern}" in ${resolvedDir}`,
+        metadata: { pattern, directory: resolvedDir, count: 0 },
+      };
+    }
+
+    return {
+      content: stdout.trim(),
+      metadata: {
+        pattern,
+        directory: resolvedDir,
+        tool: 'ripgrep',
+        options: { caseSensitive, includeHidden, maxResults, contextBefore, contextAfter, multiline },
+      },
+    };
+  } catch (err) {
+    const error = err as { code?: string; message: string };
+    if (error.code === 'ENOENT') {
+      throw new ToolError(
+        'ripgrep (rg) not found. Please install it: https://github.com/BurntSushi/ripgrep',
+        'search_content'
+      );
+    }
+    if (error.code && (error.code === '1' || error.code === '2' || Number(error.code) === 1)) {
+      // ripgrep returns 1 when no matches found, 2 for errors (not an error for our purposes)
+      return {
+        content: `No matches found for pattern "${pattern}" in ${resolvedDir}`,
+        metadata: { pattern, directory: resolvedDir, count: 0 },
+      };
+    }
+    throw new ToolError(`Failed to search content: ${error.message}`, 'search_content');
+  }
+};

package/src/core/tools/impl/SearchFileTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SearchFileTool.d.ts","sourceRoot":"","sources":["SearchFileTool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAuC,MAAM,sBAAsB,CAAC;AAG7F,eAAO,MAAM,iBAAiB,EAAE,WAuD/B,CAAC"}

package/src/core/tools/impl/SearchFileTool.ts

@@ -0,0 +1,61 @@
+import { glob } from 'glob';
+import path from 'node:path';
+import type { ToolHandler, ToolHandlerInput, ToolHandlerOutput } from '../../types/tools.js';
+import { ToolError } from '../../types/errors.js';
+
+export const searchFileHandler: ToolHandler = async (input: ToolHandlerInput): Promise<ToolHandlerOutput> => {
+  const { pattern, directory, recursive = true, caseSensitive = false, excludePatterns } = input.params as {
+    pattern: string;
+    directory: string;
+    recursive?: boolean;
+    caseSensitive?: boolean;
+    excludePatterns?: string[];
+  };
+
+  const resolvedDir = path.resolve(directory);
+
+  try {
+    const globPattern = recursive ? `**/${pattern}` : pattern;
+    
+    const ignore = excludePatterns || [
+      'node_modules/**',
+      '.git/**',
+      'dist/**',
+      'build/**',
+      '*.log',
+    ];
+
+    const files = await glob(globPattern, {
+      cwd: resolvedDir,
+      ignore,
+      absolute: true,
+      nocase: !caseSensitive,
+      nodir: true,
+      windowsPathsNoEscape: true,
+    });
+
+    if (files.length === 0) {
+      return {
+        content: `No files matching "${pattern}" found in ${resolvedDir}`,
+        metadata: { pattern, directory: resolvedDir, count: 0 },
+      };
+    }
+
+    const output = files
+      .sort()
+      .map((f) => path.relative(resolvedDir, f))
+      .join('\n');
+
+    return {
+      content: output,
+      metadata: {
+        pattern,
+        directory: resolvedDir,
+        count: files.length,
+        matches: files,
+      },
+    };
+  } catch (err) {
+    throw new ToolError(`Failed to search files: ${(err as Error).message}`, 'search_file');
+  }
+};

package/src/core/tools/impl/ShellTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShellTool.d.ts","sourceRoot":"","sources":["ShellTool.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAuC,MAAM,sBAAsB,CAAC;AAG7F,eAAO,MAAM,YAAY,EAAE,WA8G1B,CAAC"}

package/src/core/tools/impl/ShellTool.ts

@@ -0,0 +1,118 @@
+import { spawn } from 'node:child_process';
+import { isAbsolute, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import os from 'node:os';
+import type { ToolHandler, ToolHandlerInput, ToolHandlerOutput } from '../../types/tools.js';
+import { ToolError, TimeoutError } from '../../types/errors.js';
+
+export const shellHandler: ToolHandler = async (input: ToolHandlerInput): Promise<ToolHandlerOutput> => {
+  const {
+    command,
+    workingDirectory,
+    env: extraEnv,
+    timeout = 30000,
+    shell: shellOverride,
+    input: stdinInput,
+  } = input.params as {
+    command: string;
+    workingDirectory?: string;
+    env?: Record<string, string>;
+    timeout?: number;
+    shell?: string;
+    input?: string;
+  };
+
+  const cwd = workingDirectory
+    ? isAbsolute(workingDirectory) ? workingDirectory : resolve(workingDirectory)
+    : input.context.workingDirectory;
+
+  // Determine shell
+  const isWindows = os.platform() === 'win32';
+  const shellCmd = shellOverride || (isWindows ? 'powershell.exe' : '/bin/bash');
+  const shellArgs = isWindows && !shellOverride ? ['-NoProfile', '-Command', command] : ['-c', command];
+
+  return new Promise<ToolHandlerOutput>((resolveResult, reject) => {
+    const proc = spawn(shellCmd, shellArgs, {
+      cwd,
+      env: { ...process.env, ...input.context.environment, ...extraEnv },
+      stdio: ['pipe', 'pipe', 'pipe'],
+      windowsHide: true,
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on('data', (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    if (stdinInput) {
+      proc.stdin.write(stdinInput);
+      proc.stdin.end();
+    } else {
+      proc.stdin.end();
+    }
+
+    const timer = setTimeout(() => {
+      proc.kill('SIGKILL');
+      reject(new TimeoutError(`Command timed out after ${timeout}ms`, timeout));
+    }, timeout);
+
+    proc.on('close', (code) => {
+      clearTimeout(timer);
+      const exitCode = code ?? 1;
+      
+      // Enhanced truncation with actionable guidance for Agent
+      const MAX = 10_000;
+      const truncated = (s: string, label: string = 'output') => {
+        if (s.length <= MAX) return s;
+        const truncatedLen = s.length - MAX;
+        return s.slice(0, MAX) + 
+          `\n\n[TRUNCATED: Showing ${MAX.toLocaleString()} of ${s.length.toLocaleString()} chars. ` +
+          `To see more, redirect to a file: ${command} > output.txt, then read_file output.txt]`;
+      };
+
+      if (exitCode === 0) {
+        resolveResult({
+          content: truncated(stdout) || (stderr ? `stderr: ${truncated(stderr, 'stderr')}` : 'Command completed successfully (no output)'),
+          metadata: {
+            exitCode: 0,
+            duration: timeout,
+            cwd,
+            shell: shellCmd,
+            outputLength: stdout.length,
+            truncated: stdout.length > MAX,
+          },
+        });
+      } else {
+        resolveResult({
+          content: truncated(stderr, 'stderr') || truncated(stdout, 'stdout') || `Command exited with code ${exitCode}`,
+          isError: true,
+          metadata: {
+            exitCode,
+            duration: timeout,
+            cwd,
+            shell: shellCmd,
+            outputLength: stderr.length || stdout.length,
+            truncated: stderr.length > MAX || stdout.length > MAX,
+          },
+        });
+      }
+    });
+
+    proc.on('error', (err) => {
+      clearTimeout(timer);
+      reject(new ToolError(`Failed to execute command: ${err.message}`, 'execute_command'));
+    });
+
+    // Handle abort signal
+    input.abortSignal?.addEventListener('abort', () => {
+      proc.kill('SIGKILL');
+      reject(new ToolError('Command cancelled', 'execute_command'));
+    }, { once: true });
+  });
+};

package/src/core/tools/impl/TaskTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskTool.d.ts","sourceRoot":"","sources":["TaskTool.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAuC,MAAM,sBAAsB,CAAC;AAmB7F;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,EAAE,WAsIzB,CAAC;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCtB,CAAC"}