@crowley/rag-mcp 1.0.0

package/dist/tools/confluence.js

@@ -0,0 +1,147 @@
+/**
+ * Confluence tools module - search, index, status, and space listing
+ * for Confluence integration.
+ */
+import { truncate, pct } from "../formatters.js";
+/**
+ * Create the Confluence tools module with project-specific descriptions.
+ */
+export function createConfluenceTools(projectName) {
+    const tools = [
+        {
+            name: "search_confluence",
+            description: `Search indexed Confluence documentation for ${projectName}. Returns relevant pages with content snippets.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Search query for Confluence content",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Max results (default: 5)",
+                        default: 5,
+                    },
+                    spaceKey: {
+                        type: "string",
+                        description: "Filter by Confluence space key",
+                    },
+                },
+                required: ["query"],
+            },
+        },
+        {
+            name: "index_confluence",
+            description: `Index Confluence spaces/pages for ${projectName}. Requires Confluence credentials in RAG API.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    spaceKeys: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Specific space keys to index (indexes all accessible if empty)",
+                    },
+                    labels: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Filter pages by labels",
+                    },
+                    maxPages: {
+                        type: "number",
+                        description: "Maximum pages to index (default: 500)",
+                        default: 500,
+                    },
+                    force: {
+                        type: "boolean",
+                        description: "Force re-index even if already indexed",
+                        default: false,
+                    },
+                },
+            },
+        },
+        {
+            name: "get_confluence_status",
+            description: "Check if Confluence integration is configured and available.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+        {
+            name: "list_confluence_spaces",
+            description: "List available Confluence spaces that can be indexed.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+    ];
+    const handlers = {
+        search_confluence: async (args, ctx) => {
+            const { query, limit = 5, spaceKey } = args;
+            const response = await ctx.api.post("/api/search", {
+                collection: `${ctx.collectionPrefix}confluence`,
+                query,
+                limit,
+                filters: spaceKey ? { spaceKey } : undefined,
+            });
+            const results = response.data.results;
+            if (!results || results.length === 0) {
+                return "No Confluence results found.";
+            }
+            return results
+                .map((r) => `### ${r.title || r.file || "Untitled"}\n` +
+                `**Score:** ${pct(r.score)}` +
+                (r.spaceKey ? ` | **Space:** ${r.spaceKey}` : "") +
+                (r.url ? ` | [View](${r.url})` : "") +
+                `\n\n${truncate(r.content || "", 600)}`)
+                .join("\n\n---\n\n");
+        },
+        index_confluence: async (args, ctx) => {
+            const { spaceKeys, labels, maxPages = 500, force = false } = args;
+            const response = await ctx.api.post("/api/index/confluence", {
+                projectName: ctx.projectName,
+                spaceKeys,
+                labels,
+                maxPages,
+                force,
+            });
+            const data = response.data;
+            let result = `## Confluence Indexing\n\n`;
+            result += `- **Status:** ${data.status || "started"}\n`;
+            result += `- **Collection:** ${data.collection || `${ctx.collectionPrefix}confluence`}\n`;
+            result += `- **Options:**\n`;
+            if (spaceKeys && spaceKeys.length > 0) {
+                result += `  - Spaces: ${spaceKeys.join(", ")}\n`;
+            }
+            if (labels && labels.length > 0) {
+                result += `  - Labels: ${labels.join(", ")}\n`;
+            }
+            result += `  - Max Pages: ${maxPages}\n`;
+            result += `  - Force: ${force}\n`;
+            return result;
+        },
+        get_confluence_status: async (_args, ctx) => {
+            const response = await ctx.api.get("/api/confluence/status");
+            const data = response.data;
+            let result = `## Confluence Status\n\n`;
+            result += `- **Configured:** ${data.configured ? "Yes" : "No"}\n`;
+            result += `- **Message:** ${data.message || "N/A"}\n`;
+            return result;
+        },
+        list_confluence_spaces: async (_args, ctx) => {
+            const response = await ctx.api.get("/api/confluence/spaces");
+            const spaces = response.data.spaces || response.data;
+            if (!spaces || spaces.length === 0) {
+                return "No Confluence spaces available.";
+            }
+            let result = `## Confluence Spaces\n\n`;
+            for (const s of spaces) {
+                result += `- **${s.key}** - ${s.name} (${s.type || "global"})\n`;
+            }
+            return result;
+        },
+    };
+    return { tools, handlers };
+}

package/dist/tools/database.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Database Tools - Schema documentation, rules, enums, and validation.
+ */
+import type { ToolModule } from "../types.js";
+export declare function createDatabaseTools(projectName: string): ToolModule;

package/dist/tools/database.js

