@renxqoo/renx-code 0.0.9 → 0.0.12

package/vendor/agent-root/src/agent/tool/task-store.ts

@@ -1,217 +0,0 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { randomUUID } from 'node:crypto';
-import { createEmptyNamespaceState, safeJsonClone, type TaskNamespaceState } from './task-types';
-
-interface NamespaceLockState {
-  locked: boolean;
-  waiters: Array<() => void>;
-}
-
-export interface TaskStoreOptions {
-  baseDir?: string;
-  now?: () => number;
-}
-
-export class TaskStore {
-  readonly baseDir: string;
-
-  private readonly now: () => number;
-  private readonly namespaceCache = new Map<string, TaskNamespaceState>();
-  private readonly lockStates = new Map<string, NamespaceLockState>();
-  private initialized = false;
-
-  constructor(options: TaskStoreOptions = {}) {
-    this.baseDir = path.resolve(options.baseDir || path.join(os.homedir(), '.renx', 'task'));
-    this.now = options.now || Date.now;
-  }
-
-  async getState(namespaceInput?: string): Promise<TaskNamespaceState> {
-    const namespace = this.normalizeNamespace(namespaceInput);
-    await this.ensureInitialized();
-    const state = await this.readNamespaceState(namespace);
-    return safeJsonClone(state);
-  }
-
-  async updateState<T>(
-    namespaceInput: string | undefined,
-    updater: (state: TaskNamespaceState) => Promise<T> | T
-  ): Promise<{ state: TaskNamespaceState; result: T }> {
-    const namespace = this.normalizeNamespace(namespaceInput);
-    await this.ensureInitialized();
-    await this.acquireNamespaceLock(namespace);
-
-    try {
-      const current = await this.readNamespaceState(namespace);
-      const working = safeJsonClone(current);
-      const result = await updater(working);
-      working.updatedAt = this.now();
-      await this.writeNamespaceState(namespace, working);
-      this.namespaceCache.set(namespace, safeJsonClone(working));
-      return {
-        state: safeJsonClone(working),
-        result,
-      };
-    } finally {
-      this.releaseNamespaceLock(namespace);
-    }
-  }
-
-  normalizeNamespace(namespaceInput?: string): string {
-    const raw = (namespaceInput || 'default').trim();
-    if (!raw) {
-      return 'default';
-    }
-    if (!/^[a-zA-Z0-9._-]+$/.test(raw)) {
-      throw new Error('TASK_INVALID_NAMESPACE: namespace allows only [a-zA-Z0-9._-]');
-    }
-    return raw;
-  }
-
-  getNamespaceFilePath(namespace: string): string {
-    return path.join(this.baseDir, `${namespace}.json`);
-  }
-
-  private async ensureInitialized(): Promise<void> {
-    if (this.initialized) {
-      return;
-    }
-    await fs.mkdir(this.baseDir, { recursive: true });
-    this.initialized = true;
-  }
-
-  private async readNamespaceState(namespace: string): Promise<TaskNamespaceState> {
-    const cached = this.namespaceCache.get(namespace);
-    if (cached) {
-      return safeJsonClone(cached);
-    }
-
-    const filePath = this.getNamespaceFilePath(namespace);
-    try {
-      const raw = await fs.readFile(filePath, 'utf8');
-      const parsed = JSON.parse(raw) as Partial<TaskNamespaceState>;
-      const hydrated = this.hydrateState(namespace, parsed);
-      this.namespaceCache.set(namespace, safeJsonClone(hydrated));
-      return hydrated;
-    } catch (error) {
-      const nodeError = error as NodeJS.ErrnoException;
-      if (nodeError?.code !== 'ENOENT') {
-        throw new Error(
-          `TASK_STORE_IO_ERROR: failed to load namespace ${namespace}: ${nodeError.message}`
-        );
-      }
-      const emptyState = createEmptyNamespaceState(namespace);
-      this.namespaceCache.set(namespace, safeJsonClone(emptyState));
-      await this.writeNamespaceState(namespace, emptyState);
-      return emptyState;
-    }
-  }
-
-  private hydrateState(
-    namespace: string,
-    partial: Partial<TaskNamespaceState>
-  ): TaskNamespaceState {
-    const base = createEmptyNamespaceState(namespace);
-    const merged: TaskNamespaceState = {
-      ...base,
-      ...partial,
-      namespace,
-      tasks: partial.tasks || {},
-      agentRuns: partial.agentRuns || {},
-      graph: {
-        adjacency: partial.graph?.adjacency || {},
-        reverse: partial.graph?.reverse || {},
-      },
-      updatedAt: typeof partial.updatedAt === 'number' ? partial.updatedAt : base.updatedAt,
-      schemaVersion: 1,
-    };
-
-    for (const taskId of Object.keys(merged.tasks)) {
-      if (!merged.graph.adjacency[taskId]) {
-        merged.graph.adjacency[taskId] = [];
-      }
-      if (!merged.graph.reverse[taskId]) {
-        merged.graph.reverse[taskId] = [];
-      }
-    }
-
-    return merged;
-  }
-
-  private async writeNamespaceState(namespace: string, state: TaskNamespaceState): Promise<void> {
-    const filePath = this.getNamespaceFilePath(namespace);
-    const dirPath = path.dirname(filePath);
-    await fs.mkdir(dirPath, { recursive: true });
-    const tmpPath = `${filePath}.tmp.${randomUUID().slice(0, 8)}`;
-    const json = `${JSON.stringify(state, null, 2)}\n`;
-    await fs.writeFile(tmpPath, json, 'utf8');
-
-    try {
-      await fs.rename(tmpPath, filePath);
-    } catch (error) {
-      const nodeError = error as NodeJS.ErrnoException;
-      if (nodeError.code === 'EPERM' && process.platform === 'win32') {
-        await fs.copyFile(tmpPath, filePath);
-        await fs.unlink(tmpPath).catch(() => undefined);
-        return;
-      }
-      throw error;
-    }
-  }
-
-  private async acquireNamespaceLock(namespace: string): Promise<void> {
-    let lockState = this.lockStates.get(namespace);
-    if (!lockState) {
-      lockState = {
-        locked: false,
-        waiters: [],
-      };
-      this.lockStates.set(namespace, lockState);
-    }
-
-    if (!lockState.locked) {
-      lockState.locked = true;
-      return;
-    }
-
-    await new Promise<void>((resolve) => {
-      lockState?.waiters.push(resolve);
-    });
-  }
-
-  private releaseNamespaceLock(namespace: string): void {
-    const lockState = this.lockStates.get(namespace);
-    if (!lockState) {
-      return;
-    }
-
-    const next = lockState.waiters.shift();
-    if (next) {
-      next();
-      return;
-    }
-
-    lockState.locked = false;
-  }
-}
-
-let globalTaskStore: TaskStore | null = null;
-let globalTaskStoreKey = '';
-
-export function getTaskStore(options: TaskStoreOptions = {}): TaskStore {
-  const baseDir = path.resolve(options.baseDir || path.join(os.homedir(), '.renx', 'task'));
-  if (!globalTaskStore || globalTaskStoreKey !== baseDir) {
-    globalTaskStore = new TaskStore({
-      ...options,
-      baseDir,
-    });
-    globalTaskStoreKey = baseDir;
-  }
-  return globalTaskStore;
-}
-
-export function resetTaskStoreSingleton(): void {
-  globalTaskStore = null;
-  globalTaskStoreKey = '';
-}

