@renxqoo/renx-code 0.0.4 → 0.0.5

package/vendor/agent-root/src/agent/tool/lsp.ts

@@ -0,0 +1,481 @@
+import { z } from 'zod';
+import * as ts from 'typescript';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { BaseTool, ToolResult } from './base-tool';
+import { ToolExecutionError } from './error';
+import { ensurePathWithinAllowed, normalizeAllowedDirectories } from './path-security';
+import { LSP_TOOL_DESCRIPTION } from './tool-prompts';
+import type { ToolExecutionContext } from './types';
+
+// 支持的操作类型
+const OPERATIONS = ['goToDefinition', 'findReferences', 'hover', 'documentSymbols'] as const;
+
+/**
+ * 创建 TypeScript 语言服务
+ * 每次调用创建新实例以确保文件列表是最新的
+ */
+function createLanguageService(filePath: string): ts.LanguageService {
+  const configPath = findTsConfig(filePath);
+  const { options, fileNames } = loadCompilerOptions(configPath);
+  // 确保目标文件在文件列表中
+  const resolvedPath = path.resolve(filePath);
+  const allFileNames = fileNames.includes(resolvedPath) ? fileNames : [...fileNames, resolvedPath];
+  const host = createServiceHost(options, allFileNames);
+  return ts.createLanguageService(host);
+}
+
+/**
+ * 查找最近的 tsconfig.json
+ */
+function findTsConfig(startPath: string): string | undefined {
+  let dir = path.dirname(path.resolve(startPath));
+  const root = path.parse(dir).root;
+
+  while (dir !== root) {
+    const configPath = path.join(dir, 'tsconfig.json');
+    if (fs.existsSync(configPath)) {
+      return configPath;
+    }
+    dir = path.dirname(dir);
+  }
+
+  return undefined;
+}
+
+/**
+ * 加载编译器选项
+ */
+function loadCompilerOptions(configPath?: string): {
+  options: ts.CompilerOptions;
+  fileNames: string[];
+} {
+  if (configPath) {
+    const configText = fs.readFileSync(configPath, 'utf-8');
+    const result = ts.parseConfigFileTextToJson(configPath, configText);
+    if (result.error) {
+      return getDefaultOptions();
+    }
+    const parsed = ts.parseJsonConfigFileContent(result.config, ts.sys, path.dirname(configPath));
+    return { options: parsed.options, fileNames: parsed.fileNames };
+  }
+  return getDefaultOptions();
+}
+
+function getDefaultOptions(): { options: ts.CompilerOptions; fileNames: string[] } {
+  return {
+    options: {
+      target: ts.ScriptTarget.ESNext,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      allowJs: true,
+      checkJs: false,
+      strict: false,
+      skipLibCheck: true,
+      noEmit: true,
+    },
+    fileNames: [],
+  };
+}
+
+/**
+ * 创建语言服务宿主
+ */
+function createServiceHost(
+  options: ts.CompilerOptions,
+  fileNames: string[]
+): ts.LanguageServiceHost {
+  const files = new Map<string, { version: number; content: string }>();
+  const knownFileNames = new Set<string>();
+
+  // 预加载已知文件
+  for (const fileName of fileNames) {
+    try {
+      const resolved = path.resolve(fileName);
+      const content = fs.readFileSync(resolved, 'utf-8');
+      files.set(resolved, { version: 0, content });
+      knownFileNames.add(resolved);
+    } catch {
+      // 忽略读取失败的文件
+    }
+  }
+
+  function ensureFileLoaded(fileName: string): void {
+    const resolved = path.resolve(fileName);
+    if (!files.has(resolved)) {
+      try {
+        const content = fs.readFileSync(resolved, 'utf-8');
+        files.set(resolved, { version: 0, content });
+        knownFileNames.add(resolved);
+      } catch {
+        // 文件不存在或无法读取
+      }
+    }
+  }
+
+  return {
+    getScriptFileNames: () => Array.from(knownFileNames),
+    getScriptVersion: (fileName) => {
+      ensureFileLoaded(fileName);
+      const file = files.get(path.resolve(fileName));
+      return file ? String(file.version) : '0';
+    },
+    getScriptSnapshot: (fileName) => {
+      ensureFileLoaded(fileName);
+      const resolved = path.resolve(fileName);
+      const file = files.get(resolved);
+      if (!file) {
+        return undefined;
+      }
+      return ts.ScriptSnapshot.fromString(file.content);
+    },
+    getCurrentDirectory: () => process.cwd(),
+    getCompilationSettings: () => options,
+    getDefaultLibFileName: (opts) => ts.getDefaultLibFilePath(opts),
+    fileExists: (fileName) => fs.existsSync(fileName),
+    readFile: (fileName) => {
+      try {
+        return fs.readFileSync(fileName, 'utf-8');
+      } catch {
+        return undefined;
+      }
+    },
+    readDirectory: ts.sys.readDirectory,
+    directoryExists: ts.sys.directoryExists,
+    getDirectories: ts.sys.getDirectories,
+  };
+}
+
+/**
+ * 将行/列转换为文件偏移位置
+ */
+function getPositionFromLineCharacter(
+  service: ts.LanguageService,
+  fileName: string,
+  line: number,
+  character: number
+): number {
+  const sourceFile = service.getProgram()?.getSourceFile(fileName);
+  if (!sourceFile) {
+    return 0;
+  }
+  return sourceFile.getPositionOfLineAndCharacter(line - 1, character - 1);
+}
+
+/**
+ * 格式化位置信息
+ */
+function formatLocation(fileName: string, line: number, character: number): string {
+  return `${fileName}:${line + 1}:${character + 1}`;
+}
+
+/**
+ * 获取行和列偏移（兼容不同 TypeScript 版本）
+ */
+function getLineAndCharacter(
+  service: ts.LanguageService,
+  fileName: string,
+  position: number
+): { line: number; character: number } {
+  // TypeScript 5.5+ 提供 toLineColumnOffset
+  if (typeof service.toLineColumnOffset === 'function') {
+    return service.toLineColumnOffset(fileName, position);
+  }
+  // 回退：使用 ScriptSnapshot 计算
+  const snapshot = service.getProgram()?.getSourceFile(fileName);
+  if (snapshot) {
+    const pos = ts.getLineAndCharacterOfPosition(snapshot, position);
+    return { line: pos.line, character: pos.character };
+  }
+  return { line: 0, character: 0 };
+}
+
+/**
+ * 执行 goToDefinition 操作
+ */
+function executeGoToDefinition(
+  service: ts.LanguageService,
+  filePath: string,
+  line: number,
+  character: number
+): ToolResult {
+  const position = getPositionFromLineCharacter(service, filePath, line, character);
+  const definition = service.getDefinitionAndBoundSpan(filePath, position);
+
+  if (!definition || !definition.definitions || definition.definitions.length === 0) {
+    return {
+      success: true,
+      output: 'No definition found',
+      metadata: { found: false },
+    };
+  }
+
+  const lines: string[] = [`Found ${definition.definitions.length} definition(s):\n`];
+  for (const def of definition.definitions) {
+    const start = getLineAndCharacter(service, def.fileName, def.textSpan.start);
+    lines.push(`  ${formatLocation(def.fileName, start.line, start.character)}`);
+    if (def.kind) {
+      lines.push(`    Kind: ${def.kind}`);
+    }
+    if (def.containerName) {
+      lines.push(`    Container: ${def.containerName}`);
+    }
+  }
+
+  return {
+    success: true,
+    output: lines.join('\n'),
+    metadata: {
+      found: true,
+      definitions: definition.definitions.map((d) => ({
+        fileName: d.fileName,
+        start: d.textSpan.start,
+        length: d.textSpan.length,
+        kind: d.kind,
+        name: d.name,
+        containerName: d.containerName,
+      })),
+    },
+  };
+}
+
+/**
+ * 执行 findReferences 操作
+ */
+function executeFindReferences(
+  service: ts.LanguageService,
+  filePath: string,
+  line: number,
+  character: number
+): ToolResult {
+  const position = getPositionFromLineCharacter(service, filePath, line, character);
+  const references = service.getReferencesAtPosition(filePath, position);
+
+  if (!references || references.length === 0) {
+    return {
+      success: true,
+      output: 'No references found',
+      metadata: { found: false },
+    };
+  }
+
+  const lines: string[] = [`Found ${references.length} reference(s):\n`];
+  for (const ref of references) {
+    const start = getLineAndCharacter(service, ref.fileName, ref.textSpan.start);
+    const isWrite = ref.isWriteAccess ? ' (write)' : ' (read)';
+    lines.push(`  ${formatLocation(ref.fileName, start.line, start.character)}${isWrite}`);
+  }
+
+  return {
+    success: true,
+    output: lines.join('\n'),
+    metadata: {
+      found: true,
+      count: references.length,
+      references: references.map((r) => ({
+        fileName: r.fileName,
+        start: r.textSpan.start,
+        length: r.textSpan.length,
+        isWrite: r.isWriteAccess,
+      })),
+    },
+  };
+}
+
+/**
+ * 执行 hover 操作
+ */
+function executeHover(
+  service: ts.LanguageService,
+  filePath: string,
+  line: number,
+  character: number
+): ToolResult {
+  const position = getPositionFromLineCharacter(service, filePath, line, character);
+  const hover = service.getQuickInfoAtPosition(filePath, position);
+
+  if (!hover) {
+    return {
+      success: true,
+      output: 'No hover information available',
+      metadata: { found: false },
+    };
+  }
+
+  const displayParts = hover.displayParts?.map((p) => p.text).join('') || '';
+  const documentation = hover.documentation?.map((d) => d.text).join('\n') || '';
+  const tags =
+    hover.tags
+      ?.map((t) => `@${t.name} ${t.text?.map((tt) => tt.text).join('') || ''}`)
+      .join('\n') || '';
+
+  const lines: string[] = [];
+  if (displayParts) {
+    lines.push('```typescript');
+    lines.push(displayParts);
+    lines.push('```');
+  }
+  if (documentation) {
+    lines.push('');
+    lines.push(documentation);
+  }
+  if (tags) {
+    lines.push('');
+    lines.push(tags);
+  }
+
+  return {
+    success: true,
+    output: lines.join('\n') || 'No information',
+    metadata: {
+      found: true,
+      displayParts,
+      documentation,
+      kind: hover.kind,
+      kindModifiers: hover.kindModifiers,
+    },
+  };
+}
+
+/**
+ * 执行 documentSymbols 操作
+ */
+function executeDocumentSymbols(service: ts.LanguageService, filePath: string): ToolResult {
+  const navTree = service.getNavigationTree(filePath);
+
+  if (!navTree) {
+    return {
+      success: true,
+      output: 'No symbols found',
+      metadata: { found: false },
+    };
+  }
+
+  const symbols: Array<{ name: string; kind: string; line: number }> = [];
+
+  function walkTree(node: ts.NavigationTree, depth = 0) {
+    const span = node.spans[0];
+    if (span) {
+      const start = getLineAndCharacter(service, filePath, span.start);
+      symbols.push({
+        name: '  '.repeat(depth) + node.text,
+        kind: node.kind,
+        line: start.line + 1,
+      });
+    }
+    for (const child of node.childItems || []) {
+      walkTree(child, depth + 1);
+    }
+  }
+
+  walkTree(navTree);
+
+  const lines: string[] = [`Found ${symbols.length} symbol(s):\n`];
+  for (const sym of symbols) {
+    lines.push(`  ${sym.name} (${sym.kind}) - Line ${sym.line}`);
+  }
+
+  return {
+    success: true,
+    output: lines.join('\n'),
+    metadata: {
+      found: true,
+      count: symbols.length,
+      symbols,
+    },
+  };
+}
+
+const schema = z
+  .object({
+    operation: z.enum(OPERATIONS).describe('LSP operation to perform'),
+    filePath: z.string().min(1).describe('Absolute or relative path to the file'),
+    line: z.number().int().min(1).describe('Line number (1-based)').optional(),
+    character: z.number().int().min(1).describe('Character offset (1-based)').optional(),
+  })
+  .strict()
+  .refine(
+    (data) => {
+      if (['goToDefinition', 'findReferences', 'hover'].includes(data.operation)) {
+        return data.line !== undefined && data.character !== undefined;
+      }
+      return true;
+    },
+    {
+      message:
+        'line and character are required for goToDefinition, findReferences, and hover operations',
+    }
+  );
+
+export interface LspToolOptions {
+  allowedDirectories?: string[];
+}
+
+export class LspTool extends BaseTool<typeof schema> {
+  readonly name = 'lsp';
+  readonly description = LSP_TOOL_DESCRIPTION;
+  readonly parameters = schema;
+
+  private readonly allowedDirectories: string[];
+
+  constructor(options?: LspToolOptions) {
+    super();
+    this.allowedDirectories = normalizeAllowedDirectories(options?.allowedDirectories);
+  }
+
+  async execute(
+    args: z.infer<typeof schema>,
+    _context?: ToolExecutionContext
+  ): Promise<ToolResult> {
+    const { operation, filePath, line = 1, character = 1 } = args;
+
+    // 路径安全检查
+    const absolutePath = ensurePathWithinAllowed(
+      path.resolve(filePath),
+      this.allowedDirectories,
+      'LSP_PATH_NOT_ALLOWED'
+    );
+
+    // 检查文件是否存在
+    if (!fs.existsSync(absolutePath)) {
+      throw new ToolExecutionError(`File not found: ${filePath}`, 2030);
+    }
+
+    // 检查文件类型
+    const ext = path.extname(absolutePath).toLowerCase();
+    const supportedExtensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+    if (!supportedExtensions.includes(ext)) {
+      throw new ToolExecutionError(
+        `Unsupported file type: ${ext}. Supported: ${supportedExtensions.join(', ')}`,
+        2031
+      );
+    }
+
+    try {
+      const service = createLanguageService(absolutePath);
+
+      switch (operation) {
+        case 'goToDefinition':
+          return executeGoToDefinition(service, absolutePath, line, character);
+        case 'findReferences':
+          return executeFindReferences(service, absolutePath, line, character);
+        case 'hover':
+          return executeHover(service, absolutePath, line, character);
+        case 'documentSymbols':
+          return executeDocumentSymbols(service, absolutePath);
+        default:
+          throw new ToolExecutionError(`Unknown operation: ${operation}`, 2032);
+      }
+    } catch (error) {
+      if (error instanceof ToolExecutionError) {
+        throw error;
+      }
+      throw new ToolExecutionError(
+        `LSP operation failed: ${error instanceof Error ? error.message : String(error)}`,
+        2033
+      );
+    }
+  }
+}
+
+export default LspTool;

