profclaw 0.0.1-beta.1

package/dist/chat/execution/tools/canvas.js

@@ -0,0 +1,150 @@
+/**
+ * Canvas Render Tool
+ *
+ * Lets the AI agent render visual artifacts (code blocks, charts, diagrams,
+ * tables, HTML, markdown, mermaid diagrams, SVG) that appear in the dashboard
+ * Live Canvas panel.
+ */
+import { z } from 'zod';
+import { logger } from '../../../utils/logger.js';
+// In-memory artifact store
+const artifactStore = new Map();
+/**
+ * Retrieve a stored artifact by ID.
+ */
+export function getArtifact(id) {
+    return artifactStore.get(id);
+}
+/**
+ * List stored artifacts, optionally filtered by conversation.
+ */
+export function listArtifacts(conversationId) {
+    const all = Array.from(artifactStore.values());
+    if (conversationId === undefined)
+        return all;
+    return all.filter((a) => a.conversationId === conversationId);
+}
+/**
+ * Clear stored artifacts. Returns the count of removed entries.
+ */
+export function clearArtifacts(conversationId) {
+    if (conversationId === undefined) {
+        const count = artifactStore.size;
+        artifactStore.clear();
+        return count;
+    }
+    let removed = 0;
+    for (const [id, artifact] of artifactStore) {
+        if (artifact.conversationId === conversationId) {
+            artifactStore.delete(id);
+            removed++;
+        }
+    }
+    return removed;
+}
+// Schema
+const CanvasRenderParamsSchema = z.object({
+    type: z
+        .enum(['code', 'chart', 'diagram', 'table', 'html', 'markdown', 'mermaid', 'svg'])
+        .describe('Artifact type to render'),
+    content: z.string().min(1).describe('Content to render'),
+    title: z.string().optional().describe('Title for the artifact'),
+    language: z
+        .string()
+        .optional()
+        .describe('Language for code blocks (e.g., typescript, python)'),
+    metadata: z
+        .record(z.unknown())
+        .optional()
+        .describe('Additional metadata for rendering'),
+});
+// Tool Definition
+export const canvasRenderTool = {
+    name: 'canvas_render',
+    description: `Render a visual artifact to the Live Canvas panel in the dashboard.
+Supports code blocks (with syntax highlighting), charts, diagrams, tables,
+HTML snippets, markdown documents, Mermaid diagrams, and raw SVG.
+
+The artifact is stored and a reference ID is returned so the UI can display it.
+Use this whenever a visual representation would communicate results more clearly
+than plain text.`,
+    category: 'system',
+    securityLevel: 'safe',
+    requiresApproval: false,
+    allowedHosts: ['sandbox', 'gateway', 'local'],
+    parameters: CanvasRenderParamsSchema,
+    examples: [
+        {
+            description: 'Render a TypeScript code block',
+            params: {
+                type: 'code',
+                title: 'hello.ts',
+                language: 'typescript',
+                content: 'const greet = (name: string) => `Hello, ${name}!`;',
+            },
+        },
+        {
+            description: 'Render a Mermaid flowchart',
+            params: {
+                type: 'mermaid',
+                title: 'Request flow',
+                content: 'flowchart LR\n  A[Client] --> B[API] --> C[DB]',
+            },
+        },
+        {
+            description: 'Render an HTML snippet',
+            params: {
+                type: 'html',
+                title: 'Status badge',
+                content: '<span style="color:green">Online</span>',
+            },
+        },
+    ],
+    async execute(context, params) {
+        const start = Date.now();
+        try {
+            const id = crypto.randomUUID();
+            const artifact = {
+                id,
+                type: params.type,
+                content: params.content,
+                title: params.title,
+                language: params.language,
+                metadata: params.metadata,
+                conversationId: context.conversationId,
+                createdAt: Date.now(),
+            };
+            artifactStore.set(id, artifact);
+            const preview = params.content.slice(0, 200);
+            logger.debug(`[canvas] stored artifact id=${id} type=${params.type} conversation=${context.conversationId}`);
+            const result = {
+                artifactId: id,
+                type: params.type,
+                title: params.title,
+                preview,
+            };
+            const label = params.title ? `"${params.title}"` : params.type;
+            const output = `Canvas artifact rendered: ${label} (id: ${id})`;
+            return {
+                success: true,
+                data: result,
+                output,
+                durationMs: Date.now() - start,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error(`[canvas] failed to store artifact:`, error instanceof Error ? error : undefined);
+            return {
+                success: false,
+                error: {
+                    code: 'CANVAS_RENDER_ERROR',
+                    message: `Failed to render canvas artifact: ${message}`,
+                    retryable: false,
+                },
+                durationMs: Date.now() - start,
+            };
+        }
+    },
+};
+//# sourceMappingURL=canvas.js.map

package/dist/chat/execution/tools/complete-task.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Complete Task Tool
+ *
+ * Allows the AI agent to signal that a task has been completed.
+ * This is the primary mechanism for the agentic loop to know when to stop.
+ */
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+declare const CompleteTaskParamsSchema: z.ZodObject<{
+    summary: z.ZodString;
+    artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["ticket", "commit", "file", "pr", "project", "comment", "other"]>;
+        id: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "commit" | "file" | "comment" | "other" | "ticket" | "pr" | "project";
+        id: string;
+        description?: string | undefined;
+        url?: string | undefined;
+    }, {
+        type: "commit" | "file" | "comment" | "other" | "ticket" | "pr" | "project";
+        id: string;
+        description?: string | undefined;
+        url?: string | undefined;
+    }>, "many">>;
+    nextSteps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    confidence: z.ZodDefault<z.ZodEnum<["high", "medium", "low"]>>;
+}, "strip", z.ZodTypeAny, {
+    confidence: "medium" | "high" | "low";
+    summary: string;
+    artifacts?: {
+        type: "commit" | "file" | "comment" | "other" | "ticket" | "pr" | "project";
+        id: string;
+        description?: string | undefined;
+        url?: string | undefined;
+    }[] | undefined;
+    nextSteps?: string[] | undefined;
+}, {
+    summary: string;
+    confidence?: "medium" | "high" | "low" | undefined;
+    artifacts?: {
+        type: "commit" | "file" | "comment" | "other" | "ticket" | "pr" | "project";
+        id: string;
+        description?: string | undefined;
+        url?: string | undefined;
+    }[] | undefined;
+    nextSteps?: string[] | undefined;
+}>;
+export type CompleteTaskParams = z.infer<typeof CompleteTaskParamsSchema>;
+interface CompleteTaskResult {
+    /** Signals the agentic loop that the task is complete */
+    complete: true;
+    /** Summary of what was accomplished */
+    summary: string;
+    /** Artifacts created during execution */
+    artifacts: Array<{
+        type: string;
+        id: string;
+        description?: string;
+        url?: string;
+    }>;
+    /** Suggested next steps */
+    nextSteps: string[];
+    /** Confidence level */
+    confidence: 'high' | 'medium' | 'low';
+    /** Timestamp of completion */
+    completedAt: string;
+}
+export declare const completeTaskTool: ToolDefinition<CompleteTaskParams, CompleteTaskResult>;
+export default completeTaskTool;
+//# sourceMappingURL=complete-task.d.ts.map

