@ai-setting/roy-agent-cli 1.3.14 → 1.3.16

package/dist/core/src/env/task/tools/task-types.d.ts

@@ -0,0 +1,114 @@
+/**
+ * @fileoverview Task Tool Parameter Schemas
+ */
+import { z } from "zod";
+/**
+ * task_create tool parameters
+ */
+export declare const CreateTaskToolSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    goals_and_expected_deliverables: z.ZodOptional<z.ZodString>;
+    due_date: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    tags?: string[];
+    description?: string;
+    priority?: "low" | "medium" | "high";
+    title?: string;
+    goals_and_expected_deliverables?: string;
+    due_date?: string;
+}, {
+    tags?: string[];
+    description?: string;
+    priority?: "low" | "medium" | "high";
+    title?: string;
+    goals_and_expected_deliverables?: string;
+    due_date?: string;
+}>;
+export type CreateTaskToolParams = z.infer<typeof CreateTaskToolSchema>;
+/**
+ * task_get tool parameters
+ */
+export declare const GetTaskToolSchema: z.ZodObject<{
+    task_id: z.ZodNumber;
+    include_operations: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    task_id?: number;
+    include_operations?: boolean;
+}, {
+    task_id?: number;
+    include_operations?: boolean;
+}>;
+export type GetTaskToolParams = z.infer<typeof GetTaskToolSchema>;
+/**
+ * task_list tool parameters
+ */
+export declare const ListTasksToolSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<["todo", "active", "completed", "paused", "cancelled"]>>;
+    priority: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    status?: "completed" | "paused" | "active" | "todo" | "cancelled";
+    priority?: "low" | "medium" | "high";
+    offset?: number;
+    limit?: number;
+}, {
+    status?: "completed" | "paused" | "active" | "todo" | "cancelled";
+    priority?: "low" | "medium" | "high";
+    offset?: number;
+    limit?: number;
+}>;
+export type ListTasksToolParams = z.infer<typeof ListTasksToolSchema>;
+/**
+ * task_update tool parameters
+ */
+export declare const UpdateTaskToolSchema: z.ZodObject<{
+    task_id: z.ZodNumber;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["todo", "active", "completed", "paused", "cancelled"]>>;
+    priority: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    progress: z.ZodOptional<z.ZodNumber>;
+    current_status: z.ZodOptional<z.ZodString>;
+    goals_and_expected_deliverables: z.ZodOptional<z.ZodString>;
+    due_date: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    status?: "completed" | "paused" | "active" | "todo" | "cancelled";
+    tags?: string[];
+    description?: string;
+    priority?: "low" | "medium" | "high";
+    title?: string;
+    progress?: number;
+    goals_and_expected_deliverables?: string;
+    due_date?: string;
+    task_id?: number;
+    current_status?: string;
+}, {
+    status?: "completed" | "paused" | "active" | "todo" | "cancelled";
+    tags?: string[];
+    description?: string;
+    priority?: "low" | "medium" | "high";
+    title?: string;
+    progress?: number;
+    goals_and_expected_deliverables?: string;
+    due_date?: string;
+    task_id?: number;
+    current_status?: string;
+}>;
+export type UpdateTaskToolParams = z.infer<typeof UpdateTaskToolSchema>;
+/**
+ * task_delete tool parameters
+ */
+export declare const DeleteTaskToolSchema: z.ZodObject<{
+    task_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    task_id?: number;
+}, {
+    task_id?: number;
+}>;
+export type DeleteTaskToolParams = z.infer<typeof DeleteTaskToolSchema>;
+//# sourceMappingURL=task-types.d.ts.map

