@renxqoo/renx-code 0.0.3 → 0.0.5

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

@@ -0,0 +1,186 @@
+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 {
+  DEFAULT_RETRY_CONFIG,
+  createTaskId,
+  safeJsonClone,
+  type RetryConfig,
+  type TaskCheckpoint,
+  type TaskEntity,
+  type TaskTag,
+  type TaskPriority,
+} from './task-types';
+import { ensureGraphNode } from './task-graph';
+import { TASK_CREATE_DESCRIPTION } from './tool-prompts';
+
+const checkpointSchema = z
+  .object({
+    id: z.string().min(1).describe('Checkpoint identifier'),
+    name: z.string().min(1).describe('Checkpoint display name'),
+    completed: z.boolean().optional().describe('Whether checkpoint is already completed'),
+  })
+  .strict();
+
+const retryConfigSchema = z
+  .object({
+    maxRetries: z.number().int().min(0).describe('Maximum retry attempts'),
+    retryDelayMs: z.number().int().min(0).describe('Initial delay between retries in milliseconds'),
+    backoffMultiplier: z.number().min(1).describe('Exponential backoff multiplier'),
+    retryOn: z.array(z.string().min(1)).describe('Error categories that should trigger retry'),
+  })
+  .strict();
+
+const tagSchema = z
+  .object({
+    name: z.string().min(1).describe('Tag name'),
+    color: z.string().optional().describe('Optional color hint'),
+    category: z.string().optional().describe('Optional tag category'),
+  })
+  .strict();
+
+const schema = z
+  .object({
+    namespace: z.string().min(1).optional().describe('Optional task namespace'),
+    subject: z.string().min(3).describe('A brief actionable title in imperative form'),
+    description: z
+      .string()
+      .min(10)
+      .describe('Detailed task description with context and acceptance criteria'),
+    active_form: z
+      .string()
+      .min(1)
+      .optional()
+      .describe('Present continuous form shown while task is in progress'),
+    priority: z.enum(['critical', 'high', 'normal', 'low']).optional().describe('Task priority'),
+    tags: z.array(tagSchema).optional().describe('Optional task tags'),
+    checkpoints: z
+      .array(checkpointSchema)
+      .optional()
+      .describe('Optional checkpoints for progress tracking'),
+    retry_config: retryConfigSchema.optional().describe('Optional retry behavior configuration'),
+    timeout_ms: z
+      .number()
+      .int()
+      .positive()
+      .optional()
+      .describe('Optional timeout budget in milliseconds'),
+    metadata: z.record(z.string(), z.unknown()).optional().describe('Optional metadata map'),
+    created_by: z.string().optional().describe('Optional actor identifier'),
+  })
+  .strict();
+
+type TaskCreateArgs = z.infer<typeof schema>;
+
+export interface TaskCreateToolOptions {
+  store?: TaskStore;
+  defaultNamespace?: string;
+}
+
+export class TaskCreateTool extends BaseTool<typeof schema> {
+  name = 'task_create';
+  description = TASK_CREATE_DESCRIPTION;
+  parameters = schema;
+
+  private readonly store: TaskStore;
+  private readonly defaultNamespace?: string;
+
+  constructor(options: TaskCreateToolOptions = {}) {
+    super();
+    this.store = options.store || getTaskStore();
+    this.defaultNamespace = options.defaultNamespace;
+  }
+
+  override getConcurrencyMode(): 'exclusive' {
+    return 'exclusive';
+  }
+
+  override getConcurrencyLockKey(args: TaskCreateArgs): string {
+    const namespace = args.namespace || this.defaultNamespace || 'default';
+    return `taskns:${namespace}`;
+  }
+
+  async execute(args: TaskCreateArgs): Promise<ToolResult> {
+    const namespace = args.namespace || this.defaultNamespace;
+
+    try {
+      const created = await this.store.updateState(namespace, (state) => {
+        const now = Date.now();
+        const normalizedSubject = args.subject.trim();
+
+        const duplicate = Object.values(state.tasks).find(
+          (task) =>
+            task.subject === normalizedSubject &&
+            task.status !== 'completed' &&
+            task.status !== 'cancelled' &&
+            task.status !== 'failed'
+        );
+        if (duplicate) {
+          throw new Error(
+            `TASK_DUPLICATE_SUBJECT: duplicate active task subject already exists: ${duplicate.id}`
+          );
+        }
+
+        const id = createTaskId();
+        const checkpointItems: TaskCheckpoint[] = (args.checkpoints || []).map((checkpoint) => ({
+          id: checkpoint.id,
+          name: checkpoint.name,
+          completed: checkpoint.completed || false,
+        }));
+        const retryConfig: RetryConfig = args.retry_config
+          ? safeJsonClone(args.retry_config as RetryConfig)
+          : safeJsonClone(DEFAULT_RETRY_CONFIG);
+        const tags: TaskTag[] = (args.tags || []).map((tag) => safeJsonClone(tag));
+
+        const task: TaskEntity = {
+          id,
+          subject: normalizedSubject,
+          description: args.description.trim(),
+          activeForm: args.active_form?.trim() || `${normalizedSubject} in progress`,
+          status: 'pending',
+          priority: (args.priority || 'normal') as TaskPriority,
+          owner: null,
+          blockedBy: [],
+          blocks: [],
+          progress: 0,
+          checkpoints: checkpointItems,
+          retryConfig,
+          retryCount: 0,
+          timeoutMs: args.timeout_ms,
+          tags,
+          metadata: safeJsonClone(args.metadata || {}),
+          history: [
+            {
+              timestamp: now,
+              action: 'created',
+              actor: args.created_by || null,
+              metadata: {
+                subject: normalizedSubject,
+              },
+            },
+          ],
+          createdAt: now,
+          updatedAt: now,
+          version: 1,
+        };
+
+        state.tasks[id] = task;
+        ensureGraphNode(state.graph, id);
+
+        return safeJsonClone(task);
+      });
+
+      return buildTaskSuccess({
+        namespace: this.store.normalizeNamespace(namespace),
+        task: created.result,
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const parsed = parsePrefixedError(message);
+      return buildTaskFailure(parsed.code, parsed.detail);
+    }
+  }
+}
+
+export default TaskCreateTool;

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

@@ -0,0 +1,42 @@
+import { ToolExecutionError } from './error';
+import type { ToolResult } from './base-tool';
+
+export function buildTaskFailure(
+  code: string,
+  message: string,
+  details?: Record<string, unknown>
+): ToolResult {
+  const output = `${code}: ${message}`;
+  return {
+    success: false,
+    output,
+    error: new ToolExecutionError(output),
+    metadata: {
+      error: code,
+      message,
+      ...(details || {}),
+    },
+  };
+}
+
+export function buildTaskSuccess(payload: Record<string, unknown>): ToolResult {
+  return {
+    success: true,
+    output: JSON.stringify(payload),
+    metadata: payload,
+  };
+}
+
+export function parsePrefixedError(message: string): { code: string; detail: string } {
+  const matched = message.match(/^([A-Z][A-Z0-9_]{2,}):\s*(.*)$/);
+  if (!matched) {
+    return {
+      code: 'TASK_OPERATION_FAILED',
+      detail: message,
+    };
+  }
+  return {
+    code: matched[1],
+    detail: matched[2],
+  };
+}

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

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+import { BaseTool, type ToolResult } from './base-tool';
+import { buildTaskFailure, buildTaskSuccess } from './task-errors';
+import { getTaskStore, type TaskStore } from './task-store';
+import { evaluateTaskCanStart, safeJsonClone, type TaskEntity } from './task-types';
+import { TASK_GET_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 retrieve'),
+    include_history: z.boolean().optional().describe('Include full history entries when true'),
+  })
+  .strict();
+
+type TaskGetArgs = z.infer<typeof schema>;
+
+export interface TaskGetToolOptions {
+  store?: TaskStore;
+  defaultNamespace?: string;
+}
+
+function calculateCheckpointProgress(task: TaskEntity): number {
+  if (!task.checkpoints || task.checkpoints.length === 0) {
+    return 0;
+  }
+  const completedCount = task.checkpoints.filter((checkpoint) => checkpoint.completed).length;
+  return Math.round((completedCount / task.checkpoints.length) * 100);
+}
+
+export class TaskGetTool extends BaseTool<typeof schema> {
+  name = 'task_get';
+  description = TASK_GET_DESCRIPTION;
+  parameters = schema;
+
+  private readonly store: TaskStore;
+  private readonly defaultNamespace?: string;
+
+  constructor(options: TaskGetToolOptions = {}) {
+    super();
+    this.store = options.store || getTaskStore();
+    this.defaultNamespace = options.defaultNamespace;
+  }
+
+  override getConcurrencyMode(): 'parallel-safe' {
+    return 'parallel-safe';
+  }
+
+  override getConcurrencyLockKey(args: TaskGetArgs): string {
+    const namespace = args.namespace || this.defaultNamespace || 'default';
+    return `taskns:${namespace}:task:${args.task_id}`;
+  }
+
+  async execute(args: TaskGetArgs): Promise<ToolResult> {
+    const namespace = args.namespace || this.defaultNamespace;
+    const normalizedNamespace = this.store.normalizeNamespace(namespace);
+    const state = await this.store.getState(normalizedNamespace);
+
+    const task = state.tasks[args.task_id];
+    if (!task) {
+      return buildTaskFailure('TASK_NOT_FOUND', `task not found: ${args.task_id}`, {
+        namespace: normalizedNamespace,
+        task_id: args.task_id,
+      });
+    }
+
+    const blockers = task.blockedBy.map((blockerId) => {
+      const blocker = state.tasks[blockerId];
+      return blocker
+        ? {
+            id: blocker.id,
+            subject: blocker.subject,
+            status: blocker.status,
+          }
+        : {
+            id: blockerId,
+            subject: '(missing task)',
+            status: 'missing',
+          };
+    });
+
+    const blockedTasks = task.blocks.map((blockedTaskId) => {
+      const blockedTask = state.tasks[blockedTaskId];
+      return blockedTask
+        ? {
+            id: blockedTask.id,
+            subject: blockedTask.subject,
+            status: blockedTask.status,
+          }
+        : {
+            id: blockedTaskId,
+            subject: '(missing task)',
+            status: 'missing',
+          };
+    });
+
+    const checkpointProgress = calculateCheckpointProgress(task);
+    const canStart = evaluateTaskCanStart(task, state.tasks);
+    const detail = {
+      ...safeJsonClone(task),
+      blockers,
+      blocked_tasks: blockedTasks,
+      can_start: canStart,
+      checkpoint_progress: checkpointProgress,
+      effective_progress: Math.max(task.progress, checkpointProgress),
+      history: args.include_history === true ? safeJsonClone(task.history) : undefined,
+    };
+
+    return buildTaskSuccess({
+      namespace: normalizedNamespace,
+      task: detail,
+    });
+  }
+}
+
+export default TaskGetTool;

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

@@ -0,0 +1,78 @@
+import type { DependencyGraphState } from './task-types';
+
+function ensureUniquePush(values: string[], next: string): void {
+  if (!values.includes(next)) {
+    values.push(next);
+  }
+}
+
+export function ensureGraphNode(graph: DependencyGraphState, taskId: string): void {
+  if (!graph.adjacency[taskId]) {
+    graph.adjacency[taskId] = [];
+  }
+  if (!graph.reverse[taskId]) {
+    graph.reverse[taskId] = [];
+  }
+}
+
+export function addDependencyEdge(
+  graph: DependencyGraphState,
+  blockerId: string,
+  dependentId: string
+): void {
+  ensureGraphNode(graph, blockerId);
+  ensureGraphNode(graph, dependentId);
+  ensureUniquePush(graph.adjacency[blockerId], dependentId);
+  ensureUniquePush(graph.reverse[dependentId], blockerId);
+}
+
+export function removeDependencyEdge(
+  graph: DependencyGraphState,
+  blockerId: string,
+  dependentId: string
+): void {
+  ensureGraphNode(graph, blockerId);
+  ensureGraphNode(graph, dependentId);
+  graph.adjacency[blockerId] = graph.adjacency[blockerId].filter((id) => id !== dependentId);
+  graph.reverse[dependentId] = graph.reverse[dependentId].filter((id) => id !== blockerId);
+}
+
+export function hasPath(graph: DependencyGraphState, fromId: string, toId: string): boolean {
+  if (fromId === toId) {
+    return true;
+  }
+
+  const visited = new Set<string>();
+  const queue: string[] = [fromId];
+
+  while (queue.length > 0) {
+    const current = queue.shift() as string;
+    if (current === toId) {
+      return true;
+    }
+    if (visited.has(current)) {
+      continue;
+    }
+    visited.add(current);
+    const nextNodes = graph.adjacency[current] || [];
+    for (const next of nextNodes) {
+      if (!visited.has(next)) {
+        queue.push(next);
+      }
+    }
+  }
+
+  return false;
+}
+
+export function wouldCreateCycle(
+  graph: DependencyGraphState,
+  blockerId: string,
+  dependentId: string
+): boolean {
+  if (blockerId === dependentId) {
+    return true;
+  }
+  // If dependent can already reach blocker, blocker -> dependent creates a cycle.
+  return hasPath(graph, dependentId, blockerId);
+}

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

@@ -0,0 +1,141 @@
+import { z } from 'zod';
+import { BaseTool, type ToolResult } from './base-tool';
+import { buildTaskSuccess } from './task-errors';
+import { getTaskStore, type TaskStore } from './task-store';
+import { safeJsonClone, type TaskEntity, type TaskPriority, type TaskStatus } from './task-types';
+import { TASK_LIST_DESCRIPTION } from './tool-prompts';
+
+const schema = z
+  .object({
+    namespace: z.string().min(1).optional().describe('Optional task namespace'),
+    statuses: z
+      .array(z.enum(['pending', 'in_progress', 'completed', 'cancelled', 'failed']))
+      .optional()
+      .describe('Optional status filter'),
+    owner: z.string().min(1).optional().describe('Optional owner filter'),
+    tag: z.string().min(1).optional().describe('Optional tag-name filter'),
+    include_history: z.boolean().optional().describe('Include history for each returned task'),
+  })
+  .strict();
+
+type TaskListArgs = z.infer<typeof schema>;
+
+export interface TaskListToolOptions {
+  store?: TaskStore;
+  defaultNamespace?: string;
+}
+
+interface TaskSummary {
+  id: string;
+  subject: string;
+  status: TaskStatus;
+  priority: TaskPriority;
+  owner: string | null;
+  blocked_by: string[];
+  blocks: string[];
+  progress: number;
+  is_blocked: boolean;
+  can_be_claimed: boolean;
+  created_at: number;
+  updated_at: number;
+  history?: unknown;
+}
+
+function computeSummary(task: TaskEntity, taskMap: Record<string, TaskEntity>): TaskSummary {
+  const blockedByCount = task.blockedBy.filter((blockerId) => {
+    const blocker = taskMap[blockerId];
+    return !blocker || blocker.status !== 'completed';
+  }).length;
+  return {
+    id: task.id,
+    subject: task.subject,
+    status: task.status,
+    priority: task.priority,
+    owner: task.owner,
+    blocked_by: safeJsonClone(task.blockedBy),
+    blocks: safeJsonClone(task.blocks),
+    progress: task.progress,
+    is_blocked: blockedByCount > 0,
+    can_be_claimed: task.status === 'pending' && blockedByCount === 0 && !task.owner,
+    created_at: task.createdAt,
+    updated_at: task.updatedAt,
+  };
+}
+
+function rankTask(summary: TaskSummary): number {
+  if (summary.can_be_claimed && summary.priority === 'critical') return 0;
+  if (summary.status === 'in_progress') return 1;
+  if (summary.can_be_claimed && summary.priority === 'high') return 2;
+  if (summary.can_be_claimed && summary.priority === 'normal') return 3;
+  if (summary.can_be_claimed && summary.priority === 'low') return 4;
+  if (summary.is_blocked) return 5;
+  if (summary.status === 'completed') return 6;
+  if (summary.status === 'cancelled' || summary.status === 'failed') return 7;
+  return 8;
+}
+
+export class TaskListTool extends BaseTool<typeof schema> {
+  name = 'task_list';
+  description = TASK_LIST_DESCRIPTION;
+  parameters = schema;
+
+  private readonly store: TaskStore;
+  private readonly defaultNamespace?: string;
+
+  constructor(options: TaskListToolOptions = {}) {
+    super();
+    this.store = options.store || getTaskStore();
+    this.defaultNamespace = options.defaultNamespace;
+  }
+
+  override getConcurrencyMode(): 'parallel-safe' {
+    return 'parallel-safe';
+  }
+
+  override getConcurrencyLockKey(args: TaskListArgs): string {
+    const namespace = args.namespace || this.defaultNamespace || 'default';
+    return `taskns:${namespace}:list`;
+  }
+
+  async execute(args: TaskListArgs): Promise<ToolResult> {
+    const namespace = args.namespace || this.defaultNamespace;
+    const normalizedNamespace = this.store.normalizeNamespace(namespace);
+    const state = await this.store.getState(normalizedNamespace);
+    const tasks = Object.values(state.tasks);
+
+    let filtered = tasks;
+    if (args.statuses && args.statuses.length > 0) {
+      const statusSet = new Set(args.statuses);
+      filtered = filtered.filter((task) => statusSet.has(task.status));
+    }
+    if (args.owner) {
+      filtered = filtered.filter((task) => task.owner === args.owner);
+    }
+    if (args.tag) {
+      filtered = filtered.filter((task) => task.tags.some((tag) => tag.name === args.tag));
+    }
+
+    const summaries = filtered.map((task) => {
+      const summary = computeSummary(task, state.tasks);
+      if (args.include_history === true) {
+        summary.history = safeJsonClone(task.history);
+      }
+      return summary;
+    });
+
+    summaries.sort((a, b) => {
+      const rankDelta = rankTask(a) - rankTask(b);
+      if (rankDelta !== 0) return rankDelta;
+      if (a.created_at !== b.created_at) return a.created_at - b.created_at;
+      return a.id.localeCompare(b.id);
+    });
+
+    return buildTaskSuccess({
+      namespace: normalizedNamespace,
+      total: summaries.length,
+      tasks: summaries,
+    });
+  }
+}
+
+export default TaskListTool;