@renxqoo/renx-code 0.0.3 → 0.0.5

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

@@ -0,0 +1,153 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,229 @@
+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

@@ -0,0 +1,124 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,143 @@
+import { z } from 'zod';
+import { BaseTool, 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;