@compilr-dev/cli 0.4.0 → 0.5.0

package/dist/tools/document-db.js

@@ -0,0 +1,220 @@
+/**
+ * Document Database Tools
+ *
+ * Tools for managing project documents (PRD, architecture, design notes) in the database.
+ */
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+import { documentRepository } from '../db/repositories/index.js';
+import { getActiveProject } from './project-db.js';
+/**
+ * project_document_add - Add or update a project document
+ */
+export const projectDocumentAddTool = defineTool({
+    name: 'project_document_add',
+    description: 'Add or update a project document (PRD, architecture, design, notes). If a document of the same type exists, it will be updated.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            project_id: {
+                type: 'number',
+                description: 'Project ID (uses active project if not provided)',
+            },
+            doc_type: {
+                type: 'string',
+                enum: ['prd', 'architecture', 'design', 'notes'],
+                description: 'Document type',
+            },
+            title: {
+                type: 'string',
+                description: 'Document title',
+            },
+            content: {
+                type: 'string',
+                description: 'Document content (markdown)',
+            },
+        },
+        required: ['doc_type', 'title', 'content'],
+    },
+    execute: async (input) => {
+        await Promise.resolve(); // Required for async type signature
+        try {
+            const projectId = input.project_id || getActiveProject()?.id;
+            if (!projectId) {
+                return createErrorResult('No project specified and no active project. Use project_get or /projects to select a project first.');
+            }
+            const createInput = {
+                project_id: projectId,
+                doc_type: input.doc_type,
+                title: input.title,
+                content: input.content,
+            };
+            const doc = documentRepository.upsert(createInput);
+            return createSuccessResult({
+                success: true,
+                message: `Document "${doc.title}" saved`,
+                document: {
+                    id: doc.id,
+                    docType: doc.docType,
+                    title: doc.title,
+                    contentLength: doc.content.length,
+                    updatedAt: doc.updatedAt.toISOString(),
+                },
+            });
+        }
+        catch (error) {
+            return createErrorResult(`Failed to save document: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    },
+});
+/**
+ * project_document_get - Get a project document
+ */
+export const projectDocumentGetTool = defineTool({
+    name: 'project_document_get',
+    description: 'Get a project document by type. Returns the document content.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            project_id: {
+                type: 'number',
+                description: 'Project ID (uses active project if not provided)',
+            },
+            doc_type: {
+                type: 'string',
+                enum: ['prd', 'architecture', 'design', 'notes'],
+                description: 'Document type to retrieve',
+            },
+        },
+        required: ['doc_type'],
+    },
+    execute: async (input) => {
+        await Promise.resolve(); // Required for async type signature
+        try {
+            const projectId = input.project_id || getActiveProject()?.id;
+            if (!projectId) {
+                return createErrorResult('No project specified and no active project. Use project_get or /projects to select a project first.');
+            }
+            const doc = documentRepository.getByType(projectId, input.doc_type);
+            if (!doc) {
+                return createSuccessResult({
+                    success: true,
+                    document: null,
+                    message: `No ${input.doc_type} document found for this project`,
+                });
+            }
+            return createSuccessResult({
+                success: true,
+                document: {
+                    id: doc.id,
+                    docType: doc.docType,
+                    title: doc.title,
+                    content: doc.content,
+                    createdAt: doc.createdAt.toISOString(),
+                    updatedAt: doc.updatedAt.toISOString(),
+                },
+            });
+        }
+        catch (error) {
+            return createErrorResult(`Failed to get document: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    },
+});
+/**
+ * project_document_list - List all documents for a project
+ */
+export const projectDocumentListTool = defineTool({
+    name: 'project_document_list',
+    description: 'List all documents for a project. Returns document metadata without full content.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            project_id: {
+                type: 'number',
+                description: 'Project ID (uses active project if not provided)',
+            },
+        },
+        required: [],
+    },
+    execute: async (input) => {
+        await Promise.resolve(); // Required for async type signature
+        try {
+            const projectId = input.project_id || getActiveProject()?.id;
+            if (!projectId) {
+                return createErrorResult('No project specified and no active project. Use project_get or /projects to select a project first.');
+            }
+            const docs = documentRepository.listByProject(projectId);
+            const documents = docs.map((doc) => ({
+                id: doc.id,
+                docType: doc.docType,
+                title: doc.title,
+                contentLength: doc.content.length,
+                createdAt: doc.createdAt.toISOString(),
+                updatedAt: doc.updatedAt.toISOString(),
+            }));
+            return createSuccessResult({
+                success: true,
+                documents,
+                count: documents.length,
+            });
+        }
+        catch (error) {
+            return createErrorResult(`Failed to list documents: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    },
+});
+/**
+ * project_document_delete - Delete a project document
+ */
+export const projectDocumentDeleteTool = defineTool({
+    name: 'project_document_delete',
+    description: 'Delete a project document by type.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            project_id: {
+                type: 'number',
+                description: 'Project ID (uses active project if not provided)',
+            },
+            doc_type: {
+                type: 'string',
+                enum: ['prd', 'architecture', 'design', 'notes'],
+                description: 'Document type to delete',
+            },
+        },
+        required: ['doc_type'],
+    },
+    execute: async (input) => {
+        await Promise.resolve(); // Required for async type signature
+        try {
+            const projectId = input.project_id || getActiveProject()?.id;
+            if (!projectId) {
+                return createErrorResult('No project specified and no active project. Use project_get or /projects to select a project first.');
+            }
+            // Find the document first
+            const doc = documentRepository.getByType(projectId, input.doc_type);
+            if (!doc) {
+                return createErrorResult(`No ${input.doc_type} document found for this project`);
+            }
+            const deleted = documentRepository.delete(doc.id);
+            if (!deleted) {
+                return createErrorResult(`Failed to delete ${input.doc_type} document`);
+            }
+            return createSuccessResult({
+                success: true,
+                message: `Document "${doc.title}" deleted`,
+            });
+        }
+        catch (error) {
+            return createErrorResult(`Failed to delete document: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    },
+});
+/**
+ * All document tools
+ */
+export const documentDbTools = [
+    projectDocumentAddTool,
+    projectDocumentGetTool,
+    projectDocumentListTool,
+    projectDocumentDeleteTool,
+];

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

