@compilr-dev/sdk 0.1.7 → 0.1.9

package/dist/platform/tools/project-tools.js

@@ -0,0 +1,367 @@
+/**
+ * Project Tools — CRUD operations for projects.
+ *
+ * 4 tools: project_get, project_create, project_update, project_list
+ *
+ * Ported from CLI's src/tools/project-db.ts. Key adaptations:
+ * - getActiveProject()?.id → ctx.currentProjectId
+ * - setCurrentProject() → ctx.currentProjectId = id + hooks?.onProjectResolved()
+ * - awardFirstProject() → hooks?.onFirstProject()
+ * - process.cwd() → config.cwd ?? process.cwd()
+ * - All repo calls are properly await-ed
+ */
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export function createProjectTools(config) {
+    const { context: ctx, hooks } = config;
+    // ---------------------------------------------------------------------------
+    // project_get
+    // ---------------------------------------------------------------------------
+    const projectGetTool = defineTool({
+        name: 'project_get',
+        description: 'Get the active project for the current directory, or get a project by ID/name. ' +
+            'Returns project details including metadata, workflow state, and last context.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: {
+                    type: 'number',
+                    description: 'Project ID to look up (optional - uses active project or cwd detection if not provided)',
+                },
+                name: {
+                    type: 'string',
+                    description: 'Project name to look up (optional)',
+                },
+                path: {
+                    type: 'string',
+                    description: 'Path to check for project (optional - defaults to cwd)',
+                },
+            },
+            required: [],
+        },
+        execute: async (input) => {
+            try {
+                let project = null;
+                // Priority: ID > name > active > path detection
+                if (input.project_id) {
+                    project = await ctx.projects.getById(input.project_id);
+                }
+                else if (input.name) {
+                    project = await ctx.projects.getByName(input.name);
+                }
+                else if (ctx.currentProjectId) {
+                    project = await ctx.projects.getById(ctx.currentProjectId);
+                }
+                else if (input.path) {
+                    project = await ctx.projects.findByPath(input.path);
+                }
+                else {
+                    const cwd = config.cwd ?? process.cwd();
+                    project = await ctx.projects.findByPath(cwd);
+                }
+                if (!project) {
+                    return createSuccessResult({
+                        success: true,
+                        project: null,
+                        message: 'No project found. Use project_create to create a new project, or /projects to select one.',
+                    });
+                }
+                // Update current project
+                ctx.currentProjectId = project.id;
+                hooks?.onProjectResolved?.({
+                    id: project.id,
+                    name: project.name,
+                    displayName: project.displayName,
+                    path: project.path,
+                });
+                return createSuccessResult({
+                    success: true,
+                    project: {
+                        id: project.id,
+                        name: project.name,
+                        displayName: project.displayName,
+                        description: project.description,
+                        type: project.type,
+                        status: project.status,
+                        path: project.path,
+                        docsPath: project.docsPath,
+                        repoPattern: project.repoPattern,
+                        language: project.language,
+                        framework: project.framework,
+                        packageManager: project.packageManager,
+                        runtimeVersion: project.runtimeVersion,
+                        commands: project.commands,
+                        gitRemote: project.gitRemote,
+                        gitBranch: project.gitBranch,
+                        workflowMode: project.workflowMode,
+                        lifecycleState: project.lifecycleState,
+                        currentItemId: project.currentItemId,
+                        lastContext: project.lastContext,
+                        createdAt: project.createdAt.toISOString(),
+                        updatedAt: project.updatedAt.toISOString(),
+                        lastActivityAt: project.lastActivityAt?.toISOString(),
+                    },
+                });
+            }
+            catch (error) {
+                return createErrorResult(`Failed to get project: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+    });
+    // ---------------------------------------------------------------------------
+    // project_create
+    // ---------------------------------------------------------------------------
+    const projectCreateTool = defineTool({
+        name: 'project_create',
+        description: 'Create a new tracked project. This promotes a directory to a tracked project with workflow support.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Filesystem-safe project name (e.g., "my-api-project")',
+                },
+                display_name: {
+                    type: 'string',
+                    description: 'Human-friendly display name (e.g., "My API Project")',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Project description',
+                },
+                path: {
+                    type: 'string',
+                    description: 'Project path (defaults to cwd)',
+                },
+                type: {
+                    type: 'string',
+                    enum: ['general', 'web', 'cli', 'library', 'api'],
+                    description: 'Project type',
+                },
+                workflow_mode: {
+                    type: 'string',
+                    enum: ['flexible', 'guided'],
+                    description: 'Workflow mode: flexible (default) or guided',
+                },
+                language: {
+                    type: 'string',
+                    description: 'Programming language (e.g., "typescript", "python")',
+                },
+                framework: {
+                    type: 'string',
+                    description: 'Framework (e.g., "react", "express")',
+                },
+                package_manager: {
+                    type: 'string',
+                    description: 'Package manager (e.g., "npm", "yarn", "pnpm")',
+                },
+            },
+            required: ['name', 'display_name'],
+        },
+        execute: async (input) => {
+            try {
+                // Check if project with this name already exists
+                const existing = await ctx.projects.getByName(input.name);
+                if (existing) {
+                    return createErrorResult(`Project with name "${input.name}" already exists`);
+                }
+                // Check if a project exists at this path
+                const projectPath = input.path ?? config.cwd ?? process.cwd();
+                const existingByPath = await ctx.projects.findByPath(projectPath);
+                if (existingByPath) {
+                    return createErrorResult(`A project already exists at path "${projectPath}": ${existingByPath.name}`);
+                }
+                const createInput = {
+                    name: input.name,
+                    display_name: input.display_name,
+                    description: input.description,
+                    path: projectPath,
+                    type: input.type ? input.type : 'general',
+                    workflow_mode: input.workflow_mode ? input.workflow_mode : 'flexible',
+                    language: input.language,
+                    framework: input.framework,
+                    package_manager: input.package_manager,
+                };
+                const project = await ctx.projects.create(createInput);
+                // Award coin for first project
+                const listResult = await ctx.projects.list();
+                if (listResult.total === 1) {
+                    hooks?.onFirstProject?.({ id: project.id, name: project.name });
+                }
+                // Set as current project
+                ctx.currentProjectId = project.id;
+                hooks?.onProjectResolved?.({
+                    id: project.id,
+                    name: project.name,
+                    displayName: project.displayName,
+                    path: project.path,
+                });
+                return createSuccessResult({
+                    success: true,
+                    message: `Project "${project.displayName}" created successfully`,
+                    project: {
+                        id: project.id,
+                        name: project.name,
+                        displayName: project.displayName,
+                        type: project.type,
+                        workflowMode: project.workflowMode,
+                        path: project.path,
+                    },
+                });
+            }
+            catch (error) {
+                return createErrorResult(`Failed to create project: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+    });
+    // ---------------------------------------------------------------------------
+    // project_update
+    // ---------------------------------------------------------------------------
+    const projectUpdateTool = defineTool({
+        name: 'project_update',
+        description: 'Update an existing project. Can update status, description, workflow mode, lifecycle state, and other fields.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: {
+                    type: 'number',
+                    description: 'Project ID to update (uses active project if not provided)',
+                },
+                status: {
+                    type: 'string',
+                    enum: ['active', 'paused', 'completed', 'archived'],
+                    description: 'Project status',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Project description',
+                },
+                workflow_mode: {
+                    type: 'string',
+                    enum: ['flexible', 'guided'],
+                    description: 'Workflow mode',
+                },
+                lifecycle_state: {
+                    type: 'string',
+                    enum: ['setup', 'active', 'maintenance', 'complete'],
+                    description: 'Project lifecycle state',
+                },
+                current_item_id: {
+                    type: 'string',
+                    description: 'Currently focused work item ID (e.g., "REQ-003")',
+                },
+                git_remote: {
+                    type: 'string',
+                    description: 'Git remote URL',
+                },
+                git_branch: {
+                    type: 'string',
+                    description: 'Default git branch',
+                },
+                last_context: {
+                    type: 'object',
+                    description: 'Context for session resumption',
+                },
+            },
+            required: [],
+        },
+        execute: async (input) => {
+            try {
+                const projectId = input.project_id ?? ctx.currentProjectId;
+                if (!projectId) {
+                    return createErrorResult('No project specified and no active project. Use project_get or /projects to select a project.');
+                }
+                const updateInput = {};
+                if (input.status)
+                    updateInput.status = input.status;
+                if (input.description !== undefined)
+                    updateInput.description = input.description;
+                if (input.workflow_mode)
+                    updateInput.workflow_mode = input.workflow_mode;
+                if (input.lifecycle_state)
+                    updateInput.lifecycle_state = input.lifecycle_state;
+                if (input.current_item_id !== undefined)
+                    updateInput.current_item_id = input.current_item_id;
+                if (input.git_remote !== undefined)
+                    updateInput.git_remote = input.git_remote;
+                if (input.git_branch !== undefined)
+                    updateInput.git_branch = input.git_branch;
+                if (input.last_context)
+                    updateInput.last_context = input.last_context;
+                const project = await ctx.projects.update(projectId, updateInput);
+                if (!project) {
+                    return createErrorResult(`Project with ID ${String(projectId)} not found`);
+                }
+                return createSuccessResult({
+                    success: true,
+                    message: `Project "${project.displayName}" updated`,
+                    project: {
+                        id: project.id,
+                        name: project.name,
+                        displayName: project.displayName,
+                        status: project.status,
+                        workflowMode: project.workflowMode,
+                        lifecycleState: project.lifecycleState,
+                        currentItemId: project.currentItemId,
+                        gitRemote: project.gitRemote,
+                        gitBranch: project.gitBranch,
+                    },
+                });
+            }
+            catch (error) {
+                return createErrorResult(`Failed to update project: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+    });
+    // ---------------------------------------------------------------------------
+    // project_list
+    // ---------------------------------------------------------------------------
+    const projectListTool = defineTool({
+        name: 'project_list',
+        description: 'List all tracked projects, optionally filtered by status.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: {
+                    type: 'string',
+                    enum: ['active', 'paused', 'completed', 'archived', 'all'],
+                    description: 'Filter by status (default: all)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of projects to return (default: 20)',
+                },
+            },
+            required: [],
+        },
+        execute: async (input) => {
+            try {
+                const result = await ctx.projects.list({
+                    status: input.status,
+                    limit: input.limit ?? 20,
+                });
+                const projects = result.projects.map((p) => ({
+                    id: p.id,
+                    name: p.name,
+                    displayName: p.displayName,
+                    type: p.type,
+                    status: p.status,
+                    path: p.path,
+                    workflowMode: p.workflowMode,
+                    lifecycleState: p.lifecycleState,
+                    lastActivityAt: p.lastActivityAt?.toISOString(),
+                }));
+                return createSuccessResult({
+                    success: true,
+                    projects,
+                    total: result.total,
+                    currentProjectId: ctx.currentProjectId,
+                });
+            }
+            catch (error) {
+                return createErrorResult(`Failed to list projects: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+    });
+    return [projectGetTool, projectCreateTool, projectUpdateTool, projectListTool];
+}

