@compilr-dev/cli 0.5.0 → 0.5.1

package/dist/tools/project-db.js

@@ -1,11 +1,11 @@
 /**
- * Project Database Tools
+ * Project State Management
  *
- * Tools for managing projects in the database.
- * These tools allow the agent to create, query, and update projects.
+ * Runtime state for the current working project.
+ * Used by ~15+ CLI files for project context.
+ *
+ * Tool definitions have moved to the SDK (via platform-adapter.ts).
  */
-import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
-import { projectRepository } from '../db/repositories/index.js';
 import { setLastProjectId } from '../settings/index.js';
 // Current project state (runtime, not persisted)
 // This is the project the user is currently working on
@@ -37,334 +37,3 @@ export function clearCurrentProject() {
 export const getActiveProject = getCurrentProject;
 export const setActiveProject = setCurrentProject;
 export const clearActiveProject = clearCurrentProject;
-/**
- * project_get - Get project for current directory or by ID
- */
-export 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) => {
-        await Promise.resolve(); // Required for async type signature
-        try {
-            let project = null;
-            // Priority: ID > name > active > path detection
-            if (input.project_id) {
-                project = projectRepository.getById(input.project_id);
-            }
-            else if (input.name) {
-                project = projectRepository.getByName(input.name);
-            }
-            else if (currentProject) {
-                project = projectRepository.getById(currentProject.id);
-            }
-            else if (input.path) {
-                project = projectRepository.findByPath(input.path);
-            }
-            else {
-                // Try to find project by cwd
-                const cwd = process.cwd();
-                project = projectRepository.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
-            setCurrentProject({ 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 - Create a new project
- */
-export 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) => {
-        await Promise.resolve(); // Required for async type signature
-        try {
-            // Check if project with this name already exists
-            const existing = projectRepository.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 || process.cwd();
-            const existingByPath = projectRepository.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 = projectRepository.create(createInput);
-            // Set as current project
-            setCurrentProject({ 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 - Update an existing project
- */
-export 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")',
-            },
-            last_context: {
-                type: 'object',
-                description: 'Context for session resumption',
-            },
-        },
-        required: [],
-    },
-    execute: async (input) => {
-        await Promise.resolve(); // Required for async type signature
-        try {
-            const projectId = input.project_id || currentProject?.id;
-            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.last_context)
-                updateInput.last_context = input.last_context;
-            const project = projectRepository.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,
-                },
-            });
-        }
-        catch (error) {
-            return createErrorResult(`Failed to update project: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    },
-});
-/**
- * project_list - List projects
- */
-export 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) => {
-        await Promise.resolve(); // Required for async type signature
-        try {
-            const result = projectRepository.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: currentProject?.id,
-            });
-        }
-        catch (error) {
-            return createErrorResult(`Failed to list projects: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    },
-});
-/**
- * All project tools
- */
-export const projectDbTools = [
-    projectGetTool,
-    projectCreateTool,
-    projectUpdateTool,
-    projectListTool,
-];

package/dist/tools/recall-work-tool.d.ts

@@ -0,0 +1,18 @@
+/**
+ * recall_work Tool — Query Work History
+ *
+ * Lets agents proactively query episodic work history.
+ * Returns episodes with agent attribution, effort level, and affected files.
+ */
+interface RecallWorkInput {
+    /** Filter by file paths (returns episodes touching any of these files) */
+    files?: string[];
+    /** Filter by agent ID */
+    agentId?: string;
+    /** Filter by session ID */
+    sessionId?: string;
+    /** Return N most recent episodes (default: 20) */
+    recent?: number;
+}
+export declare const recallWorkTool: import("@compilr-dev/sdk").Tool<RecallWorkInput>;
+export {};

package/dist/tools/recall-work-tool.js

@@ -0,0 +1,82 @@
+/**
+ * recall_work Tool — Query Work History
+ *
+ * Lets agents proactively query episodic work history.
+ * Returns episodes with agent attribution, effort level, and affected files.
+ */
+import { defineTool } from '@compilr-dev/sdk';
+import { getGlobalEpisodeStore } from '../episodes/index.js';
+// =============================================================================
+// Tool Definition
+// =============================================================================
+export const recallWorkTool = defineTool({
+    name: 'recall_work',
+    description: 'Query work history — episodes of what agents have done in this project. ' +
+        'Returns episodes with agent attribution, effort level, and affected files. ' +
+        'Use before destructive operations to check what work would be affected. ' +
+        'Use to understand what has been done in this session or by other agents.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            files: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Filter by file paths — returns episodes touching any of these files',
+            },
+            agentId: {
+                type: 'string',
+                description: 'Filter by agent ID (e.g., "default", "backend")',
+            },
+            sessionId: {
+                type: 'string',
+                description: 'Filter by session ID',
+            },
+            recent: {
+                type: 'number',
+                description: 'Return N most recent episodes (default: 20)',
+            },
+        },
+    },
+    execute: (input) => {
+        const store = getGlobalEpisodeStore();
+        if (!store) {
+            return Promise.resolve({
+                success: false,
+                error: 'No episode store available (no active project)',
+            });
+        }
+        let episodes;
+        if (input.files && input.files.length > 0) {
+            episodes = store.getByFiles(input.files);
+        }
+        else if (input.agentId) {
+            episodes = store.getByAgent(input.agentId);
+        }
+        else if (input.sessionId) {
+            episodes = store.getBySession(input.sessionId);
+        }
+        else {
+            episodes = store.getRecent(input.recent ?? 20);
+        }
+        const summary = store.getWorkSummary();
+        return Promise.resolve({
+            success: true,
+            result: {
+                episodes: episodes.map(ep => ({
+                    id: ep.id,
+                    agentId: ep.agentId,
+                    terminalPrefix: ep.terminalPrefix,
+                    action: ep.action,
+                    summary: ep.summary,
+                    files: ep.files,
+                    effort: ep.effort,
+                    timestamp: ep.timestamp,
+                    toolCalls: ep.toolCalls,
+                })),
+                totalEpisodes: summary.episodeCount,
+                totalEffort: summary.totalEffort,
+                uncommittedCount: summary.uncommittedWork.length,
+            },
+        });
+    },
+});

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

