44reports-mcp 1.1.0 → 1.2.0

package/dist/api-client.d.ts

@@ -56,6 +56,22 @@ export interface Folder {
     created_at: string;
     updated_at: string;
 }
+export interface BacklogEntry {
+    id: string;
+    product_slug: string | null;
+    content: string;
+    source: string | null;
+    source_context: string | null;
+    domain_hint: string | null;
+    tags: string | null;
+    status: string;
+    result_summary: string | null;
+    applied_changes: string | null;
+    rejection_reason: string | null;
+    processed_at: string | null;
+    created_at: string;
+    updated_at: string;
+}
 export declare class ApiClient {
     private readonly config;
     constructor(config: Config);
@@ -120,17 +136,22 @@ export declare class ApiClient {
     removeReportFromFolder(folderSlug: string, reportSlug: string): Promise<{
         success: boolean;
     }>;
-    listProducts(): Promise<{
+    listProducts(options?: {
+        search?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
         products: Array<{
             id: string;
             slug: string;
             name: string;
             description: string | null;
-            json_file_count: number;
-            binary_file_count: number;
+            created_at: string;
+            updated_at: string;
         }>;
+        total: number;
     }>;
-    getProduct(slug: string): Promise<{
+    getProduct(slug: string, domain?: string): Promise<{
         product: {
             id: string;
             slug: string;
@@ -140,10 +161,16 @@ export declare class ApiClient {
             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;
         }>;
     }>;
     getProductFile(slug: string, filepath: string): Promise<{
@@ -168,4 +195,88 @@ export declare class ApiClient {
         success: boolean;
         uploaded: string[];
     }>;
+    getProductHealth(slug: string): Promise<{
+        slug: string;
+        name: string;
+        overall_score: number;
+        files: Record<string, unknown>;
+        recommendations: string[];
+    }>;
+    getAllProductsHealth(): Promise<{
+        products: Array<{
+            slug: string;
+            name: string;
+            overall_score: number;
+            files: Record<string, {
+                score: number;
+                missing_required: string[];
+            }>;
+        }>;
+    }>;
+    createProduct(data: {
+        name: string;
+        slug?: string;
+        description?: string;
+    }): Promise<{
+        product: {
+            id: string;
+            slug: string;
+            name: string;
+            description: string | null;
+            created_at: string;
+            updated_at: string;
+        };
+    }>;
+    deleteProduct(slug: string): Promise<{
+        success: boolean;
+    }>;
+    deleteProductFile(slug: string, filepath: string): Promise<{
+        success: boolean;
+    }>;
+    getProductIndex(slug: string, domain?: string): 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;
+        }>;
+    }>;
+    pullProductFiles(slug: string, options?: {
+        files?: string[];
+        include_knowledge?: boolean;
+    }): Promise<{
+        files: PulledFile[];
+    }>;
+    addBacklogEntry(data: {
+        content: string;
+        product_slug?: string;
+        source?: string;
+        source_context?: string;
+        domain_hint?: string;
+        tags?: string[];
+    }): Promise<{
+        entry: BacklogEntry;
+    }>;
+    listBacklog(options?: {
+        product_slug?: string;
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        entries: BacklogEntry[];
+        total: number;
+    }>;
+    deleteBacklogEntry(id: string): Promise<{
+        success: boolean;
+    }>;
+    processBacklog(options?: {
+        product_slug?: string;
+        dry_run?: boolean;
+    }): Promise<unknown>;
 }

package/dist/api-client.js

@@ -91,11 +91,19 @@ export class ApiClient {
         });
     }
     // --- Product Knowledge ---
-    async listProducts() {
-        return this.request('/api/products');
+    async listProducts(options) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(options ?? {})) {
+            if (value !== undefined) {
+                params.set(key, String(value));
+            }
+        }
+        const query = params.toString();
+        return this.request(`/api/products${query ? `?${query}` : ''}`);
     }
-    async getProduct(slug) {
-        return this.request(`/api/products/${slug}`);
+    async getProduct(slug, domain) {
+        const query = domain ? `?domain=${encodeURIComponent(domain)}` : '';
+        return this.request(`/api/products/${slug}${query}`);
     }
     async getProductFile(slug, filepath) {
         return this.request(`/api/products/${slug}/files/${filepath}`);
@@ -112,4 +120,69 @@ export class ApiClient {
             body: JSON.stringify({ files }),
         });
     }
+    async getProductHealth(slug) {
+        return this.request(`/api/products/${slug}/health`);
+    }
+    async getAllProductsHealth() {
+        return this.request('/api/products/health');
+    }
+    async createProduct(data) {
+        return this.request('/api/products', {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+    }
+    async deleteProduct(slug) {
+        return this.request(`/api/products/${slug}`, {
+            method: 'DELETE',
+        });
+    }
+    async deleteProductFile(slug, filepath) {
+        return this.request(`/api/products/${slug}/files/${filepath}`, {
+            method: 'DELETE',
+        });
+    }
+    async getProductIndex(slug, domain) {
+        const query = domain ? `?domain=${encodeURIComponent(domain)}` : '';
+        return this.request(`/api/products/${slug}/index${query}`);
+    }
+    async pullProductFiles(slug, options) {
+        return this.request(`/api/products/${slug}/pull`, {
+            method: 'POST',
+            body: JSON.stringify(options ?? {}),
+        });
+    }
+    // --- Agent Backlog ---
+    async addBacklogEntry(data) {
+        return this.request('/api/backlog', {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+    }
+    async listBacklog(options) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(options ?? {})) {
+            if (value !== undefined) {
+                params.set(key, String(value));
+            }
+        }
+        const query = params.toString();
+        return this.request(`/api/backlog${query ? `?${query}` : ''}`);
+    }
+    async deleteBacklogEntry(id) {
+        return this.request(`/api/backlog/${id}`, {
+            method: 'DELETE',
+        });
+    }
+    async processBacklog(options) {
+        const params = new URLSearchParams();
+        if (options?.product_slug)
+            params.set('product_slug', options.product_slug);
+        if (options?.dry_run !== undefined)
+            params.set('dry_run', String(options.dry_run));
+        const query = params.toString();
+        return this.request(`/api/backlog/process${query ? `?${query}` : ''}`, {
+            method: 'POST',
+        });
+    }
 }

package/dist/index.js

@@ -8,7 +8,8 @@ import { deployReportSchema, updateReportSchema, createDeployTool, createUpdateT
 import { listReportsSchema, getReportSchema, deleteReportSchema, createListTool, createGetTool, createDeleteTool, } from './tools/reports.js';
 import { pullContextSchema, createPullTool, } from './tools/pull.js';
 import { manageFoldersSchema, createManageFoldersTool, } from './tools/folders.js';
-import { listProductsSchema, getProductSchema, readProductFileSchema, updateProductKnowledgeSchema, uploadProductFilesSchema, pullProductFilesSchema, createListProductsTool, createGetProductTool, createReadProductFileTool, createUpdateProductKnowledgeTool, createUploadProductFilesTool, createPullProductFilesTool, } from './tools/products.js';
+import { listProductsSchema, getProductSchema, readProductFileSchema, updateProductKnowledgeSchema, uploadProductFilesSchema, pullProductFilesSchema, createProductSchema, deleteProductSchema, deleteProductFileSchema, getProductHealthSchema, getProductIndexSchema, createListProductsTool, createGetProductTool, createReadProductFileTool, createUpdateProductKnowledgeTool, createUploadProductFilesTool, createPullProductFilesTool, createGetProductHealthTool, createGetProductIndexTool, createCreateProductTool, createDeleteProductTool, createDeleteProductFileTool, } from './tools/products.js';
+import { addToBacklogSchema, listBacklogSchema, processBacklogSchema, createAddToBacklogTool, createListBacklogTool, createProcessBacklogTool, } from './tools/backlog.js';
 const config = loadConfig();
 const client = new ApiClient(config);
 function prop(type, description, extra = {}) {
@@ -139,18 +140,24 @@ const toolDefinitions = [
     },
     {
         name: 'list_products',
-        description: 'List all 44pixels products in the knowledge repository (Cue, Deep, Pixi, Clara, Vivi, Wordcast, etc.) with their knowledge file inventory. Call this first to discover available products and which knowledge files are already populated.',
-        inputSchema: { type: 'object', properties: {} },
+        description: 'List all products in the knowledge repository with their knowledge file inventory. Call this first to discover available products and which knowledge files are already populated.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                search: prop('string', 'Search term to filter products by name or description'),
+            },
+        },
         schema: listProductsSchema,
         handler: createListProductsTool(client),
     },
     {
         name: 'get_product',
-        description: 'Get a product\'s complete knowledge — returns ALL JSON knowledge files (product.json, brand.json, copy.json, meta-ads.json, cpps.json) fully parsed, plus a listing of binary assets. This is the primary tool to read before generating creative work, writing ad copy, or configuring campaigns — it gives you brand voice, product positioning, hooks, and ad account IDs in one call.',
+        description: 'Get a product\'s complete knowledge — returns all JSON config files (meta-ads.json, cpps.json, brand-config.json) fully parsed, plus listings of markdown docs and binary assets. This is the primary tool to read before generating creative work, writing ad copy, or configuring campaigns. For narrative knowledge (brand voice, product positioning, research), use get_product_index to find the right markdown doc, then read_product_file to get its content.\n\nOptionally filter by domain to get only files relevant to a specific area: product-research, brand, copy, advertising, or app-store. Note: JSON config files are domain-scoped (meta-ads.json → advertising, brand-config.json → brand, cpps.json → app-store), so domains without a config file will return an empty knowledge object.',
         inputSchema: {
             type: 'object',
             properties: {
                 slug: prop('string', 'Product slug'),
+                domain: prop('string', 'Filter files by domain', { enum: ['product-research', 'brand', 'copy', 'advertising', 'app-store'] }),
             },
             required: ['slug'],
         },
@@ -159,12 +166,12 @@ const toolDefinitions = [
     },
     {
         name: 'read_product_file',
-        description: 'Read a single file from a product by path. Use get_product to read all knowledge files at once (more efficient). Use read_product_file only when you need one specific file — especially useful for binary files (logos, PDFs) returned as base64 data URIs.',
+        description: 'Read a single file from a product by path. Use get_product to read all knowledge files at once (more efficient). Use read_product_file only when you need one specific file — works for markdown docs, JSON configs, and binary files (logos, PDFs returned as base64 data URIs).\n\nTypical workflow: get_product_index → find the file you need → read_product_file.',
         inputSchema: {
             type: 'object',
             properties: {
                 slug: prop('string', 'Product slug'),
-                filepath: prop('string', 'File path within the product (e.g., "meta-ads.json", "brand-assets/logo.png")'),
+                filepath: prop('string', 'File path within the product (e.g., "docs/research/user-research.md", "meta-ads.json", "brand-assets/logo.png")'),
             },
             required: ['slug', 'filepath'],
         },
@@ -173,12 +180,12 @@ const toolDefinitions = [
     },
     {
         name: 'update_product_knowledge',
-        description: 'Write or update product knowledge using deep merge-patch — only the keys you send are changed, all other data is preserved. This is the canonical way to store brand knowledge: ALWAYS use this (not deploy_context) for product profiles, brand guidelines, copy, ad accounts, and CPP config.\n\nKnowledge files per product:\n- product.json — core info, target audience, pain points, selling points, competitors\n- brand.json — colors, typography, voice/tone, brand archetypes, power words\n- copy.json — taglines, hooks, CTAs, approved/banned claims\n- meta-ads.json — Meta account IDs, pixels, creative test config\n- cpps.json — CPP motivations and custom product page config\n\nAlways pass updated_by with your agent name so humans can see who wrote each update.',
+        description: 'Write or update product knowledge JSON config using deep merge-patch — only the keys you send are changed, all other data is preserved. Use this for programmatic config files that agents plug into API calls.\n\nConfig files per product:\n- meta-ads.json — Meta account IDs, pixels, creative test config\n- cpps.json — CPP motivations and custom product page config\n- brand-config.json — brand color palette hex values, font families\n\nFor narrative knowledge (product info, brand voice, copy, research), create or update Markdown docs using upload_product_files instead. Place docs in the correct domain prefix:\n- docs/research/ — user research, competitive analysis, hypotheses, GTM strategy, roadmap\n- docs/brand/ — brand voice, positioning\n- docs/copy/ — copy guidelines, messaging\n- docs/advertising/ — campaign briefs, ad copy\n- docs/app-store/ — store listing copy, metadata\n\nAlways pass updated_by with your agent name so humans can see who wrote each update.',
         inputSchema: {
             type: 'object',
             properties: {
                 slug: prop('string', 'Product slug'),
-                filepath: prop('string', 'Knowledge file to update (e.g., "meta-ads.json", "brand.json", "product.json", "copy.json", "cpps.json")'),
+                filepath: prop('string', 'Config file to update (e.g., "meta-ads.json", "cpps.json", "brand-config.json")'),
                 content: prop('object', 'JSON object to deep merge-patch into the knowledge file. Use null values to delete keys.'),
                 updated_by: prop('string', 'Agent name or ID writing the update (optional)'),
             },
@@ -189,7 +196,7 @@ const toolDefinitions = [
     },
     {
         name: 'upload_product_files',
-        description: 'Upload binary assets to a product — logos, brand books, App Store screenshots, ad creatives, videos. Files are organized into sections:\n- brand-assets/ — logos, brand book PDFs, color swatches\n- store-listings/ — App Store / Play Store screenshots and preview videos\n- assets/ — ad creatives, icons, campaign videos',
+        description: 'Upload files to a product — binary assets or Markdown knowledge docs. Files are organized into sections:\n\nBinary assets:\n- brand-assets/ — logos, brand book PDFs, color swatches\n- store-listings/ — App Store / Play Store screenshots and preview videos\n- assets/ — ad creatives, icons, campaign videos\n\nMarkdown docs (use these prefixes for knowledge documents):\n- docs/research/ — user research, competitive analysis, hypotheses, GTM strategy, roadmap\n- docs/brand/ — brand voice, positioning\n- docs/copy/ — copy guidelines, messaging\n- docs/advertising/ — campaign briefs, ad copy\n- docs/app-store/ — store listing copy, metadata',
         inputSchema: {
             type: 'object',
             properties: {
@@ -213,19 +220,134 @@ const toolDefinitions = [
     },
     {
         name: 'pull_product_files',
-        description: 'Download binary files from a product to a local directory.',
+        description: 'Download files from a product to a local directory. By default pulls binary assets (logos, screenshots, videos). Set include_knowledge to also pull JSON config files. To pull markdown docs, specify their paths in the files array (e.g., ["docs/research/user-research.md"]).',
         inputSchema: {
             type: 'object',
             properties: {
                 slug: prop('string', 'Product slug'),
                 output_dir: prop('string', 'Local directory to write files to. Will be created if needed.'),
                 files: prop('array', 'Specific file paths to pull. If omitted, all binary files are pulled.', { items: { type: 'string' } }),
+                include_knowledge: prop('boolean', 'Include knowledge JSON files in addition to binary files. Default: false.'),
             },
             required: ['slug', 'output_dir'],
         },
         schema: pullProductFilesSchema,
         handler: createPullProductFilesTool(client),
     },
+    {
+        name: 'get_product_health',
+        description: 'Get knowledge completeness scores for a product or all products. Scores both JSON config files (field-level completeness) and expected markdown docs (presence check). Shows missing required/optional fields and missing docs, with an overall health score (0-100). Use to identify gaps before generating content.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Product slug. If omitted, returns health summary for all products.'),
+            },
+        },
+        schema: getProductHealthSchema,
+        handler: createGetProductHealthTool(client),
+    },
+    {
+        name: 'get_product_index',
+        description: 'Get a lightweight file index for a product — a table of contents listing every file with its title, summary, sections, domain, and size. Use this FIRST to discover what knowledge is available before pulling specific files. Much faster than get_product since it returns metadata only, not file contents.\n\nTypical workflow: list_products → get_product_index → read_product_file (for specific docs) or get_product (for all JSON configs at once).\n\nOptionally filter by domain to see only files in a specific area: product-research, brand, copy, advertising, or app-store.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Product slug'),
+                domain: prop('string', 'Filter index entries by domain', { enum: ['product-research', 'brand', 'copy', 'advertising', 'app-store'] }),
+            },
+            required: ['slug'],
+        },
+        schema: getProductIndexSchema,
+        handler: createGetProductIndexTool(client),
+    },
+    {
+        name: 'create_product',
+        description: 'Create a new product in the knowledge repository. The slug is auto-generated from the name if not provided. Use this before uploading knowledge files or assets.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: prop('string', 'Product name'),
+                slug: prop('string', 'URL-friendly slug (auto-generated from name if not provided)'),
+                description: prop('string', 'Product description'),
+            },
+            required: ['name'],
+        },
+        schema: createProductSchema,
+        handler: createCreateProductTool(client),
+    },
+    {
+        name: 'delete_product',
+        description: 'Delete a product and all its associated knowledge files and assets from the repository. This action is irreversible.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Product slug to delete'),
+            },
+            required: ['slug'],
+        },
+        schema: deleteProductSchema,
+        handler: createDeleteProductTool(client),
+    },
+    {
+        name: 'delete_product_file',
+        description: 'Delete a single file from a product. Use for removing outdated assets or resetting a knowledge file.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Product slug'),
+                filepath: prop('string', 'File path within the product to delete (e.g., "brand-assets/old-logo.png")'),
+            },
+            required: ['slug', 'filepath'],
+        },
+        schema: deleteProductFileSchema,
+        handler: createDeleteProductFileTool(client),
+    },
+    {
+        name: 'add_to_backlog',
+        description: 'Add an unstructured observation to the agent backlog for later processing. Low-friction way for any agent to contribute signals — competitor insights, user feedback, research findings, or any data that should eventually enrich product knowledge. Only content is required; everything else is optional.\n\nIf you know which product this relates to, pass product_slug. Otherwise, omit it — the backlog processor will auto-route it to the right product (or reject it as noise).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: prop('string', 'The observation or data (100-2000 chars typical). Be specific — include sources, numbers, quotes when available.'),
+                product_slug: prop('string', 'Product slug if known. Omit for global entries that will be auto-routed.'),
+                source: prop('string', 'Your agent name or ID (e.g., "research-agent", "competitor-monitor")'),
+                source_context: prop('string', 'Context slug this observation came from, if applicable'),
+                domain_hint: prop('string', 'Knowledge domain hint', { enum: ['product-research', 'brand', 'copy', 'advertising', 'app-store'] }),
+                tags: prop('array', 'Free-form tags for categorization', { items: { type: 'string' } }),
+            },
+            required: ['content'],
+        },
+        schema: addToBacklogSchema,
+        handler: createAddToBacklogTool(client),
+    },
+    {
+        name: 'list_backlog',
+        description: 'List backlog entries — inspect the queue of pending observations waiting to be processed into product knowledge. Filter by product, status, or both.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                product_slug: prop('string', 'Filter by product slug. Use "global" for unrouted entries without a product.'),
+                status: prop('string', 'Filter by status', { enum: ['pending', 'processing', 'applied', 'rejected', 'partial'] }),
+                limit: prop('number', 'Maximum number of results (default: 50)'),
+                offset: prop('number', 'Offset for pagination'),
+            },
+        },
+        schema: listBacklogSchema,
+        handler: createListBacklogTool(client),
+    },
+    {
+        name: 'process_backlog',
+        description: 'Trigger backlog processing — routes global entries to products, then uses LLM to triage and apply changes to product knowledge (JSON configs and markdown docs). Defaults to dry_run=true for safety.\n\nProcessing stages:\n1. Route: Global entries (no product_slug) are matched to products or rejected\n2. Process: Per-product entries are classified and generate JSON patches or markdown operations\n3. Apply: Only high-confidence changes are auto-applied; medium/low are marked as partial with suggestions',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                product_slug: prop('string', 'Process entries for a specific product only. Omit to process all products including global routing.'),
+                dry_run: prop('boolean', 'Preview changes without applying them. Default: true.'),
+            },
+        },
+        schema: processBacklogSchema,
+        handler: createProcessBacklogTool(client),
+    },
 ];
 const toolHandlers = Object.fromEntries(toolDefinitions.map((t) => [t.name, { schema: t.schema, handler: t.handler }]));
 const server = new Server({ name: '44reports', version: '1.0.0' }, { capabilities: { tools: {} } });

