@crowley/rag-mcp 1.5.0 → 1.6.0

package/dist/tools/memory.js

@@ -5,7 +5,7 @@
  *        batch_remember, validate_memory, review_memories,
  *        promote_memory, run_quality_gates, memory_maintenance
  */
-import { formatMemoryResults, truncate, paginationFooter, PREVIEW } from "../formatters.js";
+import { formatMemoryResults, truncate, paginationFooter, PREVIEW, } from "../formatters.js";
 import { z } from "zod";
 import { TOOL_ANNOTATIONS } from "../annotations.js";
 const typeEmojis = {
@@ -29,8 +29,21 @@ export function createMemoryTools(projectName) {
             description: "Store important information in agent memory. Use this to save decisions, insights, context, todos, or important conversations for future reference.",
             schema: z.object({
                 content: z.string().describe("Information to remember"),
-                type: z.enum(["decision", "insight", "context", "todo", "conversation", "note"]).optional().describe("Type of memory (default: note)"),
-                tags: z.array(z.string()).optional().describe("Tags for categorization (e.g., ['feature-x', 'important'])"),
+                type: z
+                    .enum([
+                    "decision",
+                    "insight",
+                    "context",
+                    "todo",
+                    "conversation",
+                    "note",
+                ])
+                    .optional()
+                    .describe("Type of memory (default: note)"),
+                tags: z
+                    .array(z.string())
+                    .optional()
+                    .describe("Tags for categorization (e.g., ['feature-x', 'important'])"),
                 relatedTo: z.string().optional().describe("Related feature or topic"),
             }),
             annotations: TOOL_ANNOTATIONS["remember"],
@@ -61,9 +74,27 @@ export function createMemoryTools(projectName) {
             description: "Retrieve relevant memories based on context. Searches agent memory for past decisions, insights, and notes related to the query.",
             schema: z.object({
                 query: z.string().describe("What to recall (semantic search)"),
-                type: z.enum(["decision", "insight", "context", "todo", "conversation", "note", "procedure", "all"]).optional().describe("Filter by memory type (default: all)"),
-                limit: z.coerce.number().optional().describe("Max memories to retrieve (default: 5)"),
-                graphRecall: z.boolean().optional().describe("Enable graph-aware recall with spreading activation (default: false)"),
+                type: z
+                    .enum([
+                    "decision",
+                    "insight",
+                    "context",
+                    "todo",
+                    "conversation",
+                    "note",
+                    "procedure",
+                    "all",
+                ])
+                    .optional()
+                    .describe("Filter by memory type (default: all)"),
+                limit: z.coerce
+                    .number()
+                    .optional()
+                    .describe("Max memories to retrieve (default: 5)"),
+                graphRecall: z
+                    .boolean()
+                    .optional()
+                    .describe("Enable graph-aware recall with spreading activation (default: false)"),
             }),
             annotations: TOOL_ANNOTATIONS["recall"],
             handler: async (args, ctx) => {
@@ -90,10 +121,27 @@ export function createMemoryTools(projectName) {
             name: "list_memories",
             description: "List recent memories or filter by type/tags. Shows what the agent has remembered.",
             schema: z.object({
-                type: z.enum(["decision", "insight", "context", "todo", "conversation", "note", "all"]).optional().describe("Filter by type"),
+                type: z
+                    .enum([
+                    "decision",
+                    "insight",
+                    "context",
+                    "todo",
+                    "conversation",
+                    "note",
+                    "all",
+                ])
+                    .optional()
+                    .describe("Filter by type"),
                 tag: z.string().optional().describe("Filter by tag"),
-                limit: z.coerce.number().optional().describe("Max results (default: 10)"),
-                offset: z.coerce.number().optional().describe("Pagination offset (default: 0)"),
+                limit: z.coerce
+                    .number()
+                    .optional()
+                    .describe("Max results (default: 10)"),
+                offset: z.coerce
+                    .number()
+                    .optional()
+                    .describe("Pagination offset (default: 0)"),
             }),
             annotations: TOOL_ANNOTATIONS["list_memories"],
             handler: async (args, ctx) => {
@@ -130,9 +178,25 @@ export function createMemoryTools(projectName) {
             name: "forget",
             description: "Delete a specific memory by ID or clear memories by type.",
             schema: z.object({
-                memoryId: z.string().optional().describe("Specific memory ID to delete"),
-                type: z.enum(["decision", "insight", "context", "todo", "conversation", "note"]).optional().describe("Delete all memories of this type"),
-                olderThanDays: z.coerce.number().optional().describe("Delete memories older than N days"),
+                memoryId: z
+                    .string()
+                    .optional()
+                    .describe("Specific memory ID to delete"),
+                type: z
+                    .enum([
+                    "decision",
+                    "insight",
+                    "context",
+                    "todo",
+                    "conversation",
+                    "note",
+                ])
+                    .optional()
+                    .describe("Delete all memories of this type"),
+                olderThanDays: z.coerce
+                    .number()
+                    .optional()
+                    .describe("Delete memories older than N days"),
             }),
             annotations: TOOL_ANNOTATIONS["forget"],
             handler: async (args, ctx) => {
@@ -164,7 +228,9 @@ export function createMemoryTools(projectName) {
             description: "Update status of a todo/task in memory.",
             schema: z.object({
                 todoId: z.string().describe("Todo memory ID"),
-                status: z.enum(["pending", "in_progress", "done", "cancelled"]).describe("New status"),
+                status: z
+                    .enum(["pending", "in_progress", "done", "cancelled"])
+                    .describe("New status"),
                 note: z.string().optional().describe("Optional note about the update"),
             }),
             annotations: TOOL_ANNOTATIONS["update_todo"],
@@ -191,12 +257,53 @@ export function createMemoryTools(projectName) {
             name: "batch_remember",
             description: `Efficiently store multiple memories at once in ${projectName}. Faster than individual remember calls.`,
             schema: z.object({
-                items: z.array(z.object({
+                items: z
+                    .array(z.object({
                     content: z.string().describe("Content to remember"),
-                    type: z.enum(["decision", "insight", "context", "todo", "conversation", "note"]).optional().describe("Memory type (default: note)"),
-                    tags: z.array(z.string()).optional().describe("Tags for categorization"),
-                    relatedTo: z.string().optional().describe("Related feature or topic"),
-                })).describe("Array of memories to store"),
+                    type: z
+                        .enum([
+                        "decision",
+                        "insight",
+                        "context",
+                        "todo",
+                        "conversation",
+                        "note",
+                    ])
+                        .optional()
+                        .describe("Memory type (default: note)"),
+                    tags: z
+                        .array(z.string())
+                        .optional()
+                        .describe("Tags for categorization"),
+                    relatedTo: z
+                        .string()
+                        .optional()
+                        .describe("Related feature or topic"),
+                    metadata: z
+                        .record(z.string(), z.unknown())
+                        .optional()
+                        .describe("Custom metadata (factEntities, factDateTs, etc.)"),
+                    factCategory: z
+                        .enum([
+                        "personal_info",
+                        "preference",
+                        "event",
+                        "temporal",
+                        "update",
+                        "plan",
+                    ])
+                        .optional()
+                        .describe("Structured fact category for temporal retrieval"),
+                    factEntities: z
+                        .array(z.string())
+                        .optional()
+                        .describe("Named entities: file names, service names, external systems"),
+                    factDateTs: z
+                        .number()
+                        .optional()
+                        .describe("Unix timestamp (seconds) for temporal filtering"),
+                }))
+                    .describe("Array of memories to store"),
             }),
             annotations: TOOL_ANNOTATIONS["batch_remember"],
             handler: async (args, ctx) => {
@@ -229,7 +336,9 @@ export function createMemoryTools(projectName) {
             description: `Validate or reject an auto-extracted memory in ${projectName}. Helps improve future extraction accuracy.`,
             schema: z.object({
                 memoryId: z.string().describe("ID of the memory to validate"),
-                validated: z.boolean().describe("true to confirm the memory is valuable, false to reject it"),
+                validated: z
+                    .boolean()
+                    .describe("true to confirm the memory is valuable, false to reject it"),
             }),
             annotations: TOOL_ANNOTATIONS["validate_memory"],
             handler: async (args, ctx) => {
@@ -250,8 +359,14 @@ export function createMemoryTools(projectName) {
             name: "review_memories",
             description: `Get auto-extracted memories pending review in ${projectName}. Shows unvalidated learnings that need human confirmation.`,
             schema: z.object({
-                limit: z.coerce.number().optional().describe("Max memories to return (default: 20)"),
-                offset: z.coerce.number().optional().describe("Pagination offset (default: 0)"),
+                limit: z.coerce
+                    .number()
+                    .optional()
+                    .describe("Max memories to return (default: 20)"),
+                offset: z.coerce
+                    .number()
+                    .optional()
+                    .describe("Pagination offset (default: 0)"),
             }),
             annotations: TOOL_ANNOTATIONS["review_memories"],
             handler: async (args, ctx) => {
@@ -285,10 +400,21 @@ export function createMemoryTools(projectName) {
             description: `Promote a quarantine memory to durable storage in ${projectName}. Requires a reason for promotion. Optionally runs quality gates before promotion.`,
             schema: z.object({
                 memoryId: z.string().describe("ID of the memory to promote"),
-                reason: z.enum(["human_validated", "pr_merged", "tests_passed"]).describe("Reason for promotion"),
-                evidence: z.string().optional().describe("Optional evidence supporting the promotion"),
-                runGates: z.boolean().optional().describe("Run quality gates before promotion (default: false)"),
-                affectedFiles: z.array(z.string()).optional().describe("Files affected by this memory (for quality gate checking)"),
+                reason: z
+                    .enum(["human_validated", "pr_merged", "tests_passed"])
+                    .describe("Reason for promotion"),
+                evidence: z
+                    .string()
+                    .optional()
+                    .describe("Optional evidence supporting the promotion"),
+                runGates: z
+                    .boolean()
+                    .optional()
+                    .describe("Run quality gates before promotion (default: false)"),
+                affectedFiles: z
+                    .array(z.string())
+                    .optional()
+                    .describe("Files affected by this memory (for quality gate checking)"),
             }),
             annotations: TOOL_ANNOTATIONS["promote_memory"],
             handler: async (args, ctx) => {
@@ -320,8 +446,14 @@ export function createMemoryTools(projectName) {
             name: "run_quality_gates",
             description: `Run quality gates (typecheck, tests, blast radius) for ${projectName}.`,
             schema: z.object({
-                affectedFiles: z.array(z.string()).optional().describe("Files to check (for related tests and blast radius)"),
-                skipGates: z.array(z.string()).optional().describe("Gates to skip (typecheck, test, blast_radius)"),
+                affectedFiles: z
+                    .array(z.string())
+                    .optional()
+                    .describe("Files to check (for related tests and blast radius)"),
+                skipGates: z
+                    .array(z.string())
+                    .optional()
+                    .describe("Gates to skip (typecheck, test, blast_radius)"),
             }),
             annotations: TOOL_ANNOTATIONS["run_quality_gates"],
             handler: async (args, ctx) => {
@@ -359,12 +491,27 @@ export function createMemoryTools(projectName) {
             name: "memory_maintenance",
             description: `Run memory maintenance for ${projectName}: quarantine cleanup (expire old auto-memories), feedback-driven promote/prune, and compaction (merge similar durable memories).`,
             schema: z.object({
-                operations: z.object({
-                    quarantine_cleanup: z.boolean().optional().describe("Remove expired quarantine memories (default: true)"),
-                    feedback_maintenance: z.boolean().optional().describe("Auto-promote/prune by feedback (default: true)"),
-                    compaction: z.boolean().optional().describe("Merge similar durable memories (default: false)"),
-                    compaction_dry_run: z.boolean().optional().describe("Preview compaction without changes (default: true)"),
-                }).optional().describe("Which operations to run (default: quarantine_cleanup + feedback_maintenance)"),
+                operations: z
+                    .object({
+                    quarantine_cleanup: z
+                        .boolean()
+                        .optional()
+                        .describe("Remove expired quarantine memories (default: true)"),
+                    feedback_maintenance: z
+                        .boolean()
+                        .optional()
+                        .describe("Auto-promote/prune by feedback (default: true)"),
+                    compaction: z
+                        .boolean()
+                        .optional()
+                        .describe("Merge similar durable memories (default: false)"),
+                    compaction_dry_run: z
+                        .boolean()
+                        .optional()
+                        .describe("Preview compaction without changes (default: true)"),
+                })
+                    .optional()
+                    .describe("Which operations to run (default: quarantine_cleanup + feedback_maintenance)"),
             }),
             annotations: TOOL_ANNOTATIONS["memory_maintenance"],
             handler: async (args, ctx) => {
@@ -381,7 +528,9 @@ export function createMemoryTools(projectName) {
                     result += `## Quarantine Cleanup\n`;
                     if (qc.rejected.length > 0) {
                         result += `**Expired** (${qc.rejected.length}): removed from quarantine\n`;
-                        qc.rejected.slice(0, 10).forEach((id) => { result += `  \u{1F5D1}\u{FE0F} ${id}\n`; });
+                        qc.rejected.slice(0, 10).forEach((id) => {
+                            result += `  \u{1F5D1}\u{FE0F} ${id}\n`;
+                        });
                         if (qc.rejected.length > 10)
                             result += `  ... and ${qc.rejected.length - 10} more\n`;
                     }
@@ -389,7 +538,9 @@ export function createMemoryTools(projectName) {
                         result += `No expired quarantine memories.\n`;
                     }
                     if (qc.errors.length > 0) {
-                        qc.errors.forEach((e) => { result += `  \u26A0\u{FE0F} ${e}\n`; });
+                        qc.errors.forEach((e) => {
+                            result += `  \u26A0\u{FE0F} ${e}\n`;
+                        });
                     }
                     result += `\n`;
                 }
@@ -399,24 +550,30 @@ export function createMemoryTools(projectName) {
                     result += `## Feedback Maintenance\n`;
                     if (fm.promoted.length > 0) {
                         result += `**Promoted** (${fm.promoted.length}): moved to durable\n`;
-                        fm.promoted.forEach((id) => { result += `  \u2705 ${id}\n`; });
+                        fm.promoted.forEach((id) => {
+                            result += `  \u2705 ${id}\n`;
+                        });
                     }
                     if (fm.pruned.length > 0) {
                         result += `**Pruned** (${fm.pruned.length}): removed\n`;
-                        fm.pruned.forEach((id) => { result += `  \u{1F5D1}\u{FE0F} ${id}\n`; });
+                        fm.pruned.forEach((id) => {
+                            result += `  \u{1F5D1}\u{FE0F} ${id}\n`;
+                        });
                     }
                     if (fm.promoted.length === 0 && fm.pruned.length === 0) {
                         result += `No feedback-based actions needed.\n`;
                     }
                     if (fm.errors.length > 0) {
-                        fm.errors.forEach((e) => { result += `  \u26A0\u{FE0F} ${e}\n`; });
+                        fm.errors.forEach((e) => {
+                            result += `  \u26A0\u{FE0F} ${e}\n`;
+                        });
                     }
                     result += `\n`;
                 }
                 // Compaction section
                 if (data.compaction) {
                     const cp = data.compaction;
-                    result += `## Compaction${cp.dryRun ? ' (dry run)' : ''}\n`;
+                    result += `## Compaction${cp.dryRun ? " (dry run)" : ""}\n`;
                     if (cp.clusters.length > 0) {
                         result += `**${cp.totalClusters} cluster(s)** of similar memories found\n\n`;
                         cp.clusters.slice(0, 5).forEach((c, i) => {

package/dist/tools/pm.js

@@ -14,8 +14,13 @@ export function createPmTools(projectName) {
             name: "search_requirements",
             description: `Search technical requirements and product documentation for ${projectName}. Finds relevant requirements, user stories, and specifications from Confluence.`,
             schema: z.object({
-                query: z.string().describe("Search query for requirements (e.g., 'video inspection flow', 'payment integration')"),
-                limit: z.coerce.number().optional().describe("Max results (default: 5)"),
+                query: z
+                    .string()
+                    .describe("Search query for requirements (e.g., 'video inspection flow', 'payment integration')"),
+                limit: z.coerce
+                    .number()
+                    .optional()
+                    .describe("Max results (default: 5)"),
             }),
             annotations: TOOL_ANNOTATIONS["search_requirements"],
             handler: async (args, ctx) => {
@@ -42,8 +47,13 @@ export function createPmTools(projectName) {
             name: "analyze_requirements",
             description: `Analyze technical requirements and compare with existing implementation in ${projectName}. Identifies gaps, missing features, and implementation status.`,
             schema: z.object({
-                feature: z.string().describe("Feature or requirement to analyze (e.g., 'video inspection', 'notifications')"),
-                detailed: z.boolean().optional().describe("Include detailed code references (default: false)"),
+                feature: z
+                    .string()
+                    .describe("Feature or requirement to analyze (e.g., 'video inspection', 'notifications')"),
+                detailed: z
+                    .boolean()
+                    .optional()
+                    .describe("Include detailed code references (default: false)"),
             }),
             annotations: TOOL_ANNOTATIONS["analyze_requirements"],
             handler: async (args, ctx) => {
@@ -107,7 +117,10 @@ export function createPmTools(projectName) {
             description: `Estimate development effort for a feature based on requirements and codebase analysis. Returns complexity assessment, affected files, and risk factors.`,
             schema: z.object({
                 feature: z.string().describe("Feature description to estimate"),
-                includeSubtasks: z.boolean().optional().describe("Break down into subtasks (default: true)"),
+                includeSubtasks: z
+                    .boolean()
+                    .optional()
+                    .describe("Break down into subtasks (default: true)"),
             }),
             annotations: TOOL_ANNOTATIONS["estimate_feature"],
             handler: async (args, ctx) => {
@@ -235,13 +248,22 @@ export function createPmTools(projectName) {
             name: "list_requirements",
             description: `List all documented requirements/features for ${projectName} from Confluence. Groups by category or status.`,
             schema: z.object({
-                category: z.string().optional().describe("Filter by category (optional)"),
-                limit: z.coerce.number().optional().describe("Max results (default: 20)"),
-                offset: z.coerce.number().optional().describe("Pagination offset (default: 0)"),
+                category: z
+                    .string()
+                    .optional()
+                    .describe("Filter by category (optional)"),
+                limit: z.coerce
+                    .number()
+                    .optional()
+                    .describe("Max results (default: 20)"),
+                offset: z.coerce
+                    .number()
+                    .optional()
+                    .describe("Pagination offset (default: 0)"),
             }),
             annotations: TOOL_ANNOTATIONS["list_requirements"],
             handler: async (args, ctx) => {
-                const { category, limit = 20, offset = 0 } = args;
+                const { category, limit = 20, offset = 0, } = args;
                 const query = category || "requirements features specifications";
                 const response = await ctx.api.post("/api/search", {
                     collection: `${ctx.collectionPrefix}confluence`,
@@ -274,7 +296,9 @@ export function createPmTools(projectName) {
             name: "ask_pm",
             description: `Ask product management questions about ${projectName}. Answers questions about requirements, features, priorities, and project status using both documentation and codebase.`,
             schema: z.object({
-                question: z.string().describe("PM question (e.g., 'What features are planned for video inspection?', 'What\\'s the status of notifications?')"),
+                question: z
+                    .string()
+                    .describe("PM question (e.g., 'What features are planned for video inspection?', 'What\\'s the status of notifications?')"),
             }),
             annotations: TOOL_ANNOTATIONS["ask_pm"],
             handler: async (args, ctx) => {
@@ -335,7 +359,10 @@ export function createPmTools(projectName) {
             description: `Generate technical specification from requirements. Creates a structured spec document based on Confluence requirements and existing codebase patterns.`,
             schema: z.object({
                 feature: z.string().describe("Feature to generate spec for"),
-                format: z.enum(["markdown", "jira", "brief"]).optional().describe("Output format (default: markdown)"),
+                format: z
+                    .enum(["markdown", "jira", "brief"])
+                    .optional()
+                    .describe("Output format (default: markdown)"),
             }),
             annotations: TOOL_ANNOTATIONS["generate_spec"],
             handler: async (args, ctx) => {

package/dist/tools/quality.js

@@ -12,7 +12,10 @@ export function createQualityTools(projectName) {
             name: "get_quality_report",
             description: `Get LLM quality metrics for ${projectName}. Shows JSON parse rates, latency percentiles, thinking trace rates, and alerts.`,
             schema: z.object({
-                endpoint: z.string().optional().describe("Filter by specific endpoint (e.g., '/api/ask')"),
+                endpoint: z
+                    .string()
+                    .optional()
+                    .describe("Filter by specific endpoint (e.g., '/api/ask')"),
             }),
             annotations: TOOL_ANNOTATIONS["get_quality_report"] || {
                 title: "Get Quality Report",
@@ -20,7 +23,9 @@ export function createQualityTools(projectName) {
                 openWorldHint: false,
             },
             handler: async (args, ctx) => {
-                const params = args.endpoint ? `?endpoint=${encodeURIComponent(args.endpoint)}` : '';
+                const params = args.endpoint
+                    ? `?endpoint=${encodeURIComponent(args.endpoint)}`
+                    : "";
                 const response = await ctx.api.get(`/api/quality/report${params}`);
                 const data = response.data;
                 let result = `## Quality Report\n\n`;

package/dist/tools/review.js

@@ -14,12 +14,18 @@ export function createReviewTools(projectName) {
             schema: z.object({
                 code: z.string().describe("Code to review"),
                 filePath: z.string().optional().describe("File path for context"),
-                reviewType: z.enum(["security", "performance", "patterns", "style", "general"]).optional().describe("Type of review focus (default: general)"),
-                diff: z.string().optional().describe("Git diff to review instead of full code"),
+                reviewType: z
+                    .enum(["security", "performance", "patterns", "style", "general"])
+                    .optional()
+                    .describe("Type of review focus (default: general)"),
+                diff: z
+                    .string()
+                    .optional()
+                    .describe("Git diff to review instead of full code"),
             }),
             annotations: TOOL_ANNOTATIONS["review_code"],
             handler: async (args, ctx) => {
-                const { code, filePath, reviewType = "general", diff } = args;
+                const { code, filePath, reviewType = "general", diff, } = args;
                 const response = await ctx.api.post("/api/review", {
                     code: code || diff,
                     filePath,
@@ -76,9 +82,18 @@ export function createReviewTools(projectName) {
             schema: z.object({
                 code: z.string().describe("Code to generate tests for"),
                 filePath: z.string().optional().describe("File path for context"),
-                framework: z.enum(["jest", "vitest", "pytest", "mocha"]).optional().describe("Test framework to use (default: jest)"),
-                testType: z.enum(["unit", "integration", "e2e"]).optional().describe("Type of tests to generate (default: unit)"),
-                coverage: z.enum(["minimal", "standard", "comprehensive"]).optional().describe("Coverage level (default: comprehensive)"),
+                framework: z
+                    .enum(["jest", "vitest", "pytest", "mocha"])
+                    .optional()
+                    .describe("Test framework to use (default: jest)"),
+                testType: z
+                    .enum(["unit", "integration", "e2e"])
+                    .optional()
+                    .describe("Type of tests to generate (default: unit)"),
+                coverage: z
+                    .enum(["minimal", "standard", "comprehensive"])
+                    .optional()
+                    .describe("Coverage level (default: comprehensive)"),
             }),
             annotations: TOOL_ANNOTATIONS["generate_tests"],
             handler: async (args, ctx) => {
@@ -115,7 +130,10 @@ export function createReviewTools(projectName) {
             description: "Analyze existing tests for coverage and quality.",
             schema: z.object({
                 testCode: z.string().describe("Test code to analyze"),
-                sourceCode: z.string().optional().describe("Optional source code being tested"),
+                sourceCode: z
+                    .string()
+                    .optional()
+                    .describe("Optional source code being tested"),
             }),
             annotations: TOOL_ANNOTATIONS["analyze_tests"],
             handler: async (args, ctx) => {