@@ -6,11 +6,12 @@
 /**
  * workitem_query - Query work items with filters
  */
-export declare const workitemQueryTool: import("@compilr-dev/agents").Tool<{
+export declare const workitemQueryTool: import("@compilr-dev/sdk").Tool<{
     project_id?: number;
     status?: string;
     type?: string;
     priority?: string;
+    owner?: string;
     search?: string;
     limit?: number;
     offset?: number;
@@ -18,22 +19,24 @@ export declare const workitemQueryTool: import("@compilr-dev/agents").Tool<{
 /**
  * workitem_add - Add a new work item
  */
-export declare const workitemAddTool: import("@compilr-dev/agents").Tool<{
+export declare const workitemAddTool: import("@compilr-dev/sdk").Tool<{
     project_id?: number;
     type: string;
     title: string;
     description?: string;
     priority?: string;
     estimated_effort?: string;
+    owner?: string;
 }>;
 /**
  * workitem_update - Update a work item
  */
-export declare const workitemUpdateTool: import("@compilr-dev/agents").Tool<{
+export declare const workitemUpdateTool: import("@compilr-dev/sdk").Tool<{
     item_id: string;
     project_id?: number;
     status?: string;
     priority?: string;
+    owner?: string;
     guided_step?: string;
     title?: string;
     description?: string;
@@ -42,62 +45,91 @@ export declare const workitemUpdateTool: import("@compilr-dev/agents").Tool<{
 /**
  * workitem_next - Get the next work item to work on
  */
-export declare const workitemNextTool: import("@compilr-dev/agents").Tool<{
+export declare const workitemNextTool: import("@compilr-dev/sdk").Tool<{
     project_id?: number;
     type?: string;
 }>;
 /**
  * workitem_delete - Delete a work item
  */
-export declare const workitemDeleteTool: import("@compilr-dev/agents").Tool<{
+export declare const workitemDeleteTool: import("@compilr-dev/sdk").Tool<{
     item_id: string;
     project_id?: number;
 }>;
 /**
  * workitem_status_counts - Get work item counts by status
  */
-export declare const workitemStatusCountsTool: import("@compilr-dev/agents").Tool<{
+export declare const workitemStatusCountsTool: import("@compilr-dev/sdk").Tool<{
     project_id?: number;
 }>;
 /**
  * workitem_advance_step - Advance to the next guided workflow step
  */
-export declare const workitemAdvanceStepTool: import("@compilr-dev/agents").Tool<{
+export declare const workitemAdvanceStepTool: import("@compilr-dev/sdk").Tool<{
     item_id: string;
     reason: string;
     force?: boolean;
     project_id?: number;
 }>;
+/**
+ * workitem_claim - Claim an unassigned work item
+ */
+export declare const workitemClaimTool: import("@compilr-dev/sdk").Tool<{
+    item_id: string;
+    agent_id: string;
+    project_id?: number;
+}>;
+/**
+ * workitem_handoff - Hand off a work item to another agent
+ */
+export declare const workitemHandoffTool: import("@compilr-dev/sdk").Tool<{
+    item_id: string;
+    to_agent_id: string;
+    notes?: string;
+    project_id?: number;
+}>;
 /**
  * All work item tools
  */
-export declare const workitemDbTools: (import("@compilr-dev/agents").Tool<{
+export declare const workitemDbTools: (import("@compilr-dev/sdk").Tool<{
     project_id?: number;
     status?: string;
     type?: string;
     priority?: string;
+    owner?: string;
     search?: string;
     limit?: number;
     offset?: number;
-}> | import("@compilr-dev/agents").Tool<{
+}> | import("@compilr-dev/sdk").Tool<{
     project_id?: number;
     type: string;
     title: string;
     description?: string;
     priority?: string;
     estimated_effort?: string;
-}> | import("@compilr-dev/agents").Tool<{
+    owner?: string;
+}> | import("@compilr-dev/sdk").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<{
+}> | import("@compilr-dev/sdk").Tool<{
     item_id: string;
     reason: string;
     force?: boolean;
     project_id?: number;
+}> | import("@compilr-dev/sdk").Tool<{
+    item_id: string;
+    agent_id: string;
+    project_id?: number;
+}> | import("@compilr-dev/sdk").Tool<{
+    item_id: string;
+    to_agent_id: string;
+    notes?: string;
+    project_id?: number;
 }>)[];