package/dist/tools/backlog.d.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import type { ApiClient } from '../api-client.js';
+export declare const addToBacklogSchema: z.ZodObject<{
+    content: z.ZodString;
+    product_slug: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    source_context: z.ZodOptional<z.ZodString>;
+    domain_hint: z.ZodOptional<z.ZodEnum<["product-research", "brand", "copy", "advertising", "app-store"]>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    product_slug?: string | undefined;
+    tags?: string[] | undefined;
+    source?: string | undefined;
+    source_context?: string | undefined;
+    domain_hint?: "product-research" | "brand" | "copy" | "advertising" | "app-store" | undefined;
+}, {
+    content: string;
+    product_slug?: string | undefined;
+    tags?: string[] | undefined;
+    source?: string | undefined;
+    source_context?: string | undefined;
+    domain_hint?: "product-research" | "brand" | "copy" | "advertising" | "app-store" | undefined;
+}>;
+export declare const listBacklogSchema: z.ZodObject<{
+    product_slug: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["pending", "processing", "applied", "rejected", "partial"]>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status?: "pending" | "processing" | "applied" | "rejected" | "partial" | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    product_slug?: string | undefined;
+}, {
+    status?: "pending" | "processing" | "applied" | "rejected" | "partial" | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    product_slug?: string | undefined;
+}>;
+export declare const processBacklogSchema: z.ZodObject<{
+    product_slug: z.ZodOptional<z.ZodString>;
+    dry_run: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    dry_run: boolean;
+    product_slug?: string | undefined;
+}, {
+    product_slug?: string | undefined;
+    dry_run?: boolean | undefined;
+}>;
+export declare function createAddToBacklogTool(client: ApiClient): (input: z.infer<typeof addToBacklogSchema>) => Promise<{
+    entry: import("../api-client.js").BacklogEntry;
+}>;
+export declare function createListBacklogTool(client: ApiClient): (input: z.infer<typeof listBacklogSchema>) => Promise<{
+    entries: import("../api-client.js").BacklogEntry[];
+    total: number;
+}>;
+export declare function createProcessBacklogTool(client: ApiClient): (input: z.infer<typeof processBacklogSchema>) => Promise<unknown>;

