@renxqoo/renx-code 0.0.8 → 0.0.10

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

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

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

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

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

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