package/dist/core/src/env/task/tools/task-types.js

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview Task Tool Parameter Schemas
+ */
+import { z } from "zod";
+/**
+ * task_create tool parameters
+ */
+export const CreateTaskToolSchema = z.object({
+    title: z.string().describe("Task title"),
+    description: z.string().optional().describe("Task description"),
+    priority: z.enum(["low", "medium", "high"]).optional().describe("Task priority"),
+    goals_and_expected_deliverables: z.string().optional().describe("Goals and expected deliverables"),
+    due_date: z.string().optional().describe("Due date (ISO format)"),
+    tags: z.array(z.string()).optional().describe("Task tags (for search, stored in task.tags JSON field)"),
+});
+/**
+ * task_get tool parameters
+ */
+export const GetTaskToolSchema = z.object({
+    task_id: z.number().describe("Task ID"),
+    include_operations: z.boolean().optional().default(false).describe("Include operation records"),
+});
+/**
+ * task_list tool parameters
+ */
+export const ListTasksToolSchema = z.object({
+    status: z.enum(["todo", "active", "completed", "paused", "cancelled"]).optional(),
+    priority: z.enum(["low", "medium", "high"]).optional(),
+    limit: z.number().optional().default(20),
+    offset: z.number().optional().default(0),
+});
+/**
+ * task_update tool parameters
+ */
+export const UpdateTaskToolSchema = z.object({
+    task_id: z.number().describe("Task ID"),
+    title: z.string().optional(),
+    description: z.string().optional(),
+    status: z.enum(["todo", "active", "completed", "paused", "cancelled"]).optional(),
+    priority: z.enum(["low", "medium", "high"]).optional(),
+    progress: z.number().min(0).max(100).optional(),
+    current_status: z.string().optional(),
+    goals_and_expected_deliverables: z.string().optional(),
+    due_date: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+});
+/**
+ * task_delete tool parameters
+ */
+export const DeleteTaskToolSchema = z.object({
+    task_id: z.number().describe("Task ID"),
+});
+//# sourceMappingURL=task-types.js.map

package/dist/core/src/env/task/tools/task-types.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview Test for task tool schemas
+ */
+export {};
+//# sourceMappingURL=task-types.test.d.ts.map

package/dist/core/src/env/task/tools/task-types.test.js

@@ -0,0 +1,63 @@
+/**
+ * @fileoverview Test for task tool schemas
+ */
+import { describe, expect, test } from "bun:test";
+import { CreateTaskToolSchema, UpdateTaskToolSchema } from "./task-types.js";
+describe("CreateTaskToolSchema", () => {
+    test("should accept task without tags (tags is optional)", () => {
+        // tags is now optional (for search, stored in task.tags JSON field)
+        const validParams = {
+            title: "Test task",
+        };
+        const result = CreateTaskToolSchema.safeParse(validParams);
+        expect(result.success).toBe(true);
+    });
+    test("should accept task with tags", () => {
+        const validParams = {
+            title: "Test task",
+            tags: ["test", "feature"],
+        };
+        const result = CreateTaskToolSchema.safeParse(validParams);
+        expect(result.success).toBe(true);
+    });
+    test("should accept empty tags array", () => {
+        // tags can be empty array
+        const params = {
+            title: "Test task",
+            tags: [],
+        };
+        const result = CreateTaskToolSchema.safeParse(params);
+        expect(result.success).toBe(true);
+    });
+    test("should accept all optional fields", () => {
+        const params = {
+            title: "Test task",
+            description: "Test description",
+            priority: "high",
+            goals_and_expected_deliverables: "Test goals",
+            due_date: "2025-12-31",
+            tags: ["test"],
+        };
+        const result = CreateTaskToolSchema.safeParse(params);
+        expect(result.success).toBe(true);
+    });
+});
+describe("UpdateTaskToolSchema", () => {
+    test("tags can be optional in update", () => {
+        const params = {
+            task_id: 1,
+            title: "Updated title",
+        };
+        const result = UpdateTaskToolSchema.safeParse(params);
+        expect(result.success).toBe(true);
+    });
+    test("should require task_id", () => {
+        const params = {
+            title: "Updated title",
+            tags: ["updated"],
+        };
+        const result = UpdateTaskToolSchema.safeParse(params);
+        expect(result.success).toBe(false);
+    });
+});
+//# sourceMappingURL=task-types.test.js.map

package/dist/core/src/env/task/tools/update-tool.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Task Update Tool
+ */
+import type { Tool } from "../../tool/types";
+import type { TaskComponent } from "../task-component";
+export declare function updateTaskTool(taskComponent: TaskComponent): Tool;
+//# sourceMappingURL=update-tool.d.ts.map

package/dist/core/src/env/task/tools/update-tool.js