package/dist/platform/tools/workitem-tools.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Work Item Tools — CRUD + workflow operations for work items.
+ *
+ * 9 tools: workitem_query, workitem_add, workitem_update, workitem_next,
+ *          workitem_delete, workitem_status_counts, workitem_advance_step,
+ *          workitem_claim, workitem_handoff
+ *
+ * Ported from CLI's src/tools/workitem-db.ts. Key adaptations:
+ * - getActiveProject()?.id → ctx.currentProjectId
+ * - getActiveSharedContext() "self" resolution → hooks?.resolveOwner?.('self')
+ * - awardWorkItemCompletion() → hooks?.onWorkItemCompleted?.(item)
+ * - workitem_advance_step imports from ../workflow.js (SDK's module)
+ */
+import type { PlatformToolsConfig } from '../context.js';
+export declare function createWorkItemTools(config: PlatformToolsConfig): (import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+    status?: string;
+    type?: string;
+    priority?: string;
+    owner?: string;
+    search?: string;
+    limit?: number;
+    offset?: number;
+}> | import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+    type: string;
+    title: string;
+    description?: string;
+    priority?: string;
+    estimated_effort?: string;
+    owner?: string;
+}> | import("@compilr-dev/agents").Tool<{
+    item_id: string;
+    project_id?: number;
+    status?: string;
+    priority?: string;
+    owner?: string;
+    guided_step?: string;
+    title?: string;
+    description?: string;
+    commit_hash?: string;
+}> | import("@compilr-dev/agents").Tool<{
+    item_id: string;
+    reason: string;
+    force?: boolean;
+    project_id?: number;
+}> | import("@compilr-dev/agents").Tool<{
+    item_id: string;
+    agent_id: string;
+    project_id?: number;
+}> | import("@compilr-dev/agents").Tool<{
+    item_id: string;
+    to_agent_id: string;
+    notes?: string;
+    project_id?: number;
+}>)[];