@@ -0,0 +1,102 @@
+/**
+ * Project Database Tools
+ *
+ * Tools for managing projects in the database.
+ * These tools allow the agent to create, query, and update projects.
+ */
+/**
+ * Get the current working project
+ */
+export declare function getCurrentProject(): {
+    id: number;
+    name: string;
+    displayName: string;
+    path: string;
+} | null;
+/**
+ * Set the current working project
+ * Also remembers it as lastProjectId for "last opened" startup mode
+ */
+export declare function setCurrentProject(project: {
+    id: number;
+    name: string;
+    displayName: string;
+    path: string;
+} | null): void;
+/**
+ * Clear the current working project
+ */
+export declare function clearCurrentProject(): void;
+export declare const getActiveProject: typeof getCurrentProject;
+export declare const setActiveProject: typeof setCurrentProject;
+export declare const clearActiveProject: typeof clearCurrentProject;
+/**
+ * project_get - Get project for current directory or by ID
+ */
+export declare const projectGetTool: import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+    name?: string;
+    path?: string;
+}>;
+/**
+ * project_create - Create a new project
+ */
+export declare const projectCreateTool: import("@compilr-dev/agents").Tool<{
+    name: string;
+    display_name: string;
+    description?: string;
+    path?: string;
+    type?: string;
+    workflow_mode?: string;
+    language?: string;
+    framework?: string;
+    package_manager?: string;
+}>;
+/**
+ * project_update - Update an existing project
+ */
+export declare const projectUpdateTool: import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+    status?: string;
+    description?: string;
+    workflow_mode?: string;
+    lifecycle_state?: string;
+    current_item_id?: string;
+    last_context?: Record<string, unknown>;
+}>;
+/**
+ * project_list - List projects
+ */
+export declare const projectListTool: import("@compilr-dev/agents").Tool<{
+    status?: string;
+    limit?: number;
+}>;
+/**
+ * All project tools
+ */
+export declare const projectDbTools: (import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+    name?: string;
+    path?: string;
+}> | import("@compilr-dev/agents").Tool<{
+    name: string;
+    display_name: string;
+    description?: string;
+    path?: string;
+    type?: string;
+    workflow_mode?: string;
+    language?: string;
+    framework?: string;
+    package_manager?: string;
+}> | import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+    status?: string;
+    description?: string;
+    workflow_mode?: string;
+    lifecycle_state?: string;
+    current_item_id?: string;
+    last_context?: Record<string, unknown>;
+}> | import("@compilr-dev/agents").Tool<{
+    status?: string;
+    limit?: number;
+}>)[];

package/dist/tools/project-db.js

@@ -0,0 +1,370 @@
+/**
+ * Project Database Tools
+ *
+ * Tools for managing projects in the database.
+ * These tools allow the agent to create, query, and update projects.
+ */
+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
+let currentProject = null;
+/**
+ * Get the current working project
+ */
+export function getCurrentProject() {
+    return currentProject;
+}
+/**
+ * Set the current working project
+ * Also remembers it as lastProjectId for "last opened" startup mode
+ */
+export function setCurrentProject(project) {
+    currentProject = project;
+    // Remember for "last opened" startup mode
+    if (project) {
+        setLastProjectId(project.id);
+    }
+}
+/**
+ * Clear the current working project
+ */
+export function clearCurrentProject() {
+    currentProject = null;
+}
+// Legacy aliases (for backward compatibility during transition)
+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,
+];