@@ -0,0 +1,64 @@
+/**
+ * @fileoverview Task Update Tool
+ */
+import { UpdateTaskToolSchema } from "./task-types.js";
+export function updateTaskTool(taskComponent) {
+    return {
+        name: "task_update",
+        description: "Update an existing task's properties. Status and progress changes will create operation records.",
+        parameters: UpdateTaskToolSchema,
+        execute: async (args, ctx) => {
+            const params = UpdateTaskToolSchema.parse(args);
+            const sessionId = ctx.session_id || "unknown";
+            try {
+                const task = await taskComponent.updateTask(params.task_id, {
+                    title: params.title,
+                    description: params.description,
+                    status: params.status,
+                    priority: params.priority,
+                    progress: params.progress,
+                    current_status: params.current_status,
+                    goals_and_expected_deliverables: params.goals_and_expected_deliverables,
+                    due_date: params.due_date,
+                    tags: params.tags,
+                });
+                if (!task) {
+                    return {
+                        success: false,
+                        output: "",
+                        error: `Task not found: ${params.task_id}`,
+                        metadata: { execution_time_ms: 0 },
+                    };
+                }
+                // Create operation record for status/progress changes
+                if (params.status || params.progress !== undefined || params.current_status) {
+                    await taskComponent.createOperation({
+                        taskId: params.task_id,
+                        sessionId,
+                        actionType: "progress",
+                        actionTitle: params.current_status || `Updated: ${params.status || `${params.progress}%`}`,
+                        actionDescription: JSON.stringify({
+                            status: params.status,
+                            progress: params.progress,
+                            current_status: params.current_status,
+                        }),
+                    });
+                }
+                return {
+                    success: true,
+                    output: `Task updated: #${task.id} - ${task.title}`,
+                    metadata: { execution_time_ms: 0, task },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    output: "",
+                    error: error instanceof Error ? error.message : String(error),
+                    metadata: { execution_time_ms: 0 },
+                };
+            }
+        },
+    };
+}
+//# sourceMappingURL=update-tool.js.map

package/dist/core/src/env/task/types.d.ts