@@ -0,0 +1,429 @@
+/**
+ * Database Tools - Schema documentation, rules, enums, and validation.
+ */
+export function createDatabaseTools(projectName) {
+    const tools = [
+        {
+            name: "record_table",
+            description: `Record a database table definition with its purpose, columns, and relationships. Use this to document the database schema for ${projectName}.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tableName: {
+                        type: "string",
+                        description: "Name of the table (e.g., 'claims', 'documents')",
+                    },
+                    purpose: {
+                        type: "string",
+                        description: "What this table is for and when it's used",
+                    },
+                    columns: {
+                        type: "string",
+                        description: "Key columns and their purposes (format: 'column_name: description')",
+                    },
+                    relationships: {
+                        type: "string",
+                        description: "Relationships to other tables (FK references)",
+                    },
+                    indexes: {
+                        type: "string",
+                        description: "Important indexes and their purpose",
+                    },
+                    rules: {
+                        type: "string",
+                        description: "Business rules and constraints for this table",
+                    },
+                },
+                required: ["tableName", "purpose", "columns"],
+            },
+        },
+        {
+            name: "get_table_info",
+            description: "Get documented information about a database table including its purpose, columns, relationships, and rules.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tableName: {
+                        type: "string",
+                        description: "Table name to look up (or 'all' to list all tables)",
+                    },
+                },
+                required: ["tableName"],
+            },
+        },
+        {
+            name: "record_db_rule",
+            description: "Record a database rule or constraint that should be followed. Use this for data integrity rules, naming conventions, or query patterns.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    ruleName: {
+                        type: "string",
+                        description: "Short name for the rule",
+                    },
+                    description: {
+                        type: "string",
+                        description: "Detailed description of the rule",
+                    },
+                    scope: {
+                        type: "string",
+                        enum: ["global", "table", "column", "query", "migration"],
+                        description: "Where this rule applies",
+                    },
+                    examples: {
+                        type: "string",
+                        description: "Good and bad examples of applying this rule",
+                    },
+                },
+                required: ["ruleName", "description", "scope"],
+            },
+        },
+        {
+            name: "get_db_rules",
+            description: `Get database rules and constraints for ${projectName}. Filter by scope or get all rules.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    scope: {
+                        type: "string",
+                        enum: ["global", "table", "column", "query", "migration", "all"],
+                        description: "Filter by scope (default: all)",
+                        default: "all",
+                    },
+                },
+            },
+        },
+        {
+            name: "record_enum",
+            description: "Record a database enum type with its values and usage. Use this to document allowed values for status fields, types, etc.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    enumName: {
+                        type: "string",
+                        description: "Name of the enum (e.g., 'ClaimStatus', 'DocumentType')",
+                    },
+                    values: {
+                        type: "string",
+                        description: "List of enum values with descriptions (format: 'value: description')",
+                    },
+                    usedIn: {
+                        type: "string",
+                        description: "Tables and columns where this enum is used",
+                    },
+                    transitions: {
+                        type: "string",
+                        description: "Allowed state transitions (for status enums)",
+                    },
+                },
+                required: ["enumName", "values"],
+            },
+        },
+        {
+            name: "get_enums",
+            description: `Get documented enum types for ${projectName} database.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    enumName: {
+                        type: "string",
+                        description: "Specific enum to look up (or empty for all)",
+                    },
+                },
+            },
+        },
+        {
+            name: "check_db_schema",
+            description: "Check if a proposed database change follows the documented rules and patterns. Use before creating migrations.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    change: {
+                        type: "string",
+                        description: "Description of the proposed change (new table, column, index, etc.)",
+                    },
+                    sql: {
+                        type: "string",
+                        description: "Optional SQL or Prisma schema for the change",
+                    },
+                },
+                required: ["change"],
+            },
+        },
+        {
+            name: "suggest_db_schema",
+            description: "Get suggestions for database schema design for a new feature or data requirement.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    requirement: {
+                        type: "string",
+                        description: "What data needs to be stored or what feature needs support",
+                    },
+                    relatedTables: {
+                        type: "string",
+                        description: "Existing tables that might be related",
+                    },
+                },
+                required: ["requirement"],
+            },
+        },
+    ];
+    const handlers = {
+        async record_table(args, ctx) {
+            const { tableName, purpose, columns, relationships, indexes, rules } = args;
+            const content = `## Table: ${tableName}
+
+**Purpose:** ${purpose}
+
+### Columns
+${columns}
+
+${relationships ? `### Relationships\n${relationships}\n` : ""}
+${indexes ? `### Indexes\n${indexes}\n` : ""}
+${rules ? `### Business Rules\n${rules}` : ""}`;
+            await ctx.api.post("/api/memory", {
+                projectName: ctx.projectName,
+                content,
+                type: "context",
+                tags: ["database", "schema", "table", tableName.toLowerCase()],
+                relatedTo: `table:${tableName}`,
+                metadata: {
+                    tableType: "table",
+                    tableName,
+                },
+            });
+            return `Recorded table **${tableName}** documentation.\n\nUse \`get_table_info "${tableName}"\` to retrieve it later.`;
+        },
+        async get_table_info(args, ctx) {
+            const { tableName } = args;
+            const response = await ctx.api.post("/api/memory/recall", {
+                projectName: ctx.projectName,
+                query: tableName === "all" ? "database table schema" : `table ${tableName}`,
+                tag: "table",
+                limit: tableName === "all" ? 20 : 5,
+            });
+            const tables = response.data.results || [];
+            if (tables.length === 0) {
+                return `No documentation found for ${tableName === "all" ? "any tables" : `table "${tableName}"`}.\n\nUse \`record_table\` to document tables.`;
+            }
+            let result = tableName === "all"
+                ? `# Database Tables (${tables.length})\n\n`
+                : `# Table: ${tableName}\n\n`;
+            tables.forEach((t) => {
+                result += t.memory.content + "\n\n---\n\n";
+            });
+            return result;
+        },
+        async record_db_rule(args, ctx) {
+            const { ruleName, description, scope, examples } = args;
+            const content = `## DB Rule: ${ruleName}
+
+**Scope:** ${scope}
+
+${description}
+
+${examples ? `### Examples\n${examples}` : ""}`;
+            await ctx.api.post("/api/memory", {
+                projectName: ctx.projectName,
+                content,
+                type: "decision",
+                tags: ["database", "rule", scope],
+                relatedTo: `db-rule:${ruleName}`,
+                metadata: {
+                    ruleType: "db-rule",
+                    ruleName,
+                    scope,
+                },
+            });
+            return `Recorded database rule: **${ruleName}** (scope: ${scope})`;
+        },
+        async get_db_rules(args, ctx) {
+            const { scope = "all" } = args;
+            const response = await ctx.api.post("/api/memory/recall", {
+                projectName: ctx.projectName,
+                query: scope === "all"
+                    ? "database rule constraint"
+                    : `database rule ${scope}`,
+                tag: "rule",
+                limit: 15,
+            });
+            const rules = response.data.results || [];
+            if (rules.length === 0) {
+                return `No database rules found${scope !== "all" ? ` for scope "${scope}"` : ""}.\n\nUse \`record_db_rule\` to document rules.`;
+            }
+            let result = `# Database Rules (${rules.length})\n\n`;
+            rules.forEach((r) => {
+                const m = r.memory;
+                result += m.content + "\n\n---\n\n";
+            });
+            return result;
+        },
+        async record_enum(args, ctx) {
+            const { enumName, values, usedIn, transitions } = args;
+            const content = `## Enum: ${enumName}
+
+### Values
+${values}
+
+${usedIn ? `### Used In\n${usedIn}\n` : ""}
+${transitions ? `### State Transitions\n${transitions}` : ""}`;
+            await ctx.api.post("/api/memory", {
+                projectName: ctx.projectName,
+                content,
+                type: "context",
+                tags: ["database", "schema", "enum", enumName.toLowerCase()],
+                relatedTo: `enum:${enumName}`,
+                metadata: {
+                    tableType: "enum",
+                    enumName,
+                },
+            });
+            return `Recorded enum **${enumName}** documentation.`;
+        },
+        async get_enums(args, ctx) {
+            const { enumName } = args;
+            const response = await ctx.api.post("/api/memory/recall", {
+                projectName: ctx.projectName,
+                query: enumName
+                    ? `enum ${enumName}`
+                    : "database enum type values",
+                tag: "enum",
+                limit: 15,
+            });
+            const enums = response.data.results || [];
+            if (enums.length === 0) {
+                return `No enum documentation found${enumName ? ` for "${enumName}"` : ""}.\n\nUse \`record_enum\` to document enums.`;
+            }
+            let result = `# Database Enums (${enums.length})\n\n`;
+            enums.forEach((e) => {
+                result += e.memory.content + "\n\n---\n\n";
+            });
+            return result;
+        },
+        async check_db_schema(args, ctx) {
+            const { change, sql } = args;
+            // Get relevant rules and existing schema
+            const [rulesRes, tablesRes] = await Promise.all([
+                ctx.api.post("/api/memory/recall", {
+                    projectName: ctx.projectName,
+                    query: "database rule constraint naming convention",
+                    tag: "rule",
+                    limit: 10,
+                }),
+                ctx.api.post("/api/memory/recall", {
+                    projectName: ctx.projectName,
+                    query: change,
+                    tag: "table",
+                    limit: 5,
+                }),
+            ]);
+            const rules = rulesRes.data.results || [];
+            const relatedTables = tablesRes.data.results || [];
+            let result = `# Schema Change Review\n\n`;
+            result += `**Proposed Change:** ${change}\n\n`;
+            if (sql) {
+                result += `**SQL/Schema:**\n\`\`\`sql\n${sql}\n\`\`\`\n\n`;
+            }
+            result += `## Applicable Rules (${rules.length})\n`;
+            if (rules.length === 0) {
+                result += `_No database rules documented. Consider adding rules with \`record_db_rule\`._\n\n`;
+            }
+            else {
+                rules.forEach((r) => {
+                    const m = r.memory;
+                    result += `- **${m.metadata?.ruleName || m.relatedTo}** (${m.metadata?.scope || "general"})\n`;
+                });
+                result += "\n";
+            }
+            result += `## Related Tables (${relatedTables.length})\n`;
+            if (relatedTables.length === 0) {
+                result += `_No documented tables found related to this change._\n\n`;
+            }
+            else {
+                relatedTables.forEach((t) => {
+                    result += `- ${t.memory.metadata?.tableName || t.memory.relatedTo}\n`;
+                });
+                result += "\n";
+            }
+            result += `## Checklist\n`;
+            result += `- [ ] Follows naming conventions\n`;
+            result += `- [ ] Has appropriate indexes\n`;
+            result += `- [ ] Foreign keys properly defined\n`;
+            result += `- [ ] NOT NULL constraints where needed\n`;
+            result += `- [ ] Default values appropriate\n`;
+            result += `- [ ] Multi-tenant (partnerId) considered\n`;
+            result += `- [ ] Migration is reversible\n`;
+            return result;
+        },
+        async suggest_db_schema(args, ctx) {
+            const { requirement, relatedTables } = args;
+            // Get existing schema patterns and rules
+            const [rulesRes, tablesRes, enumsRes] = await Promise.all([
+                ctx.api.post("/api/memory/recall", {
+                    projectName: ctx.projectName,
+                    query: "database rule naming convention pattern",
+                    tag: "rule",
+                    limit: 5,
+                }),
+                ctx.api.post("/api/memory/recall", {
+                    projectName: ctx.projectName,
+                    query: relatedTables || requirement,
+                    tag: "table",
+                    limit: 5,
+                }),
+                ctx.api.post("/api/memory/recall", {
+                    projectName: ctx.projectName,
+                    query: requirement,
+                    tag: "enum",
+                    limit: 3,
+                }),
+            ]);
+            const rules = rulesRes.data.results || [];
+            const tables = tablesRes.data.results || [];
+            const enums = enumsRes.data.results || [];
+            let result = `# Schema Suggestion\n\n`;
+            result += `**Requirement:** ${requirement}\n\n`;
+            if (relatedTables) {
+                result += `**Related Tables:** ${relatedTables}\n\n`;
+            }
+            result += `## Existing Context\n\n`;
+            if (tables.length > 0) {
+                result += `### Related Tables\n`;
+                tables.forEach((t) => {
+                    result += `- **${t.memory.metadata?.tableName || t.memory.relatedTo}**\n`;
+                });
+                result += "\n";
+            }
+            if (enums.length > 0) {
+                result += `### Available Enums\n`;
+                enums.forEach((e) => {
+                    result += `- ${e.memory.metadata?.enumName || e.memory.relatedTo}\n`;
+                });
+                result += "\n";
+            }
+            if (rules.length > 0) {
+                result += `### Rules to Follow\n`;
+                rules.forEach((r) => {
+                    result += `- ${r.memory.metadata?.ruleName || r.memory.relatedTo}: ${r.memory.content.slice(0, 100)}...\n`;
+                });
+                result += "\n";
+            }
+            result += `## Suggestions\n\n`;
+            result += `Based on the existing schema patterns:\n\n`;
+            result += `1. **Table naming**: Use snake_case, plural (e.g., \`notifications\`)\n`;
+            result += `2. **Primary key**: UUID with \`gen_random_uuid()\`\n`;
+            result += `3. **Timestamps**: Include \`created_at\`, \`updated_at\`\n`;
+            result += `4. **Multi-tenant**: Add \`partner_id UUID NOT NULL\` with FK\n`;
+            result += `5. **Soft delete**: Consider \`deleted_at\` timestamp\n`;
+            result += `6. **Status fields**: Use PostgreSQL ENUMs\n`;
+            result += `\n## Next Steps\n`;
+            result += `1. Design the schema using suggestions above\n`;
+            result += `2. Run \`check_db_schema\` to validate\n`;
+            result += `3. Create Prisma migration\n`;
+            result += `4. Document with \`record_table\` after creation\n`;
+            return result;
+        },
+    };
+    return { tools, handlers };
+}

package/dist/tools/feedback.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Feedback tools module - search feedback, memory feedback, query suggestions,
+ * and quality metrics.
+ */
+import type { ToolModule } from "../types.js";
+/**
+ * Create the feedback tools module with project-specific descriptions.
+ */
+export declare function createFeedbackTools(projectName: string): ToolModule;