@compilr-dev/sdk 0.1.7 → 0.1.8

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

@@ -0,0 +1,217 @@
+/**
+ * Document Tools — CRUD operations for project documents.
+ *
+ * 4 tools: project_document_add, project_document_get,
+ *          project_document_list, project_document_delete
+ *
+ * Ported from CLI's src/tools/document-db.ts.
+ */
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export function createDocumentTools(config) {
+    const { context: ctx } = config;
+    // ---------------------------------------------------------------------------
+    // project_document_add
+    // ---------------------------------------------------------------------------
+    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) => {
+            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 first.');
+                }
+                const createInput = {
+                    project_id: projectId,
+                    doc_type: input.doc_type,
+                    title: input.title,
+                    content: input.content,
+                };
+                const doc = await ctx.documents.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
+    // ---------------------------------------------------------------------------
+    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) => {
+            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 first.');
+                }
+                const doc = await ctx.documents.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
+    // ---------------------------------------------------------------------------
+    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) => {
+            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 first.');
+                }
+                const docs = await ctx.documents.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
+    // ---------------------------------------------------------------------------
+    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) => {
+            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 first.');
+                }
+                const doc = await ctx.documents.getByType(projectId, input.doc_type);
+                if (!doc) {
+                    return createErrorResult(`No ${input.doc_type} document found for this project`);
+                }
+                const deleted = await ctx.documents.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)}`);
+            }
+        },
+    });
+    return [
+        projectDocumentAddTool,
+        projectDocumentGetTool,
+        projectDocumentListTool,
+        projectDocumentDeleteTool,
+    ];
+}

package/dist/platform/tools/index.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Platform Tools — Factory function for all platform tools.
+ *
+ * Returns 24 tool definitions operating against async PlatformContext repositories.
+ * Decouples tool logic from SQLite storage, enabling mock-based testing and
+ * future PostgreSQL/API backends.
+ */
+import type { PlatformToolsConfig } from '../context.js';
+/**
+ * Create all 24 platform tools operating against the given context.
+ */
+export declare function createPlatformTools(config: PlatformToolsConfig): (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;
+    git_remote?: string;
+    git_branch?: string;
+    last_context?: Record<string, unknown>;
+}> | 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;
+}> | import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+    doc_type: string;
+    title: string;
+    content: string;
+}> | import("@compilr-dev/agents").Tool<{
+    name: string;
+    content: string;
+    work_item_id?: number;
+    project_id?: number;
+}> | import("@compilr-dev/agents").Tool<{
+    plan_id: number;
+    content?: string;
+    status?: string;
+    work_item_id?: number | null;
+}> | import("@compilr-dev/agents").Tool<{
+    plan_id?: number;
+    name?: string;
+    project_id?: number;
+}> | import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+    status?: string;
+    work_item_id?: number;
+    limit?: number;
+    order_by?: string;
+}> | import("@compilr-dev/agents").Tool<{
+    id?: string;
+    status?: string;
+    type?: string;
+    search?: string;
+    priority?: string;
+    limit?: number;
+}> | import("@compilr-dev/agents").Tool<{
+    action: string;
+    item?: {
+        id?: string;
+        type?: string;
+        title?: string;
+        description?: string;
+        status?: string;
+        priority?: string;
+        owner?: string;
+        commit_hash?: string;
+    };
+    deleteId?: string;
+    items?: Array<{
+        id?: string;
+        type: string;
+        title: string;
+        description?: string;
+        status?: string;
+        priority?: string;
+    }>;
+}>)[];
+export { createProjectTools } from './project-tools.js';
+export { createWorkItemTools } from './workitem-tools.js';
+export { createDocumentTools } from './document-tools.js';
+export { createPlanTools } from './plan-tools.js';
+export { createBacklogTools } from './backlog-tools.js';

package/dist/platform/tools/index.js

@@ -0,0 +1,31 @@
+/**
+ * Platform Tools — Factory function for all platform tools.
+ *
+ * Returns 24 tool definitions operating against async PlatformContext repositories.
+ * Decouples tool logic from SQLite storage, enabling mock-based testing and
+ * future PostgreSQL/API backends.
+ */
+import { createProjectTools } from './project-tools.js';
+import { createWorkItemTools } from './workitem-tools.js';
+import { createDocumentTools } from './document-tools.js';
+import { createPlanTools } from './plan-tools.js';
+import { createBacklogTools } from './backlog-tools.js';
+/**
+ * Create all 24 platform tools operating against the given context.
+ */
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export function createPlatformTools(config) {
+    return [
+        ...createProjectTools(config),
+        ...createWorkItemTools(config),
+        ...createDocumentTools(config),
+        ...createPlanTools(config),
+        ...createBacklogTools(config),
+    ];
+}
+// Re-export individual factory functions for selective use
+export { createProjectTools } from './project-tools.js';
+export { createWorkItemTools } from './workitem-tools.js';
+export { createDocumentTools } from './document-tools.js';
+export { createPlanTools } from './plan-tools.js';
+export { createBacklogTools } from './backlog-tools.js';

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

@@ -0,0 +1,29 @@
+/**
+ * Plan Tools — CRUD operations for plans.
+ *
+ * 5 tools: plan_create, plan_update, plan_get, plan_list, plan_delete
+ *
+ * Ported from CLI's src/tools/plan-tools.ts.
+ */
+import type { PlatformToolsConfig } from '../context.js';
+export declare function createPlanTools(config: PlatformToolsConfig): (import("@compilr-dev/agents").Tool<{
+    name: string;
+    content: string;
+    work_item_id?: number;
+    project_id?: number;
+}> | import("@compilr-dev/agents").Tool<{
+    plan_id: number;
+    content?: string;
+    status?: string;
+    work_item_id?: number | null;
+}> | import("@compilr-dev/agents").Tool<{
+    plan_id?: number;
+    name?: string;
+    project_id?: number;
+}> | import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+    status?: string;
+    work_item_id?: number;
+    limit?: number;
+    order_by?: string;
+}>)[];