@@ -0,0 +1,129 @@
+/**
+ * @fileoverview Task Component Types
+ */
+import { z } from "zod";
+/**
+ * Task status enum
+ */
+export declare const TaskStatusEnum: z.ZodEnum<["todo", "active", "completed", "paused", "cancelled"]>;
+export type TaskStatus = z.infer<typeof TaskStatusEnum>;
+/**
+ * Task priority enum
+ */
+export declare const TaskPriorityEnum: z.ZodEnum<["low", "medium", "high"]>;
+export type TaskPriority = z.infer<typeof TaskPriorityEnum>;
+/**
+ * Action type for task operations
+ */
+export declare const ActionTypeEnum: z.ZodEnum<["create", "progress", "milestone", "problem", "solution", "decision", "review", "completed", "workflow_extracted"]>;
+export type ActionType = z.infer<typeof ActionTypeEnum>;
+/**
+ * Task entity
+ */
+export interface Task {
+    id: number;
+    title: string;
+    description: string;
+    status: TaskStatus;
+    priority: TaskPriority;
+    progress: number;
+    current_status: string;
+    goals_and_expected_deliverables: string;
+    parent_task_id?: number;
+    createdAt: string;
+    updatedAt: string;
+    due_date?: string;
+    tags?: string[];
+}
+/**
+ * TaskOperation entity
+ *
+ * 记录任务的操作历史，每个操作关联到一个 sessionId
+ */
+export interface TaskOperation {
+    id: number;
+    taskId: number;
+    sessionId: string;
+    actionType: ActionType;
+    actionTitle: string;
+    actionDescription: string;
+    timestamp: string;
+    mdPath?: string;
+}
+/**
+ * TaskTag entity
+ *
+ * Tag 池中的单个 Tag
+ */
+export interface TaskTag {
+    id: number;
+    name: string;
+    createdAt: string;
+    taskCount: number;
+}
+export declare const TaskConfigSchema: z.ZodDefault<z.ZodObject<{
+    storage: z.ZodDefault<z.ZodObject<{
+        type: z.ZodDefault<z.ZodEnum<["memory", "sqlite"]>>;
+        dbPath: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "memory" | "sqlite";
+        dbPath?: string;
+    }, {
+        type?: "memory" | "sqlite";
+        dbPath?: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    storage?: {
+        type?: "memory" | "sqlite";
+        dbPath?: string;
+    };
+}, {
+    storage?: {
+        type?: "memory" | "sqlite";
+        dbPath?: string;
+    };
+}>>;
+export type TaskConfig = z.infer<typeof TaskConfigSchema>;
+export interface CreateTaskOptions {
+    title: string;
+    description?: string;
+    priority?: TaskPriority;
+    parent_task_id?: number;
+    goals_and_expected_deliverables?: string;
+    due_date?: string;
+    tags?: string[];
+    sessionId: string;
+}
+export interface UpdateTaskOptions {
+    title?: string;
+    description?: string;
+    status?: TaskStatus;
+    priority?: TaskPriority;
+    progress?: number;
+    current_status?: string;
+    goals_and_expected_deliverables?: string;
+    due_date?: string;
+    tags?: string[];
+}
+export interface ListTasksOptions {
+    status?: TaskStatus;
+    priority?: TaskPriority;
+    parent_task_id?: number;
+    limit?: number;
+    offset?: number;
+}
+export interface CreateOperationOptions {
+    taskId: number;
+    sessionId: string;
+    actionType: ActionType;
+    actionTitle: string;
+    actionDescription?: string;
+    mdPath?: string;
+}
+export interface ListOperationsOptions {
+    taskId: number;
+    actionType?: ActionType;
+    limit?: number;
+    offset?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/src/env/task/types.js

@@ -0,0 +1,39 @@
+/**
+ * @fileoverview Task Component Types
+ */
+import { z } from "zod";
+// ============================================================================
+// Enums
+// ============================================================================
+/**
+ * Task status enum
+ */
+export const TaskStatusEnum = z.enum(["todo", "active", "completed", "paused", "cancelled"]);
+/**
+ * Task priority enum
+ */
+export const TaskPriorityEnum = z.enum(["low", "medium", "high"]);
+/**
+ * Action type for task operations
+ */
+export const ActionTypeEnum = z.enum([
+    "create",
+    "progress",
+    "milestone",
+    "problem",
+    "solution",
+    "decision",
+    "review",
+    "completed",
+    "workflow_extracted",
+]);
+// ============================================================================
+// Config Schema
+// ============================================================================
+export const TaskConfigSchema = z.object({
+    storage: z.object({
+        type: z.enum(["memory", "sqlite"]).default("sqlite"),
+        dbPath: z.string().optional(),
+    }).default({}),
+}).default({});
+//# sourceMappingURL=types.js.map

package/dist/core/src/env/tool/built-in/bash.d.ts

@@ -0,0 +1,11 @@
+import type { Tool } from "../types";
+/**
+ * Bash 工具
+ * 执行 shell 命令
+ *
+ * 支持 OpenTelemetry W3C TraceContext 跨进程追踪：
+ * - 通过 TRACEPARENT 环境变量传递 traceId 和 parentSpanId
+ * - 子进程可以正确关联到父 trace
+ */
+export declare const bashTool: Tool;
+//# sourceMappingURL=bash.d.ts.map

package/dist/core/src/env/tool/built-in/bash.js

@@ -0,0 +1,182 @@
+import { z } from "zod";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { propagation } from "../../log-trace/opentelemetry/propagation.js";
+const execAsync = promisify(exec);
+/**
+ * 获取当前 Span Context（用于设置父 span）
+ */
+function getCurrentSpanContext() {
+    try {
+        const { getTracerProvider } = require("../../log-trace/opentelemetry/tracer-provider");
+        const provider = getTracerProvider();
+        if (!provider.isInitialized()) {
+            throw new Error("Provider not initialized");
+        }
+        const tracer = provider.getTracer('roy-tracer');
+        const ctx = tracer.getCurrentContext();
+        if (ctx && ctx.traceId && ctx.spanId) {
+            return ctx;
+        }
+    }
+    catch {
+        // OTel tracer 未初始化或没有当前上下文
+    }
+    return undefined;
+}
+/**
+ * 获取当前 traceId
+ */
+function getCurrentTraceId() {
+    const ctx = getCurrentSpanContext();
+    if (ctx) {
+        return ctx.traceId;
+    }
+    // Fallback: 从环境变量读取
+    return process.env.TRACE_ID;
+}
+/**
+ * Bash 工具
+ * 执行 shell 命令
+ *
+ * 支持 OpenTelemetry W3C TraceContext 跨进程追踪：
+ * - 通过 TRACEPARENT 环境变量传递 traceId 和 parentSpanId
+ * - 子进程可以正确关联到父 trace
+ */
+export const bashTool = {
+    name: "bash",
+    description: "Execute shell commands in the terminal. Use this to run system commands, scripts, or interact with the file system.",
+    parameters: z.object({
+        command: z.string().describe("The shell command to execute"),
+        workdir: z.string().optional().describe("Working directory for the command"),
+        timeout: z.number().int().positive().optional().describe("Timeout in milliseconds"),
+        env: z.record(z.string()).optional().describe("Additional environment variables"),
+    }),
+    sandbox: {
+        enabled: true,
+        config: {
+            filesystem: {
+                denyRead: ["/etc/shadow", "/etc/sudoers", "/etc/sudoers.d/*"],
+                denyWrite: ["/etc", "/usr/bin", "/usr/sbin", "/bin", "/sbin"],
+            },
+        },
+    },
+    permission: {
+        requireConfirmation: true,
+        level: "dangerous",
+    },
+    metadata: {
+        category: "system",
+        tags: ["shell", "command", "terminal", "exec"],
+        version: "1.2.0",
+    },
+    execute: async (args, ctx) => {
+        const startTime = Date.now();
+        const { command, workdir, timeout = 60000, env } = args;
+        // 获取当前 span 上下文
+        const currentSpanCtx = getCurrentSpanContext();
+        const traceId = currentSpanCtx?.traceId || getCurrentTraceId();
+        // 构建执行选项
+        const options = {
+            timeout,
+        };
+        if (workdir || ctx.workdir) {
+            options.cwd = workdir || ctx.workdir;
+        }
+        // 构建子进程的环境变量
+        const childEnv = {};
+        for (const [key, value] of Object.entries(process.env)) {
+            if (value !== undefined) {
+                childEnv[key] = value;
+            }
+        }
+        // 使用 W3C TraceContext 注入 TRACEPARENT
+        if (currentSpanCtx) {
+            const carrier = {};
+            propagation.inject(carrier, currentSpanCtx);
+            if (carrier['TRACEPARENT']) {
+                childEnv['TRACEPARENT'] = carrier['TRACEPARENT'];
+            }
+            // 保留向后兼容的环境变量
+            childEnv['TRACE_ID'] = currentSpanCtx.traceId;
+            childEnv['PARENT_SPAN_ID'] = currentSpanCtx.spanId;
+        }
+        else if (traceId) {
+            // 如果没有当前上下文但有 traceId，创建根 span 的 traceparent
+            const spanId = Math.floor(Math.random() * 0xFFFFFFFFFFFFFFFF)
+                .toString(16)
+                .padStart(16, "0");
+            childEnv['TRACEPARENT'] = `00-${traceId}-${spanId}-01`;
+            childEnv['TRACE_ID'] = traceId;
+        }
+        // 用户提供的 env 优先级最高
+        if (env) {
+            Object.assign(childEnv, env);
+        }
+        options.env = childEnv;
+        // 使用 OTel tracer 创建 span
+        let otelSpan = undefined;
+        try {
+            const { getTracerProvider } = require("../../log-trace/opentelemetry/tracer-provider");
+            const provider = getTracerProvider();
+            const tracer = provider.getTracer('roy-tracer');
+            otelSpan = tracer.startSpan(`bash: ${command.slice(0, 50)}${command.length > 50 ? "..." : ""}`, {
+                attributes: {
+                    'bash.command': command.slice(0, 200),
+                    'bash.workdir': workdir || ctx.workdir || '',
+                    'bash.timeout': timeout,
+                },
+            });
+        }
+        catch {
+            // OTel tracer 不可用，继续执行
+        }
+        const spanId = otelSpan?.spanContext?.spanId;
+        try {
+            const { stdout, stderr } = await execAsync(command, options);
+            // 结束 span
+            if (otelSpan) {
+                otelSpan.end({ stdout, stderr });
+            }
+            return {
+                success: true,
+                output: stdout || "(no output)",
+                metadata: {
+                    execution_time_ms: Date.now() - startTime,
+                    stdout,
+                    stderr,
+                    exit_code: 0,
+                    trace_id: traceId,
+                    parent_span_id: currentSpanCtx?.spanId,
+                    span_id: spanId,
+                },
+            };
+        }
+        catch (error) {
+            const exitCode = error.code || 1;
+            const stdout = error.stdout || "";
+            const stderr = error.stderr || error.message;
+            // 结束 span（带错误）
+            const execError = new Error(stderr);
+            execError.name = "BashExecutionError";
+            if (otelSpan) {
+                otelSpan.end(undefined, execError);
+            }
+            return {
+                success: exitCode === 0,
+                output: stdout || "(no output)",
+                error: stderr,
+                metadata: {
+                    execution_time_ms: Date.now() - startTime,
+                    stdout,
+                    stderr,
+                    exit_code: exitCode,
+                    trace_id: traceId,
+                    parent_span_id: currentSpanCtx?.spanId,
+                    span_id: spanId,
+                },
+            };
+        }
+    },
+};
+//# sourceMappingURL=bash.js.map

package/dist/core/src/env/tool/built-in/echo.d.ts

@@ -0,0 +1,8 @@
+import type { Tool } from "../types";
+/**
+ * Echo tool - simple echo command
+ *
+ * This is a convenience tool for logging messages in workflows.
+ */
+export declare const echoTool: Tool;
+//# sourceMappingURL=echo.d.ts.map