@renxqoo/renx-code 0.0.3 → 0.0.5

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

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

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

@@ -0,0 +1,264 @@
+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;
+}