package/dist/chat/execution/tools/complete-task.js

@@ -0,0 +1,104 @@
+/**
+ * Complete Task Tool
+ *
+ * Allows the AI agent to signal that a task has been completed.
+ * This is the primary mechanism for the agentic loop to know when to stop.
+ */
+import { z } from 'zod';
+import { logger } from '../../../utils/logger.js';
+// Schema
+const ArtifactSchema = z.object({
+    type: z.enum(['ticket', 'commit', 'file', 'pr', 'project', 'comment', 'other']).describe('Type of artifact'),
+    id: z.string().describe('Identifier for the artifact'),
+    description: z.string().optional().describe('Brief description of the artifact'),
+    url: z.string().optional().describe('URL to the artifact if applicable'),
+});
+const CompleteTaskParamsSchema = z.object({
+    summary: z.string().min(1).describe('Summary of what was accomplished'),
+    artifacts: z.array(ArtifactSchema).optional().describe('Artifacts created during the task'),
+    nextSteps: z.array(z.string()).optional().describe('Suggested follow-up actions for the user'),
+    confidence: z
+        .enum(['high', 'medium', 'low'])
+        .default('high')
+        .describe('Confidence level that the task was fully completed'),
+});
+// Tool Definition
+export const completeTaskTool = {
+    name: 'complete_task',
+    description: `Signal that the current task has been FULLY completed.
+
+**WHEN TO CALL THIS TOOL:**
+- You have completed ALL requested actions
+- The user's goal has been achieved
+- You have a clear summary of what was done
+
+**WHEN NOT TO CALL THIS TOOL:**
+- You are still in the middle of completing steps
+- You need to call more tools to finish the task
+- The task failed and you need to retry
+
+**EXAMPLE WORKFLOW:**
+1. User: "Create a bug ticket for login issue"
+2. You: Call list_projects → get project key "PC"
+3. You: Call create_ticket → ticket "PC-42" created
+4. You: Call complete_task → summary: "Created bug ticket PC-42 for login issue"
+
+**IMPORTANT:** Always include:
+- A clear summary of what was done
+- Any artifacts that were created (tickets, files, etc.)
+- Suggested next steps if applicable`,
+    category: 'profclaw',
+    securityLevel: 'safe',
+    allowedHosts: ['sandbox', 'gateway', 'local'],
+    parameters: CompleteTaskParamsSchema,
+    examples: [
+        {
+            description: 'Complete after creating a ticket',
+            params: {
+                summary: 'Created bug ticket PC-42 for the login button issue',
+                artifacts: [
+                    {
+                        type: 'ticket',
+                        id: 'PC-42',
+                        description: 'Fix login button not responding',
+                    },
+                ],
+                nextSteps: ['Assign the ticket to a developer', 'Add more details to the description'],
+                confidence: 'high',
+            },
+        },
+        {
+            description: 'Complete after a search task',
+            params: {
+                summary: 'Found 3 open bugs related to authentication in the profClaw project',
+                artifacts: [
+                    { type: 'ticket', id: 'PC-10', description: 'Session timeout bug' },
+                    { type: 'ticket', id: 'PC-15', description: 'OAuth redirect issue' },
+                    { type: 'ticket', id: 'PC-22', description: 'Password reset not working' },
+                ],
+                confidence: 'high',
+            },
+        },
+    ],
+    async execute(_context, params) {
+        logger.info('[Agent] Task marked as complete:', {
+            summary: params.summary,
+            artifactCount: params.artifacts?.length ?? 0,
+            confidence: params.confidence ?? 'high',
+        });
+        return {
+            success: true,
+            data: {
+                complete: true,
+                summary: params.summary,
+                artifacts: params.artifacts ?? [],
+                nextSteps: params.nextSteps ?? [],
+                confidence: params.confidence ?? 'high',
+                completedAt: new Date().toISOString(),
+            },
+        };
+    },
+};
+// Export
+export default completeTaskTool;
+//# sourceMappingURL=complete-task.js.map

