profclaw 0.0.1-beta.1

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

@@ -0,0 +1,184 @@
+/**
+ * GitHub PR Tool
+ *
+ * GitHub Pull Request operations using the gh CLI.
+ */
+import { z } from 'zod';
+import { spawn } from 'child_process';
+import { logger } from '../../../utils/logger.js';
+// Schema
+const GithubPrParamsSchema = z.object({
+    action: z.enum(['create', 'get', 'list', 'comment', 'merge', 'diff']).describe('PR action to perform'),
+    repo: z.string().optional().describe('owner/repo (auto-detected from git remote if omitted)'),
+    pr_number: z.number().optional().describe('PR number (required for get, comment, merge, diff)'),
+    title: z.string().optional().describe('PR title (required for create)'),
+    body: z.string().optional().describe('PR body or comment text'),
+    base: z.string().optional().default('main').describe('Base branch for create'),
+    head: z.string().optional().describe('Head branch for create (defaults to current branch)'),
+});
+// Constants
+const MAX_OUTPUT_CHARS = 100_000;
+const GH_TIMEOUT_MS = 30_000;
+// Tool Definition
+export const githubPrTool = {
+    name: 'github_pr',
+    description: `GitHub Pull Request operations. Create, list, get, comment on, merge, and diff PRs.
+Requires the gh CLI to be installed and authenticated.
+Repo is auto-detected from git remote if not specified.`,
+    category: 'execution',
+    securityLevel: 'moderate',
+    requiresApproval: true,
+    allowedHosts: ['sandbox', 'gateway', 'local'],
+    parameters: GithubPrParamsSchema,
+    examples: [
+        { description: 'List open PRs', params: { action: 'list' } },
+        { description: 'Get PR details', params: { action: 'get', pr_number: 42 } },
+        { description: 'Create a PR', params: { action: 'create', title: 'Add feature X', body: 'Description here' } },
+    ],
+    isAvailable() {
+        return { available: true, reason: 'gh CLI required' };
+    },
+    async execute(context, params) {
+        try {
+            const args = buildGhArgs(params);
+            const output = await runGh(args, context.workdir);
+            logger.debug(`[GitHub] ${params.action} completed`, { component: 'GitHub' });
+            return {
+                success: true,
+                data: {
+                    action: params.action,
+                    output,
+                    pr_number: params.pr_number,
+                },
+                output,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            if (message.includes('is required for') || message.startsWith('Unknown action:')) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'INVALID_PARAMS',
+                        message,
+                    },
+                };
+            }
+            if (message.includes('not found') || message.includes('not installed')) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'GH_NOT_FOUND',
+                        message: 'GitHub CLI (gh) is not installed or not in PATH. Install it from https://cli.github.com',
+                    },
+                };
+            }
+            if (message.includes('not logged in') || message.includes('auth')) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'GH_AUTH_REQUIRED',
+                        message: 'GitHub CLI requires authentication. Run: gh auth login',
+                    },
+                };
+            }
+            return {
+                success: false,
+                error: {
+                    code: 'GH_ERROR',
+                    message: `GitHub operation failed: ${message}`,
+                },
+            };
+        }
+    },
+};
+// Helpers
+function buildGhArgs(params) {
+    const args = ['pr'];
+    const repoArgs = params.repo ? ['-R', params.repo] : [];
+    switch (params.action) {
+        case 'list':
+            args.push('list', '--json', 'number,title,state,author,updatedAt,headRefName', ...repoArgs);
+            break;
+        case 'get':
+            if (!params.pr_number)
+                throw new Error('pr_number is required for get action');
+            args.push('view', String(params.pr_number), ...repoArgs);
+            break;
+        case 'create':
+            if (!params.title)
+                throw new Error('title is required for create action');
+            args.push('create', '--title', params.title);
+            if (params.body)
+                args.push('--body', params.body);
+            if (params.base)
+                args.push('--base', params.base);
+            if (params.head)
+                args.push('--head', params.head);
+            args.push(...repoArgs);
+            break;
+        case 'comment':
+            if (!params.pr_number)
+                throw new Error('pr_number is required for comment action');
+            if (!params.body)
+                throw new Error('body is required for comment action');
+            args.push('comment', String(params.pr_number), '--body', params.body, ...repoArgs);
+            break;
+        case 'merge':
+            if (!params.pr_number)
+                throw new Error('pr_number is required for merge action');
+            args.push('merge', String(params.pr_number), '--merge', ...repoArgs);
+            break;
+        case 'diff':
+            if (!params.pr_number)
+                throw new Error('pr_number is required for diff action');
+            args.push('diff', String(params.pr_number), ...repoArgs);
+            break;
+        default:
+            throw new Error(`Unknown action: ${params.action}`);
+    }
+    return args;
+}
+function runGh(args, cwd) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn('gh', args, {
+            cwd,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env },
+        });
+        let stdout = '';
+        let stderr = '';
+        const timeout = setTimeout(() => {
+            proc.kill('SIGKILL');
+            reject(new Error('GitHub CLI timed out'));
+        }, GH_TIMEOUT_MS);
+        proc.stdout?.on('data', (data) => {
+            stdout += data.toString();
+            if (stdout.length > MAX_OUTPUT_CHARS) {
+                stdout = stdout.slice(0, MAX_OUTPUT_CHARS) + '\n...(truncated)';
+            }
+        });
+        proc.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            clearTimeout(timeout);
+            if (code === 0) {
+                resolve(stdout.trim() || '(no output)');
+            }
+            else {
+                reject(new Error(stderr.trim() || `gh exited with code ${code}`));
+            }
+        });
+        proc.on('error', (err) => {
+            clearTimeout(timeout);
+            if (err.code === 'ENOENT') {
+                reject(new Error('gh CLI not found. Install from https://cli.github.com'));
+            }
+            else {
+                reject(err);
+            }
+        });
+    });
+}
+//# sourceMappingURL=github.js.map