package/dist/tools/backlog.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+const DOMAIN_VALUES = ['product-research', 'brand', 'copy', 'advertising', 'app-store'];
+const STATUS_VALUES = ['pending', 'processing', 'applied', 'rejected', 'partial'];
+// --- Schemas ---
+export const addToBacklogSchema = z.object({
+    content: z.string().describe('The observation or data to add to the backlog'),
+    product_slug: z.string().optional().describe('Product slug — omit for global entries that will be auto-routed'),
+    source: z.string().optional().describe('Agent name or ID submitting this entry'),
+    source_context: z.string().optional().describe('Context slug this observation came from'),
+    domain_hint: z.enum(DOMAIN_VALUES).optional().describe('Knowledge domain hint'),
+    tags: z.array(z.string()).optional().describe('Free-form tags for categorization'),
+});
+export const listBacklogSchema = z.object({
+    product_slug: z.string().optional().describe('Filter by product slug. Use "global" for unrouted entries.'),
+    status: z.enum(STATUS_VALUES).optional().describe('Filter by status'),
+    limit: z.number().optional().describe('Maximum number of results (default: 50)'),
+    offset: z.number().optional().describe('Offset for pagination'),
+});
+export const processBacklogSchema = z.object({
+    product_slug: z.string().optional().describe('Process entries for a specific product. Omit to process all including global routing.'),
+    dry_run: z.boolean().optional().default(true).describe('Preview changes without applying. Default: true.'),
+});
+// --- Tool factories ---
+export function createAddToBacklogTool(client) {
+    return async (input) => {
+        return client.addBacklogEntry(input);
+    };
+}
+export function createListBacklogTool(client) {
+    return async (input) => {
+        return client.listBacklog({
+            product_slug: input.product_slug,
+            status: input.status,
+            limit: input.limit,
+            offset: input.offset,
+        });
+    };
+}
+export function createProcessBacklogTool(client) {
+    return async (input) => {
+        return client.processBacklog({
+            product_slug: input.product_slug,
+            dry_run: input.dry_run,
+        });
+    };
+}

