44reports-mcp 1.0.9 → 1.2.0

package/dist/tools/backlog.test.js

@@ -0,0 +1,255 @@
+import { addToBacklogSchema, listBacklogSchema, processBacklogSchema, createAddToBacklogTool, createListBacklogTool, createProcessBacklogTool, } from './backlog.js';
+// --- Schema validation tests ---
+describe('addToBacklogSchema', () => {
+    it('requires content', () => {
+        const result = addToBacklogSchema.safeParse({});
+        expect(result.success).toBe(false);
+    });
+    it('accepts content only', () => {
+        const result = addToBacklogSchema.safeParse({ content: 'User mentioned they love the dark mode feature' });
+        expect(result.success).toBe(true);
+    });
+    it('accepts all optional fields', () => {
+        const result = addToBacklogSchema.safeParse({
+            content: 'Competitor launched new pricing tier at $9.99/mo',
+            product_slug: 'my-app',
+            source: 'competitor-monitor',
+            source_context: 'weekly-research',
+            domain_hint: 'product-research',
+            tags: ['competitor', 'pricing'],
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.product_slug).toBe('my-app');
+            expect(result.data.tags).toEqual(['competitor', 'pricing']);
+        }
+    });
+    it('rejects invalid domain_hint', () => {
+        const result = addToBacklogSchema.safeParse({
+            content: 'Some observation',
+            domain_hint: 'invalid-domain',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('listBacklogSchema', () => {
+    it('accepts empty input', () => {
+        const result = listBacklogSchema.safeParse({});
+        expect(result.success).toBe(true);
+    });
+    it('accepts all filters', () => {
+        const result = listBacklogSchema.safeParse({
+            product_slug: 'my-app',
+            status: 'pending',
+            limit: 10,
+            offset: 20,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects invalid status', () => {
+        const result = listBacklogSchema.safeParse({ status: 'invalid' });
+        expect(result.success).toBe(false);
+    });
+});
+describe('processBacklogSchema', () => {
+    it('accepts empty input with dry_run defaulting to true', () => {
+        const result = processBacklogSchema.safeParse({});
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.dry_run).toBe(true);
+        }
+    });
+    it('accepts product_slug and dry_run false', () => {
+        const result = processBacklogSchema.safeParse({
+            product_slug: 'my-app',
+            dry_run: false,
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.dry_run).toBe(false);
+        }
+    });
+});
+function makeEntry(overrides = {}) {
+    return {
+        id: 'entry-1',
+        product_slug: null,
+        content: 'Test observation',
+        source: null,
+        source_context: null,
+        domain_hint: null,
+        tags: null,
+        status: 'pending',
+        result_summary: null,
+        applied_changes: null,
+        rejection_reason: null,
+        processed_at: null,
+        created_at: '2026-03-06T00:00:00Z',
+        updated_at: '2026-03-06T00:00:00Z',
+        ...overrides,
+    };
+}
+/** Simple call tracker — records arguments passed to each mock method */
+function createTrackedClient(mocks) {
+    const calls = {
+        addBacklogEntry: [],
+        listBacklog: [],
+        processBacklog: [],
+    };
+    const client = {
+        addBacklogEntry: async (data) => {
+            calls.addBacklogEntry.push(data);
+            return mocks.addBacklogEntry?.(data) ?? {};
+        },
+        listBacklog: async (options) => {
+            calls.listBacklog.push(options);
+            return mocks.listBacklog?.(options) ?? { entries: [], total: 0 };
+        },
+        processBacklog: async (options) => {
+            calls.processBacklog.push(options);
+            return mocks.processBacklog?.(options) ?? {};
+        },
+    };
+    return { client, calls };
+}
+describe('add_to_backlog → list_backlog → process_backlog flow', () => {
+    it('adds an entry, lists it, then processes it', async () => {
+        const entry = makeEntry({
+            content: 'Users report competitor app Calm added sleep stories',
+            product_slug: 'my-meditation-app',
+            source: 'research-agent',
+            domain_hint: 'product-research',
+            tags: '["competitor","feature"]',
+        });
+        const processResponse = {
+            routed: 0,
+            processed: 1,
+            applied: 1,
+            rejected: 0,
+            partial: 0,
+            errors: [],
+            details: [{
+                    id: entry.id,
+                    status: 'applied',
+                    result_summary: 'Added competitor insight to research doc',
+                    applied_changes: [{ filepath: 'docs/research/competitors.md', action: 'md_append', product_slug: 'my-meditation-app' }],
+                    rejection_reason: null,
+                }],
+        };
+        const { client, calls } = createTrackedClient({
+            addBacklogEntry: async () => ({ entry }),
+            listBacklog: async () => ({ entries: [entry], total: 1 }),
+            processBacklog: async () => processResponse,
+        });
+        // Step 1: Add entry
+        const addTool = createAddToBacklogTool(client);
+        const addResult = await addTool({
+            content: 'Users report competitor app Calm added sleep stories',
+            product_slug: 'my-meditation-app',
+            source: 'research-agent',
+            domain_hint: 'product-research',
+            tags: ['competitor', 'feature'],
+        });
+        expect(calls.addBacklogEntry).toHaveLength(1);
+        expect(calls.addBacklogEntry[0]).toEqual({
+            content: 'Users report competitor app Calm added sleep stories',
+            product_slug: 'my-meditation-app',
+            source: 'research-agent',
+            domain_hint: 'product-research',
+            tags: ['competitor', 'feature'],
+        });
+        expect(addResult.entry.id).toBe('entry-1');
+        expect(addResult.entry.status).toBe('pending');
+        // Step 2: List entries — verify pending entry appears
+        const listTool = createListBacklogTool(client);
+        const listResult = await listTool({
+            product_slug: 'my-meditation-app',
+            status: 'pending',
+        });
+        expect(calls.listBacklog).toHaveLength(1);
+        expect(calls.listBacklog[0].product_slug).toBe('my-meditation-app');
+        expect(calls.listBacklog[0].status).toBe('pending');
+        expect(listResult.entries).toHaveLength(1);
+        expect(listResult.total).toBe(1);
+        // Step 3: Process — verify changes applied
+        const processTool = createProcessBacklogTool(client);
+        const processResult = await processTool({
+            product_slug: 'my-meditation-app',
+            dry_run: false,
+        });
+        expect(calls.processBacklog).toHaveLength(1);
+        expect(calls.processBacklog[0].dry_run).toBe(false);
+        expect(processResult.applied).toBe(1);
+        expect(processResult.errors).toHaveLength(0);
+        expect(processResult.details[0].status).toBe('applied');
+        expect(processResult.details[0].applied_changes).toEqual([
+            { filepath: 'docs/research/competitors.md', action: 'md_append', product_slug: 'my-meditation-app' },
+        ]);
+    });
+    it('adds a global entry and processes with routing', async () => {
+        const globalEntry = makeEntry({
+            id: 'global-1',
+            content: 'App Store review mentions slow load times on iPhone 12',
+            source: 'review-monitor',
+        });
+        const processResponse = {
+            routed: 1,
+            processed: 1,
+            applied: 0,
+            rejected: 0,
+            partial: 1,
+            errors: [],
+            details: [{
+                    id: 'global-1',
+                    status: 'partial',
+                    result_summary: 'medium confidence — needs review',
+                    applied_changes: [{ filepath: 'docs/app-store/feedback.md', action: 'md_append', product_slug: 'my-app' }],
+                    rejection_reason: null,
+                }],
+        };
+        const { client, calls } = createTrackedClient({
+            addBacklogEntry: async () => ({ entry: globalEntry }),
+            processBacklog: async () => processResponse,
+        });
+        // Add global entry (no product_slug)
+        const addTool = createAddToBacklogTool(client);
+        const addResult = await addTool({
+            content: 'App Store review mentions slow load times on iPhone 12',
+            source: 'review-monitor',
+        });
+        expect(addResult.entry.product_slug).toBeNull();
+        // Process all (triggers routing + processing)
+        const processTool = createProcessBacklogTool(client);
+        const processResult = await processTool({ dry_run: true });
+        expect(calls.processBacklog[0].product_slug).toBeUndefined();
+        expect(calls.processBacklog[0].dry_run).toBe(true);
+        expect(processResult.routed).toBe(1);
+        expect(processResult.details[0].status).toBe('partial');
+    });
+    it('dry_run defaults to true and previews without applying', async () => {
+        const processResponse = {
+            routed: 0,
+            processed: 2,
+            applied: 0,
+            rejected: 0,
+            partial: 0,
+            errors: [],
+            details: [
+                { id: 'e1', status: 'pending', result_summary: '[DRY RUN] high confidence: fits brand config', applied_changes: [{ filepath: 'brand-config.json', action: 'json_patch', product_slug: 'my-app' }], rejection_reason: null },
+                { id: 'e2', status: 'pending', result_summary: '[DRY RUN] medium confidence: could be competitor data', applied_changes: [{ filepath: 'docs/research/competitors.md', action: 'md_append', product_slug: 'my-app' }], rejection_reason: null },
+            ],
+        };
+        const { client, calls } = createTrackedClient({
+            processBacklog: async () => processResponse,
+        });
+        const processTool = createProcessBacklogTool(client);
+        // No dry_run passed — should default to true via Zod schema
+        const parsed = processBacklogSchema.parse({ product_slug: 'my-app' });
+        expect(parsed.dry_run).toBe(true);
+        const result = await processTool({ product_slug: 'my-app', dry_run: true });
+        expect(calls.processBacklog[0].dry_run).toBe(true);
+        expect(result.applied).toBe(0);
+        expect(result.details).toHaveLength(2);
+        expect(result.details[0].result_summary).toContain('[DRY RUN]');
+    });
+});

package/dist/tools/folders.d.ts

@@ -6,6 +6,7 @@ export declare const manageFoldersSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     allowed_domains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    allowed_emails: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     report_slugs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     report_slug: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
@@ -14,6 +15,7 @@ export declare const manageFoldersSchema: z.ZodObject<{
     slug?: string | undefined;
     description?: string | undefined;
     allowed_domains?: string[] | undefined;
+    allowed_emails?: string[] | undefined;
     report_slugs?: string[] | undefined;
     report_slug?: string | undefined;
 }, {
@@ -22,6 +24,7 @@ export declare const manageFoldersSchema: z.ZodObject<{
     slug?: string | undefined;
     description?: string | undefined;
     allowed_domains?: string[] | undefined;
+    allowed_emails?: string[] | undefined;
     report_slugs?: string[] | undefined;
     report_slug?: string | undefined;
 }>;

package/dist/tools/folders.js

@@ -5,7 +5,8 @@ export const manageFoldersSchema = z.object({
     slug: z.string().optional().describe('Folder slug (required for get, update, delete, add_reports, remove_report)'),
     name: z.string().optional().describe('Folder name (required for create)'),
     description: z.string().optional().describe('Folder description'),
-    allowed_domains: z.array(z.string()).optional().describe('Email domains that can access this folder (required for create)'),
+    allowed_domains: z.array(z.string()).optional().describe('Email domains that can access this folder'),
+    allowed_emails: z.array(z.string()).optional().describe('Individual email addresses that can access this folder'),
     report_slugs: z.array(z.string()).optional().describe('Report slugs to add (for add_reports action)'),
     report_slug: z.string().optional().describe('Report slug to remove (for remove_report action)'),
 });
@@ -19,14 +20,17 @@ export function createManageFoldersTool(client) {
             case 'create': {
                 if (!input.name)
                     throw new Error('name is required for create');
-                if (!input.allowed_domains || input.allowed_domains.length === 0) {
-                    throw new Error('allowed_domains is required for create');
+                const domains = input.allowed_domains ?? [];
+                const emails = input.allowed_emails ?? [];
+                if (domains.length === 0 && emails.length === 0) {
+                    throw new Error('at least one of allowed_domains or allowed_emails is required for create');
                 }
                 return client.createFolder({
                     name: input.name,
                     slug: input.slug,
                     description: input.description,
-                    allowed_domains: input.allowed_domains,
+                    allowed_domains: domains.length > 0 ? domains : undefined,
+                    allowed_emails: emails.length > 0 ? emails : undefined,
                 });
             }
             case 'get': {
@@ -41,6 +45,7 @@ export function createManageFoldersTool(client) {
                     name: input.name,
                     description: input.description,
                     allowed_domains: input.allowed_domains,
+                    allowed_emails: input.allowed_emails,
                 });
             }
             case 'delete': {

package/dist/tools/products.d.ts

@@ -0,0 +1,241 @@
+import { z } from 'zod';
+import type { ApiClient } from '../api-client.js';
+export declare const listProductsSchema: z.ZodObject<{
+    search: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    search?: string | undefined;
+}, {
+    search?: string | undefined;
+}>;
+export declare const getProductSchema: z.ZodObject<{
+    slug: z.ZodString;
+    domain: z.ZodOptional<z.ZodEnum<["product-research", "brand", "copy", "advertising", "app-store"]>>;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    domain?: "product-research" | "brand" | "copy" | "advertising" | "app-store" | undefined;
+}, {
+    slug: string;
+    domain?: "product-research" | "brand" | "copy" | "advertising" | "app-store" | undefined;
+}>;
+export declare const readProductFileSchema: z.ZodObject<{
+    slug: z.ZodString;
+    filepath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    filepath: string;
+}, {
+    slug: string;
+    filepath: string;
+}>;
+export declare const updateProductKnowledgeSchema: z.ZodObject<{
+    slug: z.ZodString;
+    filepath: z.ZodString;
+    content: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    updated_by: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    content: Record<string, unknown>;
+    filepath: string;
+    updated_by?: string | undefined;
+}, {
+    slug: string;
+    content: Record<string, unknown>;
+    filepath: string;
+    updated_by?: string | undefined;
+}>;
+export declare const uploadProductFilesSchema: z.ZodObject<{
+    slug: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+        content_type: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        content: string;
+        content_type?: string | undefined;
+    }, {
+        path: string;
+        content: string;
+        content_type?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    files: {
+        path: string;
+        content: string;
+        content_type?: string | undefined;
+    }[];
+}, {
+    slug: string;
+    files: {
+        path: string;
+        content: string;
+        content_type?: string | undefined;
+    }[];
+}>;
+export declare const pullProductFilesSchema: z.ZodObject<{
+    slug: z.ZodString;
+    output_dir: z.ZodString;
+    files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    include_knowledge: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    output_dir: string;
+    files?: string[] | undefined;
+    include_knowledge?: boolean | undefined;
+}, {
+    slug: string;
+    output_dir: string;
+    files?: string[] | undefined;
+    include_knowledge?: boolean | undefined;
+}>;
+export declare const getProductIndexSchema: z.ZodObject<{
+    slug: z.ZodString;
+    domain: z.ZodOptional<z.ZodEnum<["product-research", "brand", "copy", "advertising", "app-store"]>>;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    domain?: "product-research" | "brand" | "copy" | "advertising" | "app-store" | undefined;
+}, {
+    slug: string;
+    domain?: "product-research" | "brand" | "copy" | "advertising" | "app-store" | undefined;
+}>;
+export declare const getProductHealthSchema: z.ZodObject<{
+    slug: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    slug?: string | undefined;
+}, {
+    slug?: string | undefined;
+}>;
+export declare const createProductSchema: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    slug?: string | undefined;
+    description?: string | undefined;
+}, {
+    name: string;
+    slug?: string | undefined;
+    description?: string | undefined;
+}>;
+export declare const deleteProductSchema: z.ZodObject<{
+    slug: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+}, {
+    slug: string;
+}>;
+export declare const deleteProductFileSchema: z.ZodObject<{
+    slug: z.ZodString;
+    filepath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    slug: string;
+    filepath: string;
+}, {
+    slug: string;
+    filepath: string;
+}>;
+export declare function createListProductsTool(client: ApiClient): (input: z.infer<typeof listProductsSchema>) => Promise<{
+    products: Array<{
+        id: string;
+        slug: string;
+        name: string;
+        description: string | null;
+        created_at: string;
+        updated_at: string;
+    }>;
+    total: number;
+}>;
+export declare function createGetProductTool(client: ApiClient): (input: z.infer<typeof getProductSchema>) => Promise<{
+    product: {
+        id: string;
+        slug: string;
+        name: string;
+        description: string | null;
+        created_at: string;
+        updated_at: string;
+    };
+    knowledge: Record<string, unknown>;
+    doc_files: Array<{
+        path: string;
+        size: number;
+        domain: string;
+    }>;
+    binary_files: Array<{
+        path: string;
+        size: number;
+        content_type: string;
+        domain: string;
+    }>;
+}>;
+export declare function createReadProductFileTool(client: ApiClient): (input: z.infer<typeof readProductFileSchema>) => Promise<{
+    path: string;
+    content: unknown;
+    content_type: string;
+    size?: number;
+}>;
+export declare function createUpdateProductKnowledgeTool(client: ApiClient): (input: z.infer<typeof updateProductKnowledgeSchema>) => Promise<{
+    success: boolean;
+    path: string;
+    merged?: unknown;
+}>;
+export declare function createUploadProductFilesTool(client: ApiClient): (input: z.infer<typeof uploadProductFilesSchema>) => Promise<{
+    success: boolean;
+    uploaded: string[];
+}>;
+export declare function createPullProductFilesTool(client: ApiClient): (input: z.infer<typeof pullProductFilesSchema>) => Promise<{
+    files_pulled: number;
+    output_dir: string;
+    files: {
+        path: string;
+        size: number;
+    }[];
+}>;
+export declare function createGetProductIndexTool(client: ApiClient): (input: z.infer<typeof getProductIndexSchema>) => Promise<{
+    product_slug: string;
+    updated_at: string;
+    files: Array<{
+        path: string;
+        title: string;
+        summary: string;
+        sections: string[];
+        domain: string;
+        content_type: string;
+        size: number;
+        updated_at: string;
+    }>;
+}>;
+export declare function createGetProductHealthTool(client: ApiClient): (input: z.infer<typeof getProductHealthSchema>) => Promise<{
+    slug: string;
+    name: string;
+    overall_score: number;
+    files: Record<string, unknown>;
+    recommendations: string[];
+} | {
+    products: Array<{
+        slug: string;
+        name: string;
+        overall_score: number;
+        files: Record<string, {
+            score: number;
+            missing_required: string[];
+        }>;
+    }>;
+}>;
+export declare function createCreateProductTool(client: ApiClient): (input: z.infer<typeof createProductSchema>) => Promise<{
+    product: {
+        id: string;
+        slug: string;
+        name: string;
+        description: string | null;
+        created_at: string;
+        updated_at: string;
+    };
+}>;
+export declare function createDeleteProductTool(client: ApiClient): (input: z.infer<typeof deleteProductSchema>) => Promise<{
+    success: boolean;
+}>;
+export declare function createDeleteProductFileTool(client: ApiClient): (input: z.infer<typeof deleteProductFileSchema>) => Promise<{
+    success: boolean;
+}>;