@renxqoo/renx-code 0.0.4 → 0.0.5

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

@@ -0,0 +1,315 @@
+import { z } from 'zod';
+import { BaseTool, type ToolResult } from './base-tool';
+import { buildTaskFailure, buildTaskSuccess, parsePrefixedError } from './task-errors';
+import { getTaskStore, type TaskStore } from './task-store';
+import {
+  evaluateTaskCanStart,
+  isTaskTerminal,
+  safeJsonClone,
+  validateTaskTransition,
+  type TaskHistoryEntry,
+} from './task-types';
+import {
+  addDependencyEdge,
+  ensureGraphNode,
+  removeDependencyEdge,
+  wouldCreateCycle,
+} from './task-graph';
+import { TASK_UPDATE_DESCRIPTION } from './tool-prompts';
+
+const schema = z
+  .object({
+    namespace: z.string().min(1).optional().describe('Optional task namespace'),
+    task_id: z.string().min(1).describe('Task identifier to update'),
+    status: z
+      .enum(['pending', 'in_progress', 'completed', 'cancelled', 'failed'])
+      .optional()
+      .describe('Optional task status update'),
+    expected_version: z
+      .number()
+      .int()
+      .min(1)
+      .optional()
+      .describe('Optional optimistic lock version'),
+    subject: z.string().min(3).optional().describe('Optional task title update'),
+    description: z.string().min(10).optional().describe('Optional task description update'),
+    active_form: z.string().min(1).optional().describe('Optional active-form text update'),
+    priority: z
+      .enum(['critical', 'high', 'normal', 'low'])
+      .optional()
+      .describe('Optional priority update'),
+    owner: z
+      .union([z.string().min(1), z.null()])
+      .optional()
+      .describe('Optional owner update (or null to clear)'),
+    progress: z.number().int().min(0).max(100).optional().describe('Optional progress percentage'),
+    metadata: z
+      .record(z.string(), z.unknown())
+      .optional()
+      .describe('Optional metadata merge patch'),
+    add_blocked_by: z
+      .array(z.string().min(1))
+      .optional()
+      .describe('Dependency ids to add as blockers'),
+    remove_blocked_by: z
+      .array(z.string().min(1))
+      .optional()
+      .describe('Dependency ids to remove from blockers'),
+    reason: z.string().optional().describe('Optional reason for update/audit trail'),
+    updated_by: z.string().optional().describe('Optional actor identifier'),
+  })
+  .strict();
+
+type TaskUpdateArgs = z.infer<typeof schema>;
+
+export interface TaskUpdateToolOptions {
+  store?: TaskStore;
+  defaultNamespace?: string;
+}
+
+function pushUnique(items: string[], id: string): void {
+  if (!items.includes(id)) {
+    items.push(id);
+  }
+}
+
+function removeItem(items: string[], id: string): void {
+  const index = items.indexOf(id);
+  if (index >= 0) {
+    items.splice(index, 1);
+  }
+}
+
+export class TaskUpdateTool extends BaseTool<typeof schema> {
+  name = 'task_update';
+  description = TASK_UPDATE_DESCRIPTION;
+  parameters = schema;
+
+  private readonly store: TaskStore;
+  private readonly defaultNamespace?: string;
+
+  constructor(options: TaskUpdateToolOptions = {}) {
+    super();
+    this.store = options.store || getTaskStore();
+    this.defaultNamespace = options.defaultNamespace;
+  }
+
+  override getConcurrencyMode(): 'exclusive' {
+    return 'exclusive';
+  }
+
+  override getConcurrencyLockKey(args: TaskUpdateArgs): string {
+    const namespace = args.namespace || this.defaultNamespace || 'default';
+    return `taskns:${namespace}`;
+  }
+
+  async execute(args: TaskUpdateArgs): Promise<ToolResult> {
+    const namespace = args.namespace || this.defaultNamespace;
+
+    const hasAnyChange =
+      args.status !== undefined ||
+      args.subject !== undefined ||
+      args.description !== undefined ||
+      args.active_form !== undefined ||
+      args.priority !== undefined ||
+      args.owner !== undefined ||
+      args.progress !== undefined ||
+      args.metadata !== undefined ||
+      (args.add_blocked_by && args.add_blocked_by.length > 0) ||
+      (args.remove_blocked_by && args.remove_blocked_by.length > 0);
+
+    if (!hasAnyChange) {
+      return buildTaskFailure('TASK_UPDATE_EMPTY', 'no update fields provided', {
+        task_id: args.task_id,
+      });
+    }
+
+    try {
+      const updated = await this.store.updateState(namespace, (state) => {
+        const task = state.tasks[args.task_id];
+        if (!task) {
+          throw new Error(`TASK_NOT_FOUND: task not found: ${args.task_id}`);
+        }
+
+        if (args.expected_version && task.version !== args.expected_version) {
+          throw new Error(
+            `TASK_VERSION_CONFLICT: expected ${args.expected_version}, actual ${task.version}`
+          );
+        }
+
+        const previousStatus = task.status;
+        const previousOwner = task.owner;
+        const now = Date.now();
+
+        if (isTaskTerminal(task.status)) {
+          throw new Error(`TASK_TERMINAL_IMMUTABLE: task is terminal (${task.status})`);
+        }
+
+        if (args.status && !validateTaskTransition(task.status, args.status)) {
+          throw new Error(
+            `TASK_INVALID_STATUS_TRANSITION: invalid transition ${task.status} -> ${args.status}`
+          );
+        }
+
+        const historyEntries: TaskHistoryEntry[] = [];
+
+        if (args.add_blocked_by && args.add_blocked_by.length > 0) {
+          for (const blockerId of args.add_blocked_by) {
+            const blocker = state.tasks[blockerId];
+            if (!blocker) {
+              throw new Error(`TASK_NOT_FOUND: blocker task not found: ${blockerId}`);
+            }
+            if (blockerId === task.id) {
+              throw new Error('TASK_CYCLE_DEPENDENCY: task cannot depend on itself');
+            }
+            ensureGraphNode(state.graph, blockerId);
+            ensureGraphNode(state.graph, task.id);
+            if (wouldCreateCycle(state.graph, blockerId, task.id)) {
+              throw new Error(
+                `TASK_CYCLE_DEPENDENCY: adding dependency ${blockerId} -> ${task.id} creates cycle`
+              );
+            }
+
+            addDependencyEdge(state.graph, blockerId, task.id);
+            pushUnique(task.blockedBy, blockerId);
+            pushUnique(blocker.blocks, task.id);
+          }
+
+          historyEntries.push({
+            timestamp: now,
+            action: 'dependency_added',
+            actor: args.updated_by || null,
+            reason: args.reason,
+            metadata: {
+              blockedBy: safeJsonClone(args.add_blocked_by),
+            },
+          });
+        }
+
+        if (args.remove_blocked_by && args.remove_blocked_by.length > 0) {
+          for (const blockerId of args.remove_blocked_by) {
+            const blocker = state.tasks[blockerId];
+            if (!blocker) {
+              continue;
+            }
+
+            removeDependencyEdge(state.graph, blockerId, task.id);
+            removeItem(task.blockedBy, blockerId);
+            removeItem(blocker.blocks, task.id);
+          }
+
+          historyEntries.push({
+            timestamp: now,
+            action: 'dependency_removed',
+            actor: args.updated_by || null,
+            reason: args.reason,
+            metadata: {
+              blockedBy: safeJsonClone(args.remove_blocked_by),
+            },
+          });
+        }
+
+        if (args.subject !== undefined) task.subject = args.subject.trim();
+        if (args.description !== undefined) task.description = args.description.trim();
+        if (args.active_form !== undefined) task.activeForm = args.active_form.trim();
+        if (args.priority !== undefined) task.priority = args.priority;
+        if (args.owner !== undefined) task.owner = args.owner;
+        if (args.progress !== undefined) task.progress = args.progress;
+        if (args.metadata !== undefined) {
+          task.metadata = {
+            ...task.metadata,
+            ...safeJsonClone(args.metadata),
+          };
+        }
+
+        if (args.status !== undefined) {
+          task.status = args.status;
+          if (args.status === 'in_progress' && previousStatus !== 'in_progress') {
+            task.startedAt = now;
+          }
+          if (args.status === 'completed') {
+            task.completedAt = now;
+            task.progress = 100;
+            task.owner = null;
+          }
+          if (args.status === 'cancelled') {
+            task.cancelledAt = now;
+            task.owner = null;
+          }
+          if (
+            args.status === 'pending' &&
+            previousStatus === 'in_progress' &&
+            args.owner === undefined
+          ) {
+            task.owner = null;
+          }
+          if (args.status === 'failed') {
+            task.lastError = args.reason || task.lastError || 'task marked as failed';
+            task.lastErrorAt = now;
+            task.owner = null;
+          }
+        }
+
+        if (args.status !== undefined && previousStatus !== task.status) {
+          historyEntries.push({
+            timestamp: now,
+            action: task.status === 'cancelled' ? 'cancelled' : 'status_changed',
+            fromStatus: previousStatus,
+            toStatus: task.status,
+            actor: args.updated_by || null,
+            reason: args.reason,
+          });
+        }
+
+        if (args.owner !== undefined && previousOwner !== task.owner) {
+          historyEntries.push({
+            timestamp: now,
+            action: 'owner_changed',
+            actor: args.updated_by || null,
+            reason: args.reason,
+            metadata: {
+              from: previousOwner,
+              to: task.owner,
+            },
+          });
+        }
+
+        if (
+          args.status === undefined &&
+          args.add_blocked_by === undefined &&
+          args.remove_blocked_by === undefined
+        ) {
+          historyEntries.push({
+            timestamp: now,
+            action: 'updated',
+            actor: args.updated_by || null,
+            reason: args.reason,
+          });
+        }
+
+        task.history.push(...historyEntries);
+        task.updatedAt = now;
+        task.version += 1;
+        ensureGraphNode(state.graph, task.id);
+
+        return safeJsonClone(task);
+      });
+
+      const canStart = evaluateTaskCanStart(updated.result, updated.state.tasks);
+
+      return buildTaskSuccess({
+        namespace: this.store.normalizeNamespace(namespace),
+        task: updated.result,
+        can_start: canStart,
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const parsed = parsePrefixedError(message);
+      return buildTaskFailure(parsed.code, parsed.detail, {
+        task_id: args.task_id,
+      });
+    }
+  }
+}
+
+export default TaskUpdateTool;

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

@@ -0,0 +1,209 @@
+import { z } from 'zod';
+import { BaseTool, type ToolResult } from './base-tool';
+import { buildTaskFailure, buildTaskSuccess, parsePrefixedError } from './task-errors';
+import { getTaskStore, type TaskStore } from './task-store';
+import {
+  createUnconfiguredSubagentRunnerAdapter,
+  type StartAgentInput,
+  type SubagentRunnerAdapter,
+} from './task-runner-adapter';
+import { getTaskSubagentConfig, resolveTaskSubagentTools } from './task-subagent-config';
+import { attachParentAbortCascade } from './task-parent-abort';
+import {
+  evaluateTaskCanStart,
+  isAgentRunTerminal,
+  safeJsonClone,
+  type SubagentType,
+} from './task-types';
+import type { ToolExecutionContext } from './types';
+import { TASK_TOOL_DESCRIPTION } from './tool-prompts';
+
+const runInBackgroundSchema = z.preprocess((value) => {
+  if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'true') return true;
+    if (normalized === 'false') return false;
+  }
+  return value;
+}, z.boolean());
+
+const schema = z
+  .object({
+    namespace: z.string().min(1).optional().describe('Optional task namespace'),
+    subagent_type: z
+      .enum([
+        'Bash',
+        'general-purpose',
+        'Explore',
+        'Restore',
+        'Plan',
+        'research-agent',
+        'find-skills',
+      ])
+      .describe('The type of specialized agent to use for this task'),
+    prompt: z.string().min(1).describe('The task for the agent to perform'),
+    description: z.string().optional().describe('A short (3-5 words) description of the task'),
+
+    run_in_background: runInBackgroundSchema
+      .optional()
+      .describe('Run task in background and return agent/task id immediately'),
+  })
+  .strict();
+
+type LegacyTaskToolArgs = {
+  model?: 'sonnet' | 'opus' | 'haiku';
+  resume?: string;
+  allowed_tools?: string[];
+  linked_task_id?: string;
+  metadata?: Record<string, unknown>;
+};
+
+type TaskToolArgs = z.infer<typeof schema> & LegacyTaskToolArgs;
+
+export interface TaskToolOptions {
+  store?: TaskStore;
+  runner?: SubagentRunnerAdapter;
+  defaultNamespace?: string;
+}
+
+export class TaskTool extends BaseTool<typeof schema> {
+  name = 'agent';
+  description = TASK_TOOL_DESCRIPTION;
+  parameters = schema;
+
+  private readonly store: TaskStore;
+  private readonly runner: SubagentRunnerAdapter;
+  private readonly defaultNamespace?: string;
+
+  constructor(options: TaskToolOptions = {}) {
+    super();
+    this.store = options.store || getTaskStore();
+    this.runner = options.runner || createUnconfiguredSubagentRunnerAdapter();
+    this.defaultNamespace = options.defaultNamespace;
+  }
+
+  override getConcurrencyMode(): 'exclusive' {
+    return 'exclusive';
+  }
+
+  override getConcurrencyLockKey(args: TaskToolArgs): string {
+    const namespace = args.namespace || this.defaultNamespace || 'default';
+    return `taskns:${namespace}`;
+  }
+
+  async execute(args: TaskToolArgs, context?: ToolExecutionContext): Promise<ToolResult> {
+    const namespace = args.namespace || this.defaultNamespace;
+    const normalizedNamespace = this.store.normalizeNamespace(namespace);
+
+    try {
+      if (args.linked_task_id) {
+        const state = await this.store.getState(normalizedNamespace);
+        const linkedTask = state.tasks[args.linked_task_id];
+        if (!linkedTask) {
+          return buildTaskFailure(
+            'TASK_NOT_FOUND',
+            `linked task not found: ${args.linked_task_id}`,
+            {
+              namespace: normalizedNamespace,
+            }
+          );
+        }
+        const canStart = evaluateTaskCanStart(linkedTask, state.tasks);
+        if (!canStart.canStart && linkedTask.status === 'pending') {
+          return buildTaskFailure('TASK_BLOCKED', canStart.reason || 'linked task is blocked', {
+            task_id: args.linked_task_id,
+            namespace: normalizedNamespace,
+          });
+        }
+      }
+
+      const subagentType = args.subagent_type as SubagentType;
+      const subagentConfig = getTaskSubagentConfig(subagentType);
+      const startInput: StartAgentInput = {
+        subagentType,
+        prompt: args.prompt,
+        systemPrompt: subagentConfig.systemPrompt,
+        description: args.description,
+        model: args.model,
+        allowedTools: resolveTaskSubagentTools(subagentType, args.allowed_tools),
+        runInBackground: args.run_in_background === true,
+        resume: args.resume,
+        linkedTaskId: args.linked_task_id,
+        metadata: safeJsonClone(args.metadata || {}),
+      };
+
+      const run = await this.runner.start(normalizedNamespace, startInput, context);
+      const detachParentAbort = attachParentAbortCascade({
+        context,
+        namespace: normalizedNamespace,
+        agentId: run.agentId,
+        linkedTaskId: args.linked_task_id,
+        runner: this.runner,
+        store: this.store,
+      });
+
+      if (args.linked_task_id) {
+        await this.store.updateState(normalizedNamespace, (state) => {
+          const task = state.tasks[args.linked_task_id as string];
+          if (!task) {
+            return null;
+          }
+
+          const now = Date.now();
+          task.agentId = run.agentId;
+
+          if (run.status === 'completed') {
+            task.status = 'completed';
+            task.progress = 100;
+            task.owner = null;
+            task.completedAt = now;
+          } else if (run.status === 'cancelled') {
+            task.status = 'cancelled';
+            task.owner = null;
+            task.cancelledAt = now;
+          } else if (run.status === 'failed' || run.status === 'timed_out') {
+            task.status = 'failed';
+            task.owner = null;
+            task.lastError = run.error || `linked agent ${run.status}`;
+            task.lastErrorAt = now;
+          } else {
+            if (task.status === 'pending') {
+              task.status = 'in_progress';
+              task.startedAt = now;
+            }
+            task.owner = `agent:${run.agentId}`;
+          }
+
+          task.updatedAt = now;
+          task.version += 1;
+          task.history.push({
+            timestamp: now,
+            action: 'agent_linked',
+            actor: 'task-tool',
+            metadata: {
+              agentId: run.agentId,
+              agentStatus: run.status,
+            },
+          });
+          return null;
+        });
+      }
+      if (isAgentRunTerminal(run.status)) {
+        detachParentAbort();
+      }
+
+      return buildTaskSuccess({
+        namespace: normalizedNamespace,
+        agent_run: run,
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const parsed = parsePrefixedError(message);
+      return buildTaskFailure(parsed.code, parsed.detail, {
+        namespace: normalizedNamespace,
+      });
+    }
+  }
+}
+
+export default TaskTool;