package/vendor/agent-root/src/agent/tool/path-security.ts

@@ -0,0 +1,117 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+export interface PathAccessAssessment {
+  normalizedCandidate: string;
+  allowed: boolean;
+  message: string;
+}
+
+export function expandHomePath(rawPath: string): string {
+  if (rawPath === '~') {
+    return os.homedir();
+  }
+  if (rawPath.startsWith('~/')) {
+    return path.join(os.homedir(), rawPath.slice(2));
+  }
+  return rawPath;
+}
+
+function normalizeExistingPath(targetPath: string): string {
+  const resolved = path.resolve(targetPath);
+  try {
+    return fs.realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+
+export function normalizeAllowedDirectories(inputDirectories?: string[]): string[] {
+  const directories =
+    inputDirectories && inputDirectories.length > 0 ? inputDirectories : [process.cwd()];
+  return directories.map((directory) => normalizeExistingPath(expandHomePath(directory)));
+}
+
+export function resolveRequestedPath(requestedPath: string, baseDirectory = process.cwd()): string {
+  const expanded = expandHomePath(requestedPath.trim());
+  if (path.isAbsolute(expanded)) {
+    return path.resolve(expanded);
+  }
+  return path.resolve(baseDirectory, expanded);
+}
+
+export function normalizePathWithExistingAncestor(inputPath: string): string {
+  const absolute = path.resolve(inputPath);
+  let current = absolute;
+  const trailingSegments: string[] = [];
+
+  for (;;) {
+    try {
+      const realCurrent = fs.realpathSync(current);
+      if (trailingSegments.length === 0) {
+        return realCurrent;
+      }
+      return path.join(realCurrent, ...trailingSegments.reverse());
+    } catch (error) {
+      const nodeError = error as NodeJS.ErrnoException;
+      if (nodeError.code !== 'ENOENT' && nodeError.code !== 'ENOTDIR') {
+        return absolute;
+      }
+      const parent = path.dirname(current);
+      if (parent === current) {
+        return absolute;
+      }
+      trailingSegments.push(path.basename(current));
+      current = parent;
+    }
+  }
+}
+
+function isPathInsideDirectory(candidatePath: string, directoryPath: string): boolean {
+  return candidatePath === directoryPath || candidatePath.startsWith(`${directoryPath}${path.sep}`);
+}
+
+export function isWithinAllowedDirectories(
+  candidatePath: string,
+  allowedDirectories: string[]
+): boolean {
+  const normalizedCandidate = normalizePathWithExistingAncestor(candidatePath);
+  return allowedDirectories.some((allowedDirectory) =>
+    isPathInsideDirectory(normalizedCandidate, allowedDirectory)
+  );
+}
+
+export function assessPathAccess(
+  candidatePath: string,
+  allowedDirectories: string[],
+  errorPrefix = 'PATH_NOT_ALLOWED'
+): PathAccessAssessment {
+  const normalizedCandidate = normalizePathWithExistingAncestor(candidatePath);
+  const allowed = allowedDirectories.some((allowedDirectory) =>
+    isPathInsideDirectory(normalizedCandidate, allowedDirectory)
+  );
+
+  return {
+    normalizedCandidate,
+    allowed,
+    message: `${errorPrefix}: ${candidatePath} is outside allowed directories: ${allowedDirectories.join(', ')}`,
+  };
+}
+
+export function ensurePathWithinAllowed(
+  candidatePath: string,
+  allowedDirectories: string[],
+  errorPrefix = 'PATH_NOT_ALLOWED',
+  allowOutsideAllowedDirectories = false
+): string {
+  const assessment = assessPathAccess(candidatePath, allowedDirectories, errorPrefix);
+  if (!assessment.allowed && !allowOutsideAllowedDirectories) {
+    throw new Error(assessment.message);
+  }
+  return assessment.normalizedCandidate;
+}
+
+export function toPosixPath(rawPath: string): string {
+  return rawPath.split(path.sep).join('/');
+}