package/dist/tools/backlog.test.d.ts

@@ -0,0 +1 @@
+export {};

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/products.d.ts

@@ -1,12 +1,21 @@
 import { z } from 'zod';
 import type { ApiClient } from '../api-client.js';
-export declare const listProductsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+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;
@@ -68,24 +77,75 @@ 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<{
+export declare function createListProductsTool(client: ApiClient): (input: z.infer<typeof listProductsSchema>) => Promise<{
     products: Array<{
         id: string;
         slug: string;
         name: string;
         description: string | null;
-        json_file_count: number;
-        binary_file_count: number;
+        created_at: string;
+        updated_at: string;
     }>;
+    total: number;
 }>;
 export declare function createGetProductTool(client: ApiClient): (input: z.infer<typeof getProductSchema>) => Promise<{
     product: {
@@ -97,10 +157,16 @@ export declare function createGetProductTool(client: ApiClient): (input: z.infer
         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<{
@@ -119,10 +185,6 @@ export declare function createUploadProductFilesTool(client: ApiClient): (input:
     uploaded: string[];
 }>;
 export declare function createPullProductFilesTool(client: ApiClient): (input: z.infer<typeof pullProductFilesSchema>) => Promise<{
-    product: {
-        name: string;
-        slug: string;
-    };
     files_pulled: number;
     output_dir: string;
     files: {
@@ -130,3 +192,50 @@ export declare function createPullProductFilesTool(client: ApiClient): (input: z
         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;
+}>;

package/dist/tools/products.js

@@ -1,25 +1,30 @@
 import { z } from 'zod';
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import { getMimeType } from './deploy.js';
 // --- Schemas ---
-export const listProductsSchema = z.object({});
+export const listProductsSchema = z.object({
+    search: z.string().optional().describe('Search term to filter products by name or description'),
+});
+const DOMAIN_VALUES = ['product-research', 'brand', 'copy', 'advertising', 'app-store'];
 export const getProductSchema = z.object({
     slug: z.string().describe('Product slug'),
+    domain: z.enum(DOMAIN_VALUES).optional().describe('Filter files by domain'),
 });
 export const readProductFileSchema = z.object({
     slug: z.string().describe('Product slug'),
-    filepath: z.string().describe('File path within the product (e.g., "meta-ads.json", "brand-assets/logo.png")'),
+    filepath: z.string().describe('File path within the product (e.g., "docs/research/user-research.md", "meta-ads.json", "brand-assets/logo.png")'),
 });
 export const updateProductKnowledgeSchema = z.object({
     slug: z.string().describe('Product slug'),
-    filepath: z.string().describe('Knowledge file to update (e.g., "meta-ads.json", "brand.json", "product.json", "copy.json", "cpps.json")'),
+    filepath: z.string().describe('Config file to update (e.g., "meta-ads.json", "cpps.json", "brand-config.json")'),
     content: z.record(z.unknown()).describe('JSON object to deep merge-patch into the knowledge file. Use null values to delete keys.'),
     updated_by: z.string().optional().describe('Agent name or ID writing the update'),
 });
 export const uploadProductFilesSchema = z.object({
     slug: z.string().describe('Product slug'),
     files: z.array(z.object({
-        path: z.string().describe('File path within the product (e.g., "brand-assets/logo.png")'),
+        path: z.string().describe('File path within the product (e.g., "docs/research/user-research.md", "brand-assets/logo.png")'),
         content: z.string().describe('File content as text or base64 data URI (e.g., "data:image/png;base64,...")'),
         content_type: z.string().optional().describe('MIME type (auto-detected if not provided)'),
     })).describe('Files to upload'),
@@ -27,18 +32,38 @@ export const uploadProductFilesSchema = z.object({
 export const pullProductFilesSchema = z.object({
     slug: z.string().describe('Product slug'),
     output_dir: z.string().describe('Local directory to write files to. Will be created if needed.'),
-    files: z.array(z.string()).optional().describe('Specific file paths to pull. If omitted, all binary files are pulled.'),
+    files: z.array(z.string()).optional().describe('Specific file paths to pull (e.g., ["docs/research/roadmap.md", "brand-assets/logo.png"]). If omitted, all binary files are pulled.'),
+    include_knowledge: z.boolean().optional().describe('Include knowledge JSON files in addition to binary files. Default: false.'),
+});
+export const getProductIndexSchema = z.object({
+    slug: z.string().describe('Product slug'),
+    domain: z.enum(DOMAIN_VALUES).optional().describe('Filter index entries by domain'),
+});
+export const getProductHealthSchema = z.object({
+    slug: z.string().optional().describe('Product slug. If omitted, returns health for all products.'),
+});
+export const createProductSchema = z.object({
+    name: z.string().describe('Product name'),
+    slug: z.string().optional().describe('URL-friendly slug (auto-generated from name if not provided)'),
+    description: z.string().optional().describe('Product description'),
+});
+export const deleteProductSchema = z.object({
+    slug: z.string().describe('Product slug'),
+});
+export const deleteProductFileSchema = z.object({
+    slug: z.string().describe('Product slug'),
+    filepath: z.string().describe('File path within the product to delete (e.g., "docs/copy/old-brief.md", "brand-assets/old-logo.png")'),
 });
 // --- Tool factories ---
 export function createListProductsTool(client) {
-    return async (_input) => {
-        const result = await client.listProducts();
+    return async (input) => {
+        const result = await client.listProducts(input.search ? { search: input.search } : undefined);
         return result;
     };
 }
 export function createGetProductTool(client) {
     return async (input) => {
-        const result = await client.getProduct(input.slug);
+        const result = await client.getProduct(input.slug, input.domain);
         return result;
     };
 }
@@ -64,13 +89,7 @@ export function createUploadProductFilesTool(client) {
             if (content.startsWith('/') || content.startsWith('./') || content.startsWith('../')) {
                 const filePath = path.resolve(content);
                 const buffer = await fs.readFile(filePath);
-                const ext = path.extname(filePath).slice(1).toLowerCase();
-                const mimeTypes = {
-                    png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg',
-                    gif: 'image/gif', webp: 'image/webp', pdf: 'application/pdf',
-                    mp4: 'video/mp4', mov: 'video/quicktime', svg: 'image/svg+xml',
-                };
-                const mimeType = file.content_type || mimeTypes[ext] || 'application/octet-stream';
+                const mimeType = file.content_type || getMimeType(filePath);
                 const base64 = buffer.toString('base64');
                 content = `data:${mimeType};base64,${base64}`;
             }
@@ -82,43 +101,69 @@ export function createUploadProductFilesTool(client) {
 }
 export function createPullProductFilesTool(client) {
     return async (input) => {
-        const { product, binary_files } = await client.getProduct(input.slug);
-        let filesToPull = binary_files.map((f) => f.path);
-        if (input.files && input.files.length > 0) {
-            filesToPull = input.files;
-        }
-        if (filesToPull.length === 0) {
-            return { product: { name: product.name, slug: product.slug }, files_pulled: 0, output_dir: input.output_dir, files: [] };
+        const { files } = await client.pullProductFiles(input.slug, {
+            files: input.files,
+            include_knowledge: input.include_knowledge,
+        });
+        if (files.length === 0) {
+            return { files_pulled: 0, output_dir: input.output_dir, files: [] };
         }
         const outputDir = path.resolve(input.output_dir);
         await fs.mkdir(outputDir, { recursive: true });
         const written = [];
         const resolvedOutputDir = path.resolve(outputDir);
-        for (const filePath of filesToPull) {
-            const result = await client.getProductFile(input.slug, filePath);
-            const destPath = path.join(outputDir, filePath);
+        for (const file of files) {
+            const destPath = path.join(outputDir, file.path);
             const resolvedDestPath = path.resolve(destPath);
             if (!resolvedDestPath.startsWith(resolvedOutputDir + path.sep) && resolvedDestPath !== resolvedOutputDir) {
-                throw new Error(`Unsafe file path rejected: ${filePath}`);
+                throw new Error(`Unsafe file path rejected: ${file.path}`);
             }
             await fs.mkdir(path.dirname(destPath), { recursive: true });
-            const content = result.content;
+            const content = file.content;
             if (content.startsWith('data:')) {
                 const commaIndex = content.indexOf(',');
+                if (commaIndex === -1)
+                    throw new Error(`Invalid data URI format for file: ${file.path}`);
                 const base64Data = content.slice(commaIndex + 1);
                 await fs.writeFile(destPath, Buffer.from(base64Data, 'base64'));
-                written.push({ path: filePath, size: result.size || 0 });
             }
             else {
                 await fs.writeFile(destPath, content, 'utf-8');
-                written.push({ path: filePath, size: content.length });
             }
+            written.push({ path: file.path, size: file.size });
         }
         return {
-            product: { name: product.name, slug: product.slug },
             files_pulled: written.length,
             output_dir: outputDir,
             files: written,
         };
     };
 }
+export function createGetProductIndexTool(client) {
+    return async (input) => {
+        return client.getProductIndex(input.slug, input.domain);
+    };
+}
+export function createGetProductHealthTool(client) {
+    return async (input) => {
+        if (input.slug) {
+            return client.getProductHealth(input.slug);
+        }
+        return client.getAllProductsHealth();
+    };
+}
+export function createCreateProductTool(client) {
+    return async (input) => {
+        return client.createProduct(input);
+    };
+}
+export function createDeleteProductTool(client) {
+    return async (input) => {
+        return client.deleteProduct(input.slug);
+    };
+}
+export function createDeleteProductFileTool(client) {
+    return async (input) => {
+        return client.deleteProductFile(input.slug, input.filepath);
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "44reports-mcp",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "type": "module",
   "description": "MCP server for deploying and pulling context files (code, docs, data) to/from 44reports",
   "main": "dist/index.js",