package/dist/chat/execution/tools/cron-tool.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Cron Tool
+ *
+ * AI agent tool for managing scheduled jobs.
+ * Allows agents to create, list, update, pause, and trigger cron jobs.
+ *
+ * Inspired by OpenClaw's cron command patterns.
+ */
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+import { type ScheduledJob } from '../../../cron/scheduler.js';
+declare const CronCreateParamsSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    cron: z.ZodOptional<z.ZodString>;
+    interval: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodDefault<z.ZodEnum<["http", "tool", "script"]>>;
+    url: z.ZodOptional<z.ZodString>;
+    method: z.ZodOptional<z.ZodEnum<["GET", "POST", "PUT", "DELETE"]>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    body: z.ZodOptional<z.ZodUnknown>;
+    tool: z.ZodOptional<z.ZodString>;
+    toolParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    workdir: z.ZodOptional<z.ZodString>;
+    maxRuns: z.ZodOptional<z.ZodNumber>;
+    maxFailures: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "tool" | "script" | "http";
+    description?: string | undefined;
+    url?: string | undefined;
+    maxRuns?: number | undefined;
+    maxFailures?: number | undefined;
+    args?: string[] | undefined;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | undefined;
+    cron?: string | undefined;
+    body?: unknown;
+    command?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    tool?: string | undefined;
+    workdir?: string | undefined;
+    interval?: number | undefined;
+    toolParams?: Record<string, unknown> | undefined;
+}, {
+    name: string;
+    description?: string | undefined;
+    type?: "tool" | "script" | "http" | undefined;
+    url?: string | undefined;
+    maxRuns?: number | undefined;
+    maxFailures?: number | undefined;
+    args?: string[] | undefined;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | undefined;
+    cron?: string | undefined;
+    body?: unknown;
+    command?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    tool?: string | undefined;
+    workdir?: string | undefined;
+    interval?: number | undefined;
+    toolParams?: Record<string, unknown> | undefined;
+}>;
+export type CronCreateParams = z.infer<typeof CronCreateParamsSchema>;
+export interface CronCreateResult {
+    job: ScheduledJob;
+    message: string;
+}
+export declare const cronCreateTool: ToolDefinition<CronCreateParams, CronCreateResult>;
+declare const CronListParamsSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<["active", "paused", "completed", "failed", "archived"]>>;
+    type: z.ZodOptional<z.ZodEnum<["http", "tool", "script", "message"]>>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    type?: "message" | "tool" | "script" | "http" | undefined;
+    status?: "completed" | "failed" | "active" | "archived" | "paused" | undefined;
+}, {
+    type?: "message" | "tool" | "script" | "http" | undefined;
+    status?: "completed" | "failed" | "active" | "archived" | "paused" | undefined;
+    limit?: number | undefined;
+}>;
+export type CronListParams = z.infer<typeof CronListParamsSchema>;
+export interface CronListResult {
+    jobs: ScheduledJob[];
+    total: number;
+}
+export declare const cronListTool: ToolDefinition<CronListParams, CronListResult>;
+declare const CronTriggerParamsSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+export type CronTriggerParams = z.infer<typeof CronTriggerParamsSchema>;
+export interface CronTriggerResult {
+    triggered: boolean;
+    runId?: string;
+}
+export declare const cronTriggerTool: ToolDefinition<CronTriggerParams, CronTriggerResult>;
+declare const CronPauseParamsSchema: z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodDefault<z.ZodEnum<["pause", "resume"]>>;
+}, "strip", z.ZodTypeAny, {
+    action: "pause" | "resume";
+    id: string;
+}, {
+    id: string;
+    action?: "pause" | "resume" | undefined;
+}>;
+export type CronPauseParams = z.infer<typeof CronPauseParamsSchema>;
+export interface CronPauseResult {
+    success: boolean;
+    status: string;
+}
+export declare const cronPauseTool: ToolDefinition<CronPauseParams, CronPauseResult>;
+declare const CronDeleteParamsSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+export type CronDeleteParams = z.infer<typeof CronDeleteParamsSchema>;
+export interface CronDeleteResult {
+    deleted: boolean;
+}
+export declare const cronDeleteTool: ToolDefinition<CronDeleteParams, CronDeleteResult>;
+declare const CronArchiveParamsSchema: z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodDefault<z.ZodEnum<["archive", "restore"]>>;
+}, "strip", z.ZodTypeAny, {
+    action: "archive" | "restore";
+    id: string;
+}, {
+    id: string;
+    action?: "archive" | "restore" | undefined;
+}>;
+export type CronArchiveParams = z.infer<typeof CronArchiveParamsSchema>;
+export interface CronArchiveResult {
+    success: boolean;
+    status: string;
+}
+export declare const cronArchiveTool: ToolDefinition<CronArchiveParams, CronArchiveResult>;
+declare const CronHistoryParamsSchema: z.ZodObject<{
+    id: z.ZodString;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    limit: number;
+}, {
+    id: string;
+    limit?: number | undefined;
+}>;
+export type CronHistoryParams = z.infer<typeof CronHistoryParamsSchema>;
+export interface CronHistoryResult {
+    jobName: string;
+    runs: Array<{
+        id: string;
+        startedAt: Date;
+        status: string;
+        durationMs?: number;
+        error?: string;
+    }>;
+}
+export declare const cronHistoryTool: ToolDefinition<CronHistoryParams, CronHistoryResult>;
+export declare const cronTools: (ToolDefinition<{
+    name: string;
+    type: "tool" | "script" | "http";
+    description?: string | undefined;
+    url?: string | undefined;
+    maxRuns?: number | undefined;
+    maxFailures?: number | undefined;
+    args?: string[] | undefined;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | undefined;
+    cron?: string | undefined;
+    body?: unknown;
+    command?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    tool?: string | undefined;
+    workdir?: string | undefined;
+    interval?: number | undefined;
+    toolParams?: Record<string, unknown> | undefined;
+}, CronCreateResult> | ToolDefinition<{
+    limit: number;
+    type?: "message" | "tool" | "script" | "http" | undefined;
+    status?: "completed" | "failed" | "active" | "archived" | "paused" | undefined;
+}, CronListResult> | ToolDefinition<{
+    id: string;
+}, CronTriggerResult> | ToolDefinition<{
+    action: "pause" | "resume";
+    id: string;
+}, CronPauseResult> | ToolDefinition<{
+    id: string;
+}, CronDeleteResult> | ToolDefinition<{
+    action: "archive" | "restore";
+    id: string;
+}, CronArchiveResult> | ToolDefinition<{
+    id: string;
+    limit: number;
+}, CronHistoryResult>)[];
+export {};
+//# sourceMappingURL=cron-tool.d.ts.map