package/vendor/agent-root/src/agent/tool/task-subagent-config.ts

@@ -1,149 +0,0 @@
-import type { SubagentType } from './task-types';
-
-export interface TaskSubagentConfig {
-  tools: string[];
-  systemPrompt: string;
-}
-
-const TOOLSET = {
-  bash: ['bash'],
-  readOnly: ['glob', 'grep', 'file_read', 'file_history_list', 'skill'],
-  restore: ['glob', 'file_read', 'file_history_list', 'file_history_restore'],
-  general: [
-    'bash',
-    'glob',
-    'grep',
-    'file_read',
-    'file_edit',
-    'write_file',
-    'file_history_list',
-    'file_history_restore',
-    'skill',
-  ],
-  findSkills: ['skill', 'bash'],
-} as const;
-
-const SYSTEM_PROMPTS: Record<SubagentType, string> = {
-  Bash: `You are a shell execution specialist.
-Run safe, minimal commands and report exact outcomes.
-Prefer non-interactive commands and always surface stderr on failure.`,
-  'general-purpose': `You are a general software engineering subagent.
-Use tools pragmatically, verify key changes, and keep responses concise and evidence-based.`,
-  Explore: `You are a codebase exploration specialist.
-Use glob/grep/file_read to find relevant implementation details quickly and accurately.`,
-  Restore: `You are a file restoration specialist.
-Your job is to restore one or more files from saved history with minimal risk.
-
-Workflow:
-1. Prefer exact absolute file paths provided by the parent agent.
-2. If the parent already gave an absolute path, do not search broadly unless the path fails.
-3. Use file_history_list to inspect available saved versions for that file.
-4. Unless the parent specifies a versionId, restore the latest saved version.
-5. Use file_history_restore to perform the rollback.
-6. Read the file after restoring to confirm the content changed as expected.
-
-Rules:
-- Prefer absolute file paths.
-- If only a file path is needed and the parent supplied one, that is sufficient.
-- Do not use file_edit or write_file.
-- Do not modify unrelated files.
-- Report exactly which file path was restored and which versionId was used.`,
-  Plan: `You are a planning specialist.
-Produce concrete implementation plans with clear steps, risks, and acceptance criteria.`,
-  'research-agent': `You are a research-focused subagent.
-Collect evidence from available files and synthesize concise, structured findings.`,
-  'find-skills': `
-## Role
-You are a **Skill Discovery and Installation Specialist**.
-Your goal is to **help the parent agent quickly and reliably find the correct skill required to complete a task.**
-## Workflow
-1. **Check local skills first**
-Use the \`skill\` tool to read local skills using **exact or likely names**.
-2. **If the skill is missing or insufficient**
-Use the \`skill\` tool to load the **\`find-skills\`** skill and follow its workflow to:
-* search skills using **exact or likely names**
-* discover candidates
-* install the appropriate skill
-3. **If \`find-skills\` is missing**
-Use \`bash\` only for the required installation command:
-\`\`\`bash
-npx skills add https://github.com/vercel-labs/skills --skill find-skills
-\`\`\`
-After installation, retry using the \`skill\` tool.
-4. **Verify after installation**
-Run the \`skill\` tool again to confirm the target skill is **readable and available**.
-## Critical Rules
-* **Never invent skill content**
-* Only report **actual tool results**
-* Do not assume a skill exists
-* Always **verify after installation**
-## Output Format (Markdown required)
-Your response must include:
-### Skill Status
-* Found locally
-* Found remotely and installed
-* Still missing
-### Recommended Skill
-* Skill name
-* Why it fits the task
-### Next Step
-What the parent agent should do next.
-Keep the response **concise, clear, and action-oriented**.
-`,
-};
-
-const TASK_SUBAGENT_CONFIGS: Record<SubagentType, TaskSubagentConfig> = {
-  Bash: {
-    tools: [...TOOLSET.bash],
-    systemPrompt: SYSTEM_PROMPTS.Bash,
-  },
-  'general-purpose': {
-    tools: [...TOOLSET.general],
-    systemPrompt: SYSTEM_PROMPTS['general-purpose'],
-  },
-  Explore: {
-    tools: [...TOOLSET.readOnly],
-    systemPrompt: SYSTEM_PROMPTS.Explore,
-  },
-  Restore: {
-    tools: [...TOOLSET.restore],
-    systemPrompt: SYSTEM_PROMPTS.Restore,
-  },
-  Plan: {
-    tools: [...TOOLSET.readOnly],
-    systemPrompt: SYSTEM_PROMPTS.Plan,
-  },
-  'research-agent': {
-    tools: [...TOOLSET.readOnly],
-    systemPrompt: SYSTEM_PROMPTS['research-agent'],
-  },
-  'find-skills': {
-    tools: [...TOOLSET.findSkills],
-    systemPrompt: SYSTEM_PROMPTS['find-skills'],
-  },
-};
-
-export function getTaskSubagentConfig(subagentType: SubagentType): TaskSubagentConfig {
-  const config = TASK_SUBAGENT_CONFIGS[subagentType];
-  return {
-    tools: [...config.tools],
-    systemPrompt: config.systemPrompt,
-  };
-}
-
-export function resolveTaskSubagentTools(
-  subagentType: SubagentType,
-  requestedTools?: string[]
-): string[] {
-  const defaults = getTaskSubagentConfig(subagentType).tools;
-  if (!requestedTools || requestedTools.length === 0) {
-    return defaults;
-  }
-
-  const defaultSet = new Set(defaults);
-  const narrowed = requestedTools.filter((tool) => defaultSet.has(tool));
-  if (narrowed.length === 0) {
-    return defaults;
-  }
-  return narrowed;
-}

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