package/dist/chat/execution/tools/glinr-ops.d.ts

@@ -0,0 +1,202 @@
+/**
+ * GLINR Operations Tools
+ *
+ * Ticket, project, and sprint management through AI chat.
+ * These tools allow the AI to create and manage GLINR's own data.
+ */
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+declare const CreateTicketParamsSchema: z.ZodObject<{
+    projectKey: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodDefault<z.ZodEnum<["task", "bug", "story", "epic", "subtask", "feature", "improvement"]>>;
+    priority: z.ZodDefault<z.ZodEnum<["critical", "high", "medium", "low", "none"]>>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    storyPoints: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    priority: "critical" | "medium" | "high" | "low" | "none";
+    type: "feature" | "bug" | "task" | "epic" | "story" | "subtask" | "improvement";
+    projectKey: string;
+    description?: string | undefined;
+    labels?: string[] | undefined;
+    storyPoints?: number | undefined;
+}, {
+    title: string;
+    projectKey: string;
+    description?: string | undefined;
+    priority?: "critical" | "medium" | "high" | "low" | "none" | undefined;
+    type?: "feature" | "bug" | "task" | "epic" | "story" | "subtask" | "improvement" | undefined;
+    labels?: string[] | undefined;
+    storyPoints?: number | undefined;
+}>;
+declare const CreateProjectParamsSchema: z.ZodObject<{
+    name: z.ZodString;
+    key: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    key: string;
+    description?: string | undefined;
+    icon?: string | undefined;
+    color?: string | undefined;
+}, {
+    name: string;
+    key: string;
+    description?: string | undefined;
+    icon?: string | undefined;
+    color?: string | undefined;
+}>;
+declare const ListTicketsParamsSchema: z.ZodObject<{
+    projectKey: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    priority?: string | undefined;
+    type?: string | undefined;
+    status?: string | undefined;
+    search?: string | undefined;
+    projectKey?: string | undefined;
+}, {
+    priority?: string | undefined;
+    type?: string | undefined;
+    status?: string | undefined;
+    search?: string | undefined;
+    limit?: number | undefined;
+    projectKey?: string | undefined;
+}>;
+declare const ListProjectsParamsSchema: z.ZodObject<{
+    status: z.ZodDefault<z.ZodEnum<["active", "archived", "all"]>>;
+}, "strip", z.ZodTypeAny, {
+    status: "active" | "archived" | "all";
+}, {
+    status?: "active" | "archived" | "all" | undefined;
+}>;
+declare const UpdateTicketParamsSchema: z.ZodObject<{
+    ticketKey: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["backlog", "todo", "in_progress", "in_review", "done", "cancelled"]>>;
+    priority: z.ZodOptional<z.ZodEnum<["critical", "high", "medium", "low", "none"]>>;
+    type: z.ZodOptional<z.ZodEnum<["task", "bug", "story", "epic", "subtask", "feature", "improvement"]>>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    storyPoints: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    ticketKey: string;
+    title?: string | undefined;
+    description?: string | undefined;
+    priority?: "critical" | "medium" | "high" | "low" | "none" | undefined;
+    type?: "feature" | "bug" | "task" | "epic" | "story" | "subtask" | "improvement" | undefined;
+    status?: "in_progress" | "cancelled" | "backlog" | "todo" | "in_review" | "done" | undefined;
+    labels?: string[] | undefined;
+    storyPoints?: number | undefined;
+}, {
+    ticketKey: string;
+    title?: string | undefined;
+    description?: string | undefined;
+    priority?: "critical" | "medium" | "high" | "low" | "none" | undefined;
+    type?: "feature" | "bug" | "task" | "epic" | "story" | "subtask" | "improvement" | undefined;
+    status?: "in_progress" | "cancelled" | "backlog" | "todo" | "in_review" | "done" | undefined;
+    labels?: string[] | undefined;
+    storyPoints?: number | undefined;
+}>;
+declare const GetTicketParamsSchema: z.ZodObject<{
+    ticketKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    ticketKey: string;
+}, {
+    ticketKey: string;
+}>;
+export type CreateTicketParams = z.infer<typeof CreateTicketParamsSchema>;
+export type CreateProjectParams = z.infer<typeof CreateProjectParamsSchema>;
+export type ListTicketsParams = z.infer<typeof ListTicketsParamsSchema>;
+export type ListProjectsParams = z.infer<typeof ListProjectsParamsSchema>;
+export type UpdateTicketParams = z.infer<typeof UpdateTicketParamsSchema>;
+export type GetTicketParams = z.infer<typeof GetTicketParamsSchema>;
+interface TicketResult {
+    id: string;
+    key: string;
+    title: string;
+    description?: string;
+    status: string;
+    type: string;
+    priority: string;
+    labels?: string[];
+    storyPoints?: number;
+    projectKey: string;
+    createdAt: string;
+    /** URL to view this ticket in the UI */
+    url: string;
+}
+interface ProjectResult {
+    id: string;
+    name: string;
+    key: string;
+    description?: string;
+    icon?: string;
+    color?: string;
+    status: string;
+    ticketCount?: number;
+}
+export declare const createTicketTool: ToolDefinition<CreateTicketParams, TicketResult>;
+export declare const createProjectTool: ToolDefinition<CreateProjectParams, ProjectResult>;
+export declare const listTicketsTool: ToolDefinition<ListTicketsParams, {
+    tickets: TicketResult[];
+    total: number;
+}>;
+export declare const listProjectsTool: ToolDefinition<ListProjectsParams, {
+    projects: ProjectResult[];
+    hint?: string;
+}>;
+export declare const updateTicketTool: ToolDefinition<UpdateTicketParams, TicketResult>;
+export declare const getTicketTool: ToolDefinition<GetTicketParams, TicketResult>;
+export declare const glinrTools: (ToolDefinition<{
+    title: string;
+    priority: "critical" | "medium" | "high" | "low" | "none";
+    type: "feature" | "bug" | "task" | "epic" | "story" | "subtask" | "improvement";
+    projectKey: string;
+    description?: string | undefined;
+    labels?: string[] | undefined;
+    storyPoints?: number | undefined;
+}, TicketResult> | ToolDefinition<{
+    name: string;
+    key: string;
+    description?: string | undefined;
+    icon?: string | undefined;
+    color?: string | undefined;
+}, ProjectResult> | ToolDefinition<{
+    limit: number;
+    priority?: string | undefined;
+    type?: string | undefined;
+    status?: string | undefined;
+    search?: string | undefined;
+    projectKey?: string | undefined;
+}, {
+    tickets: TicketResult[];
+    total: number;
+}> | ToolDefinition<{
+    status: "active" | "archived" | "all";
+}, {
+    projects: ProjectResult[];
+    hint?: string;
+}> | ToolDefinition<{
+    ticketKey: string;
+    title?: string | undefined;
+    description?: string | undefined;
+    priority?: "critical" | "medium" | "high" | "low" | "none" | undefined;
+    type?: "feature" | "bug" | "task" | "epic" | "story" | "subtask" | "improvement" | undefined;
+    status?: "in_progress" | "cancelled" | "backlog" | "todo" | "in_review" | "done" | undefined;
+    labels?: string[] | undefined;
+    storyPoints?: number | undefined;
+}, TicketResult> | ToolDefinition<{
+    ticketKey: string;
+}, TicketResult>)[];
+export {};
+//# sourceMappingURL=glinr-ops.d.ts.map