@compilr-dev/cli 0.5.0 → 0.5.2

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.d.ts

@@ -1,15 +1,80 @@
 /**
  * Tool Registry Setup
  *
- * Configures all available tools from @compilr-dev/agents
- * and @compilr-dev/agents-coding packages.
+ * Configures all available tools from @compilr-dev/sdk
+ * (which re-exports from @compilr-dev/agents and @compilr-dev/agents-coding).
+ *
+ * ARCHITECTURE (Meta-Tools):
+ * - DIRECT TOOLS: Always available, called by name (most common operations)
+ * - META-REGISTRY TOOLS: Available via use_tool() (specialized operations)
+ *
+ * This reduces token overhead from ~15K to ~2K per request.
+ *
+ * SINGLE SOURCE OF TRUTH:
+ * Tool names are defined in tool-names.ts (a dependency-free module).
+ * This file re-exports them for convenience. Import from here or tool-names.ts.
  */
+export { TOOL_NAMES, type ToolName, DIRECT_TOOL_NAMES, META_TOOL_NAMES, META_REGISTRY_TOOL_NAMES, getAllToolNames, } from './tool-names.js';
+import { TodoStore, type Tool } from '@compilr-dev/sdk';
+export declare const todoStore: TodoStore;
+import { setMetaToolFilter, getRegisteredMetaTools } from './tools/meta-tools.js';
+export { setMetaToolFilter, getRegisteredMetaTools };
 /**
  * Creates the tool registry with all available tools.
  * Returns tools as-is - the Agent.registerTools() method handles typing.
+ *
+ * @deprecated Use createDirectToolRegistry() + initializeMetaTools() instead
  */
 export declare function createToolRegistry(): unknown[];
 /**
  * Returns a minimal set of tools for basic testing.
  */
 export declare function createMinimalToolRegistry(): unknown[];
+/**
+ * Get direct tools that are always available.
+ * These are declared normally and can be called by name.
+ */
+export declare function getDirectTools(): Tool[];
+/**
+ * Get meta-tools for agent registration.
+ * Only get_tool_info is kept as a direct tool — use_tool and list_tools
+ * are no longer needed since the fallback handler routes calls transparently.
+ */
+export declare function getMetaTools(): Tool[];
+/**
+ * Create a fallback handler for the tool registry.
+ * When the agent calls a tool not in the direct registry, this handler
+ * checks the meta-registry and executes it transparently.
+ */
+export declare function createToolFallback(): (name: string, input: Record<string, unknown>) => Promise<import('@compilr-dev/sdk').ToolExecutionResult | null>;
+/**
+ * Initialize the meta-tool registry with specialized tools.
+ * Call this once at startup.
+ */
+export declare function initializeMetaTools(): void;
+/**
+ * Get the tool index for the system prompt.
+ * This lists all meta-registry tools with their signatures.
+ */
+export declare function getToolIndexForSystemPrompt(): string;
+/**
+ * Get count of meta-registry tools.
+ */
+export declare function getMetaToolsCount(): number;
+/**
+ * Check if meta-tools mode is enabled.
+ * Returns true if the meta-tool registry has been initialized.
+ */
+export declare function isMetaToolsEnabled(): boolean;
+/**
+ * Get tool statistics for debugging/display.
+ */
+export declare function getToolStats(): {
+    directTools: number;
+    metaRegistryTools: number;
+    totalTools: number;
+    estimatedDirectTokens: number;
+    estimatedMetaTokens: number;
+    estimatedLegacyTokens: number;
+    tokenSavings: number;
+};