@@ -1,264 +0,0 @@
-import { randomUUID } from 'node:crypto';
-
-export const TASK_STATUS_VALUES = [
-  'pending',
-  'in_progress',
-  'completed',
-  'cancelled',
-  'failed',
-] as const;
-
-export type TaskStatus = (typeof TASK_STATUS_VALUES)[number];
-
-export const TASK_PRIORITY_VALUES = ['critical', 'high', 'normal', 'low'] as const;
-
-export type TaskPriority = (typeof TASK_PRIORITY_VALUES)[number];
-
-export const AGENT_RUN_STATUS_VALUES = [
-  'queued',
-  'running',
-  'completed',
-  'failed',
-  'cancelled',
-  'paused',
-  'timed_out',
-] as const;
-
-export type AgentRunStatus = (typeof AGENT_RUN_STATUS_VALUES)[number];
-
-export const SUBAGENT_TYPE_VALUES = [
-  'Bash',
-  'general-purpose',
-  'Explore',
-  'Restore',
-  'Plan',
-  'research-agent',
-  'find-skills',
-] as const;
-
-export type SubagentType = (typeof SUBAGENT_TYPE_VALUES)[number];
-
-export interface TaskCheckpoint {
-  id: string;
-  name: string;
-  completed: boolean;
-  completedAt?: number;
-}
-
-export interface TaskTag {
-  name: string;
-  color?: string;
-  category?: string;
-}
-
-export interface RetryConfig {
-  maxRetries: number;
-  retryDelayMs: number;
-  backoffMultiplier: number;
-  retryOn: string[];
-}
-
-export interface TaskHistoryEntry {
-  timestamp: number;
-  action: string;
-  fromStatus?: TaskStatus;
-  toStatus?: TaskStatus;
-  actor?: string | null;
-  reason?: string;
-  metadata?: Record<string, unknown>;
-}
-
-export interface TaskEntity {
-  id: string;
-  subject: string;
-  description: string;
-  activeForm: string;
-  status: TaskStatus;
-  priority: TaskPriority;
-  owner: string | null;
-  blockedBy: string[];
-  blocks: string[];
-  progress: number;
-  checkpoints: TaskCheckpoint[];
-  retryConfig: RetryConfig;
-  retryCount: number;
-  lastError?: string;
-  lastErrorAt?: number;
-  timeoutMs?: number;
-  tags: TaskTag[];
-  metadata: Record<string, unknown>;
-  history: TaskHistoryEntry[];
-  agentId?: string;
-  createdAt: number;
-  updatedAt: number;
-  startedAt?: number;
-  completedAt?: number;
-  cancelledAt?: number;
-  version: number;
-}
-
-export interface AgentRunEntity {
-  agentId: string;
-  status: AgentRunStatus;
-  subagentType: SubagentType;
-  prompt: string;
-  description?: string;
-  model?: 'sonnet' | 'opus' | 'haiku';
-  maxTurns?: number;
-  allowedTools?: string[];
-  linkedTaskId?: string;
-  output?: string;
-  error?: string;
-  progress?: number;
-  createdAt: number;
-  startedAt?: number;
-  endedAt?: number;
-  updatedAt: number;
-  outputFile?: string;
-  metadata: Record<string, unknown>;
-  version: number;
-}
-
-export interface DependencyGraphState {
-  adjacency: Record<string, string[]>;
-  reverse: Record<string, string[]>;
-}
-
-export interface TaskNamespaceState {
-  namespace: string;
-  tasks: Record<string, TaskEntity>;
-  agentRuns: Record<string, AgentRunEntity>;
-  graph: DependencyGraphState;
-  updatedAt: number;
-  schemaVersion: 1;
-}
-
-export interface CanStartResult {
-  canStart: boolean;
-  reason?: string;
-}
-
-export const DEFAULT_RETRY_CONFIG: RetryConfig = {
-  maxRetries: 3,
-  retryDelayMs: 5000,
-  backoffMultiplier: 2,
-  retryOn: ['timeout', 'network_error'],
-};
-
-export const VALID_TASK_TRANSITIONS: Record<TaskStatus, TaskStatus[]> = {
-  pending: ['in_progress', 'cancelled'],
-  in_progress: ['completed', 'pending', 'cancelled', 'failed'],
-  completed: [],
-  cancelled: [],
-  failed: ['pending'],
-};
-
-export function createTaskId(): string {
-  return `task_${Date.now()}_${randomUUID().slice(0, 8)}`;
-}
-
-export function createAgentId(): string {
-  return `agent_${Date.now()}_${randomUUID().slice(0, 8)}`;
-}
-
-export function isTaskTerminal(status: TaskStatus): boolean {
-  return status === 'completed' || status === 'cancelled';
-}
-
-export function isTaskFinal(status: TaskStatus): boolean {
-  return status === 'completed' || status === 'cancelled' || status === 'failed';
-}
-
-export function isAgentRunTerminal(status: AgentRunStatus): boolean {
-  return (
-    status === 'completed' ||
-    status === 'failed' ||
-    status === 'cancelled' ||
-    status === 'timed_out'
-  );
-}
-
-export function validateTaskTransition(from: TaskStatus, to: TaskStatus): boolean {
-  if (from === to) {
-    return true;
-  }
-  return VALID_TASK_TRANSITIONS[from].includes(to);
-}
-
-export function createEmptyNamespaceState(namespace: string): TaskNamespaceState {
-  return {
-    namespace,
-    tasks: {},
-    agentRuns: {},
-    graph: {
-      adjacency: {},
-      reverse: {},
-    },
-    updatedAt: Date.now(),
-    schemaVersion: 1,
-  };
-}
-
-export function evaluateTaskCanStart(
-  task: TaskEntity,
-  allTasks: Record<string, TaskEntity>
-): CanStartResult {
-  if (task.status !== 'pending') {
-    return {
-      canStart: false,
-      reason: `Task status is ${task.status}, expected pending`,
-    };
-  }
-
-  if (task.owner) {
-    return {
-      canStart: false,
-      reason: `Task is already owned by ${task.owner}`,
-    };
-  }
-
-  const cancelledBlockers: string[] = [];
-  const failedBlockers: string[] = [];
-  const incompleteBlockers: string[] = [];
-
-  for (const blockerId of task.blockedBy) {
-    const blocker = allTasks[blockerId];
-    if (!blocker) {
-      incompleteBlockers.push(blockerId);
-      continue;
-    }
-    if (blocker.status === 'cancelled') {
-      cancelledBlockers.push(blockerId);
-      continue;
-    }
-    if (blocker.status === 'failed') {
-      failedBlockers.push(blockerId);
-      continue;
-    }
-    if (blocker.status !== 'completed') {
-      incompleteBlockers.push(blockerId);
-    }
-  }
-
-  if (cancelledBlockers.length > 0 || failedBlockers.length > 0) {
-    return {
-      canStart: false,
-      reason:
-        `Blocked by cancelled/failed dependencies: ` +
-        `${[...cancelledBlockers, ...failedBlockers].join(', ')}`,
-    };
-  }
-
-  if (incompleteBlockers.length > 0) {
-    return {
-      canStart: false,
-      reason: `Blocked by incomplete dependencies: ${incompleteBlockers.join(', ')}`,
-    };
-  }
-
-  return { canStart: true };
-}
-
-export function safeJsonClone<T>(value: T): T {
-  return JSON.parse(JSON.stringify(value)) as T;
-}