@renxqoo/renx-code 0.0.9 → 0.0.12

package/vendor/agent-root/src/agent/tool/search/common.ts

@@ -1,153 +0,0 @@
-import * as fs from 'node:fs/promises';
-import type { Dirent } from 'node:fs';
-import * as path from 'node:path';
-import { minimatch } from 'minimatch';
-import {
-  ensurePathWithinAllowed,
-  normalizeAllowedDirectories,
-  resolveRequestedPath,
-} from '../path-security';
-
-export const DEFAULT_IGNORE_GLOBS = [
-  '**/node_modules/**',
-  '**/.git/**',
-  '**/dist/**',
-  '**/build/**',
-  '**/.next/**',
-  '**/.nuxt/**',
-  '**/coverage/**',
-  '**/*.min.js',
-  '**/*.min.css',
-];
-
-export interface SearchPathOptions {
-  requestedPath?: string;
-  allowedDirectories?: string[];
-}
-
-export interface SearchPathResolved {
-  rootPath: string;
-  allowedDirectories: string[];
-}
-
-export interface TraverseFile {
-  absolutePath: string;
-  relativePath: string;
-}
-
-export async function resolveSearchRoot(options: SearchPathOptions): Promise<SearchPathResolved> {
-  const allowedDirectories = normalizeAllowedDirectories(options.allowedDirectories);
-  const requestedPath = options.requestedPath?.trim().length
-    ? options.requestedPath
-    : process.cwd();
-  const absolute = resolveRequestedPath(requestedPath);
-  const validated = ensurePathWithinAllowed(
-    absolute,
-    allowedDirectories,
-    'SEARCH_PATH_NOT_ALLOWED'
-  );
-
-  let stats: Awaited<ReturnType<typeof fs.stat>>;
-  try {
-    stats = await fs.stat(validated);
-  } catch (error) {
-    const nodeError = error as NodeJS.ErrnoException;
-    if (nodeError.code === 'ENOENT') {
-      throw new Error(`SEARCH_PATH_NOT_FOUND: ${validated}`);
-    }
-    if (nodeError.code === 'EACCES' || nodeError.code === 'EPERM') {
-      throw new Error(`SEARCH_PATH_NO_PERMISSION: ${validated}`);
-    }
-    throw error;
-  }
-
-  if (!stats.isDirectory()) {
-    throw new Error(`SEARCH_PATH_NOT_DIRECTORY: ${validated}`);
-  }
-
-  return {
-    rootPath: validated,
-    allowedDirectories,
-  };
-}
-
-export async function collectFilesByGlob(options: {
-  rootPath: string;
-  pattern: string;
-  includeHidden: boolean;
-  ignorePatterns: string[];
-  maxResults: number;
-}): Promise<{ files: TraverseFile[]; truncated: boolean }> {
-  const files: TraverseFile[] = [];
-  const queue = [options.rootPath];
-  const visited = new Set<string>();
-  let truncated = false;
-
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (!current) {
-      continue;
-    }
-
-    let realCurrent: string;
-    try {
-      realCurrent = await fs.realpath(current);
-    } catch {
-      continue;
-    }
-
-    if (visited.has(realCurrent)) {
-      continue;
-    }
-    visited.add(realCurrent);
-
-    let entries: Dirent[];
-    try {
-      entries = await fs.readdir(current, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-
-    entries.sort((left, right) => left.name.localeCompare(right.name));
-
-    for (const entry of entries) {
-      if (!options.includeHidden && entry.name.startsWith('.')) {
-        continue;
-      }
-
-      const absolutePath = path.join(current, entry.name);
-      const relativePath = path.relative(options.rootPath, absolutePath).split(path.sep).join('/');
-      if (!relativePath || relativePath === '.') {
-        continue;
-      }
-
-      const ignored = options.ignorePatterns.some((pattern) =>
-        minimatch(relativePath, pattern, { dot: options.includeHidden })
-      );
-      if (ignored) {
-        continue;
-      }
-
-      if (entry.isDirectory()) {
-        queue.push(absolutePath);
-        continue;
-      }
-
-      if (!entry.isFile()) {
-        continue;
-      }
-
-      if (!minimatch(relativePath, options.pattern, { dot: options.includeHidden })) {
-        continue;
-      }
-
-      files.push({ absolutePath, relativePath });
-      if (files.length >= options.maxResults) {
-        truncated = true;
-        return { files, truncated };
-      }
-    }
-  }
-
-  return { files, truncated };
-}

package/vendor/agent-root/src/agent/tool/skill/index.ts

@@ -1,13 +0,0 @@
-export type { Skill, SkillFrontmatter, SkillLoaderOptions, SkillMetadata } from './types';
-
-export {
-  parseFrontmatter,
-  stripFrontmatter,
-  extractFileRefs,
-  extractShellCommands,
-  deriveDescriptionFromMarkdown,
-  formatSkillForContext,
-  isValidSkillName,
-} from './parser';
-
-export { SkillLoader, getSkillLoader, initializeSkillLoader, resetSkillLoader } from './loader';

package/vendor/agent-root/src/agent/tool/skill/loader.ts

@@ -1,229 +0,0 @@
-import * as fs from 'node:fs/promises';
-import type { Dirent } from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import {
-  deriveDescriptionFromMarkdown,
-  extractFileRefs,
-  extractShellCommands,
-  isValidSkillName,
-  parseFrontmatter,
-  stripFrontmatter,
-} from './parser';
-import type { Skill, SkillLoaderOptions, SkillMetadata } from './types';
-
-const SKILL_FILE_NAME = 'SKILL.md';
-
-function getDefaultSkillRoots(workingDir: string): string[] {
-  const roots: string[] = [];
-  const codexHome = process.env.CODEX_HOME?.trim();
-  if (codexHome) {
-    roots.push(path.join(codexHome, 'skills'));
-  }
-
-  roots.push(path.join(workingDir, '.agents', 'skills'));
-  roots.push(path.join(os.homedir(), '.agents', 'skills'));
-  roots.push(path.join(os.homedir(), '.codex', 'skills'));
-
-  return Array.from(new Set(roots.map((dir) => path.resolve(dir))));
-}
-
-function toLoaderKey(options?: SkillLoaderOptions): string {
-  const roots = options?.skillRoots?.map((root) => path.resolve(root)).sort() || [];
-  const workingDir = path.resolve(options?.workingDir || process.cwd());
-  return JSON.stringify({ roots, workingDir });
-}
-
-export class SkillLoader {
-  private readonly roots: string[];
-  private readonly metadataMap = new Map<string, SkillMetadata>();
-  private readonly skillCache = new Map<string, Skill>();
-  private initialized = false;
-
-  constructor(options: SkillLoaderOptions = {}) {
-    const workingDir = options.workingDir ?? process.cwd();
-    this.roots = options.skillRoots?.length
-      ? options.skillRoots.map((dir) => path.resolve(dir))
-      : getDefaultSkillRoots(workingDir);
-  }
-
-  async initialize(): Promise<void> {
-    if (this.initialized) {
-      return;
-    }
-
-    this.metadataMap.clear();
-    const skillFiles = await this.discoverSkillFiles();
-
-    for (const skillFilePath of skillFiles) {
-      const metadata = await this.loadMetadata(skillFilePath);
-      if (!metadata) {
-        continue;
-      }
-      if (!this.metadataMap.has(metadata.name)) {
-        this.metadataMap.set(metadata.name, metadata);
-      }
-    }
-
-    this.initialized = true;
-  }
-
-  getAllMetadata(): SkillMetadata[] {
-    return Array.from(this.metadataMap.values()).sort((left, right) =>
-      left.name.localeCompare(right.name)
-    );
-  }
-
-  hasSkill(name: string): boolean {
-    return this.metadataMap.has(name);
-  }
-
-  async loadSkill(name: string): Promise<Skill | null> {
-    const cached = this.skillCache.get(name);
-    if (cached) {
-      return cached;
-    }
-
-    const metadata = this.metadataMap.get(name);
-    if (!metadata) {
-      return null;
-    }
-
-    let rawContent: string;
-    try {
-      rawContent = await fs.readFile(metadata.skillFilePath, 'utf-8');
-    } catch {
-      return null;
-    }
-
-    const content = stripFrontmatter(rawContent).trim();
-    const skill: Skill = {
-      metadata,
-      content,
-      fileRefs: extractFileRefs(content),
-      shellCommands: extractShellCommands(content),
-      loadedAt: Date.now(),
-    };
-
-    this.skillCache.set(name, skill);
-    return skill;
-  }
-
-  private async discoverSkillFiles(): Promise<string[]> {
-    const files: string[] = [];
-    for (const root of this.roots) {
-      const discovered = await this.walkSkillFiles(root);
-      files.push(...discovered);
-    }
-    return files;
-  }
-
-  private async walkSkillFiles(rootDirectory: string): Promise<string[]> {
-    let stats: Awaited<ReturnType<typeof fs.stat>>;
-    try {
-      stats = await fs.stat(rootDirectory);
-    } catch {
-      return [];
-    }
-
-    if (!stats.isDirectory()) {
-      return [];
-    }
-
-    const queue = [rootDirectory];
-    const skillFiles: string[] = [];
-    const visited = new Set<string>();
-
-    while (queue.length > 0) {
-      const current = queue.shift();
-      if (!current) {
-        continue;
-      }
-
-      let realCurrent: string;
-      try {
-        realCurrent = await fs.realpath(current);
-      } catch {
-        continue;
-      }
-
-      if (visited.has(realCurrent)) {
-        continue;
-      }
-      visited.add(realCurrent);
-
-      let entries: Dirent[];
-      try {
-        entries = await fs.readdir(current, { withFileTypes: true });
-      } catch {
-        continue;
-      }
-
-      for (const entry of entries) {
-        const entryPath = path.join(current, entry.name);
-        if (entry.isFile() && entry.name === SKILL_FILE_NAME) {
-          skillFiles.push(entryPath);
-          continue;
-        }
-
-        if (entry.isDirectory()) {
-          queue.push(entryPath);
-        }
-      }
-    }
-
-    return skillFiles;
-  }
-
-  private async loadMetadata(skillFilePath: string): Promise<SkillMetadata | null> {
-    let content: string;
-    try {
-      content = await fs.readFile(skillFilePath, 'utf-8');
-    } catch {
-      return null;
-    }
-
-    const frontmatter = parseFrontmatter(content);
-    const skillDirectory = path.dirname(skillFilePath);
-    const fallbackName = path.basename(skillDirectory).toLowerCase();
-    const name = (frontmatter?.name || fallbackName).trim();
-    if (!isValidSkillName(name)) {
-      return null;
-    }
-
-    const description = (frontmatter?.description || deriveDescriptionFromMarkdown(content)).trim();
-    if (!description) {
-      return null;
-    }
-
-    return {
-      name,
-      description,
-      path: skillDirectory,
-      skillFilePath,
-    };
-  }
-}
-
-let globalLoader: SkillLoader | null = null;
-let globalLoaderKey: string | null = null;
-
-export function getSkillLoader(options?: SkillLoaderOptions): SkillLoader {
-  const nextKey = toLoaderKey(options);
-  if (!globalLoader || globalLoaderKey !== nextKey) {
-    globalLoader = new SkillLoader(options);
-    globalLoaderKey = nextKey;
-  }
-  return globalLoader;
-}
-
-export async function initializeSkillLoader(options?: SkillLoaderOptions): Promise<SkillLoader> {
-  const loader = getSkillLoader(options);
-  await loader.initialize();
-  return loader;
-}
-
-export function resetSkillLoader(): void {
-  globalLoader = null;
-  globalLoaderKey = null;
-}

package/vendor/agent-root/src/agent/tool/skill/parser.ts

@@ -1,124 +0,0 @@
-import type { SkillFrontmatter } from './types';
-
-const FRONTMATTER_REGEX = /^---\s*\n([\s\S]*?)\n---/;
-const FILE_REF_REGEX = /(?<![`\w])@(\.{0,2}[/\\]?[^\s`,.*!?()]+(?:\.[^\s`,.*!?()]+)+)/g;
-const SHELL_COMMAND_REGEX = /!`([^`]+)`/g;
-
-export function parseFrontmatter(content: string): SkillFrontmatter | null {
-  const matched = content.match(FRONTMATTER_REGEX);
-  if (!matched) {
-    return null;
-  }
-
-  const frontmatter: Partial<SkillFrontmatter> = {};
-  for (const line of matched[1].split('\n')) {
-    const colonIndex = line.indexOf(':');
-    if (colonIndex < 0) {
-      continue;
-    }
-
-    const key = line.slice(0, colonIndex).trim();
-    let value = line.slice(colonIndex + 1).trim();
-    if (
-      (value.startsWith('"') && value.endsWith('"')) ||
-      (value.startsWith("'") && value.endsWith("'"))
-    ) {
-      value = value.slice(1, -1);
-    }
-
-    if (key === 'name') {
-      frontmatter.name = value;
-    }
-    if (key === 'description') {
-      frontmatter.description = value;
-    }
-    if (key === 'license') {
-      frontmatter.license = value;
-    }
-    if (key === 'version') {
-      frontmatter.version = value;
-    }
-    if (key === 'author') {
-      frontmatter.author = value;
-    }
-  }
-
-  if (!frontmatter.name || !frontmatter.description) {
-    return null;
-  }
-
-  return frontmatter as SkillFrontmatter;
-}
-
-export function stripFrontmatter(content: string): string {
-  const matched = content.match(/^---\s*\n[\s\S]*?\n---\s*\n?/);
-  if (!matched) {
-    return content;
-  }
-  return content.slice(matched[0].length);
-}
-
-export function extractFileRefs(content: string): string[] {
-  const matches = Array.from(content.matchAll(FILE_REF_REGEX), (match) => match[1]);
-  return Array.from(new Set(matches));
-}
-
-export function extractShellCommands(content: string): string[] {
-  const matches = Array.from(content.matchAll(SHELL_COMMAND_REGEX), (match) => match[1]);
-  return Array.from(new Set(matches));
-}
-
-export function deriveDescriptionFromMarkdown(content: string): string {
-  const stripped = stripFrontmatter(content);
-  const lines = stripped
-    .split('\n')
-    .map((line) => line.trim())
-    .filter((line) => line.length > 0);
-
-  for (const line of lines) {
-    if (line.startsWith('#')) {
-      continue;
-    }
-    return line.length > 180 ? `${line.slice(0, 177)}...` : line;
-  }
-
-  return 'No description provided';
-}
-
-export function formatSkillForContext(skill: {
-  metadata: { name: string; description: string; path: string };
-  content: string;
-  fileRefs: string[];
-  shellCommands: string[];
-}): string {
-  const lines: string[] = [
-    `## Skill: ${skill.metadata.name}`,
-    '',
-    `Description: ${skill.metadata.description}`,
-    `Base directory: ${skill.metadata.path}`,
-  ];
-
-  if (skill.fileRefs.length > 0) {
-    lines.push('', 'Referenced files:');
-    for (const fileRef of skill.fileRefs) {
-      lines.push(`- ${fileRef}`);
-    }
-  }
-
-  if (skill.shellCommands.length > 0) {
-    lines.push('', 'Shell commands:');
-    for (const shellCommand of skill.shellCommands) {
-      lines.push(`- !\`${shellCommand}\``);
-    }
-  }
-
-  lines.push('', '---', '', skill.content);
-  return lines.join('\n');
-}
-
-export function isValidSkillName(name: string): boolean {
-  if (name.length === 0 || name.length > 64) {
-    return false;
-  }
-  return /^[a-z0-9._]+(?:-[a-z0-9._]+)*$/.test(name);
-}

package/vendor/agent-root/src/agent/tool/skill/types.ts

@@ -1,27 +0,0 @@
-export interface SkillMetadata {
-  readonly name: string;
-  readonly description: string;
-  readonly path: string;
-  readonly skillFilePath: string;
-}
-
-export interface Skill {
-  readonly metadata: SkillMetadata;
-  readonly content: string;
-  readonly fileRefs: string[];
-  readonly shellCommands: string[];
-  readonly loadedAt: number;
-}
-
-export interface SkillLoaderOptions {
-  skillRoots?: string[];
-  workingDir?: string;
-}
-
-export interface SkillFrontmatter {
-  name: string;
-  description: string;
-  license?: string;
-  version?: string;
-  author?: string;
-}

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

@@ -1,143 +0,0 @@
-import { z } from 'zod';
-import { BaseTool, type ToolResult } from './base-tool';
-import { ToolExecutionError } from './error';
-import { formatSkillForContext } from './skill/parser';
-import { getSkillLoader, initializeSkillLoader } from './skill/loader';
-import type { SkillLoaderOptions } from './skill/types';
-import { SKILL_TOOL_BASE_DESCRIPTION } from './tool-prompts';
-
-const schema = z
-  .object({
-    name: z.string().min(1).describe('Skill identifier from available skills list'),
-  })
-  .strict();
-
-export interface SkillToolOptions {
-  includeSkillList?: boolean;
-  loaderOptions?: SkillLoaderOptions;
-}
-
-interface SkillToolPayload {
-  name: string;
-  description: string;
-  baseDir: string;
-  content: string;
-  fileRefs: string[];
-  shellCommands: string[];
-}
-
-export class SkillTool extends BaseTool<typeof schema> {
-  name = 'skill';
-  parameters = schema;
-
-  private readonly includeSkillList: boolean;
-  private readonly loaderOptions?: SkillLoaderOptions;
-  private cachedDescription: string | null = null;
-
-  constructor(options: SkillToolOptions = {}) {
-    super();
-    this.includeSkillList = options.includeSkillList ?? true;
-    this.loaderOptions = options.loaderOptions;
-  }
-
-  get description(): string {
-    if (!this.cachedDescription) {
-      this.cachedDescription = this.buildDescription();
-    }
-    return this.cachedDescription;
-  }
-
-  refreshDescription(): void {
-    this.cachedDescription = null;
-  }
-
-  override getConcurrencyMode(): 'parallel-safe' {
-    return 'parallel-safe';
-  }
-
-  override getConcurrencyLockKey(args: z.infer<typeof schema>): string {
-    return `skill:${args.name}`;
-  }
-
-  async execute(args: z.infer<typeof schema>): Promise<ToolResult> {
-    try {
-      await initializeSkillLoader(this.loaderOptions);
-      const loader = getSkillLoader(this.loaderOptions);
-
-      if (!loader.hasSkill(args.name)) {
-        const availableSkills = loader.getAllMetadata().map((item) => item.name);
-        const suggestion =
-          availableSkills.length > 0
-            ? `Available skills: ${availableSkills.join(', ')}`
-            : 'No skills are currently available.';
-        const message = `SKILL_NOT_FOUND: Skill "${args.name}" not found. ${suggestion}`;
-
-        return {
-          success: false,
-          output: message,
-          error: new ToolExecutionError(message),
-          metadata: {
-            error: 'SKILL_NOT_FOUND',
-            suggestion,
-            requested_name: args.name,
-          },
-        };
-      }
-
-      const skill = await loader.loadSkill(args.name);
-      if (!skill) {
-        const message = `SKILL_LOAD_FAILED: Failed to load skill "${args.name}"`;
-        return {
-          success: false,
-          output: message,
-          error: new ToolExecutionError(message),
-          metadata: {
-            error: 'SKILL_LOAD_FAILED',
-            requested_name: args.name,
-          },
-        };
-      }
-
-      const payload: SkillToolPayload = {
-        name: skill.metadata.name,
-        description: skill.metadata.description,
-        baseDir: skill.metadata.path,
-        content: skill.content,
-        fileRefs: skill.fileRefs,
-        shellCommands: skill.shellCommands,
-      };
-
-      return {
-        success: true,
-        output: formatSkillForContext(skill),
-        metadata: payload as unknown as Record<string, unknown>,
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return {
-        success: false,
-        output: message,
-        error: new ToolExecutionError(message),
-      };
-    }
-  }
-
-  private buildDescription(): string {
-    const base = `${SKILL_TOOL_BASE_DESCRIPTION}\n\n`;
-
-    if (!this.includeSkillList) {
-      return base;
-    }
-
-    const loader = getSkillLoader(this.loaderOptions);
-    const skills = loader.getAllMetadata();
-    if (skills.length === 0) {
-      return `${base}No skills are currently available.`;
-    }
-
-    const lines = skills.map((skill) => `- ${skill.name}: ${skill.description}`);
-    return `${base}Available skills:\n${lines.join('\n')}`;
-  }
-}
-
-export default SkillTool;