fraim 2.0.100

package/dist/src/local-mcp-server/usage-collector.js

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsageCollector = void 0;
+const mongodb_1 = require("mongodb");
+const axios_1 = __importDefault(require("axios"));
+// A placeholder ObjectId used when the real API key ID is not yet known.
+// The server will override this with the correct ID from the authenticated API key.
+const PLACEHOLDER_API_KEY_ID = new mongodb_1.ObjectId('000000000000000000000000');
+/**
+ * Usage event collector for local MCP proxy
+ * Collects usage events and batches them for upload
+ */
+class UsageCollector {
+    constructor() {
+        this.events = [];
+        this.apiKeyId = null;
+    }
+    static resolveMentoringJobName(args) {
+        if (!args || typeof args !== 'object') {
+            return 'unknown';
+        }
+        if (typeof args.jobName === 'string' && args.jobName.trim().length > 0) {
+            return args.jobName.trim();
+        }
+        // Backward compatibility for older callers and docs that still use workflowType.
+        if (typeof args.workflowType === 'string' && args.workflowType.trim().length > 0) {
+            return args.workflowType.trim();
+        }
+        if (typeof args.job === 'string' && args.job.trim().length > 0) {
+            return args.job.trim();
+        }
+        return 'unknown';
+    }
+    /**
+     * Set the API key ID for this session
+     */
+    setApiKeyId(apiKeyId) {
+        this.apiKeyId = apiKeyId;
+    }
+    /**
+     * Collect MCP tool call event
+     */
+    collectMCPCall(toolName, args, sessionId, success = true) {
+        const parsed = this.parseMCPCall(toolName, args);
+        if (!parsed) {
+            const errorMsg = `[UsageCollector] 🚫 Tool not tracked: ${toolName}`;
+            console.error(errorMsg);
+            // Also log to stderr for better visibility in main logs
+            process.stderr.write(errorMsg + '\n');
+            return;
+        }
+        // Extract useful args for analytics
+        const analyticsArgs = this.extractAnalyticsArgs(toolName, args);
+        const event = {
+            type: parsed.type,
+            name: parsed.name,
+            // Use set apiKeyId if available, otherwise a placeholder.
+            // The server will override this with the correct value from the auth token.
+            apiKeyId: this.apiKeyId || PLACEHOLDER_API_KEY_ID,
+            sessionId,
+            success,
+            args: analyticsArgs
+        };
+        this.events.push(event);
+        const successMsg = `[UsageCollector] ✅ Collected event: ${parsed.type}/${parsed.name} (session: ${sessionId}, queue: ${this.events.length})`;
+        console.error(successMsg);
+        // Also log to stderr for better visibility in main logs
+        process.stderr.write(successMsg + '\n');
+    }
+    /**
+     * Collect usage event directly (for backward compatibility with tests)
+     */
+    collectEvent(type, name, sessionId, success = true, args) {
+        const event = {
+            type,
+            name,
+            // Use set apiKeyId if available, otherwise a placeholder.
+            // The server will override this with the correct value from the auth token.
+            apiKeyId: this.apiKeyId || PLACEHOLDER_API_KEY_ID,
+            sessionId,
+            success,
+            args
+        };
+        this.events.push(event);
+    }
+    /**
+     * Extract useful arguments for analytics tracking
+     */
+    extractAnalyticsArgs(toolName, args) {
+        const analyticsArgs = {};
+        switch (toolName) {
+            case 'seekMentoring':
+                if (args.currentPhase)
+                    analyticsArgs.currentPhase = args.currentPhase;
+                if (args.status)
+                    analyticsArgs.status = args.status;
+                const mentoringJobName = UsageCollector.resolveMentoringJobName(args);
+                if (mentoringJobName !== 'unknown')
+                    analyticsArgs.jobName = mentoringJobName;
+                if (args.issueNumber)
+                    analyticsArgs.issueNumber = args.issueNumber;
+                break;
+            case 'get_fraim_file':
+                if (args.path) {
+                    analyticsArgs.path = args.path;
+                    // Extract category and subcategory from path
+                    const pathParts = args.path.split('/');
+                    if (pathParts.length >= 2) {
+                        analyticsArgs.category = pathParts[1]; // skills, jobs, rules, workflows
+                        if (pathParts.length >= 3) {
+                            analyticsArgs.subcategory = pathParts[2]; // engineering, product-building, etc.
+                        }
+                    }
+                }
+                break;
+            case 'get_fraim_job':
+                if (args.job)
+                    analyticsArgs.job = args.job;
+                break;
+            case 'fraim_connect':
+                if (args.agent?.name)
+                    analyticsArgs.agentName = args.agent.name;
+                if (args.agent?.model)
+                    analyticsArgs.agentModel = args.agent.model;
+                break;
+            default:
+                // For other tools, don't collect args to avoid PII
+                return undefined;
+        }
+        return Object.keys(analyticsArgs).length > 0 ? analyticsArgs : undefined;
+    }
+    /**
+     * Parse MCP tool call to extract usage analytics info
+     */
+    parseMCPCall(toolName, args) {
+        switch (toolName) {
+            case 'get_fraim_job':
+                return { type: 'job', name: args.job || 'unknown' };
+            case 'get_fraim_file':
+                if (args.path) {
+                    return UsageCollector.parseComponentName(args.path);
+                }
+                return null;
+            case 'seekMentoring':
+                return { type: 'mentoring', name: UsageCollector.resolveMentoringJobName(args) };
+            case 'list_fraim_jobs':
+                return { type: 'job', name: 'list' };
+            case 'fraim_connect':
+                return { type: 'session', name: 'connect' };
+            default:
+                return null;
+        }
+    }
+    /**
+     * Get collected events for upload and clear the queue
+     */
+    getEventsForUpload() {
+        const eventsToUpload = [...this.events];
+        this.events = [];
+        return eventsToUpload;
+    }
+    /**
+     * Get current event count
+     */
+    getEventCount() {
+        return this.events.length;
+    }
+    /**
+     * Flush events to the remote server via API
+     */
+    async flush(remoteUrl, apiKey) {
+        if (this.events.length === 0) {
+            const noEventsMsg = `[UsageCollector] 📊 No events to flush`;
+            console.error(noEventsMsg);
+            process.stderr.write(noEventsMsg + '\n');
+            return;
+        }
+        const events = [...this.events];
+        this.events = [];
+        const flushMsg = `[UsageCollector] 📤 Flushing ${events.length} events to ${remoteUrl}/api/analytics/events`;
+        console.error(flushMsg);
+        process.stderr.write(flushMsg + '\n');
+        try {
+            const response = await axios_1.default.post(`${remoteUrl}/api/analytics/events`, {
+                events,
+                apiKey
+            }, {
+                timeout: 5000,
+                headers: {
+                    'x-api-key': apiKey,
+                    'Content-Type': 'application/json'
+                }
+            });
+            const successMsg = `[UsageCollector] ✅ Successfully flushed ${events.length} events (HTTP ${response.status})`;
+            console.error(successMsg);
+            process.stderr.write(successMsg + '\n');
+            // Success - events are already cleared from the queue
+        }
+        catch (error) {
+            const status = error.response?.status;
+            const message = error.response?.data?.error || error.message;
+            const errorMsg = `[UsageCollector] ❌ Failed to flush usage events (HTTP ${status}): ${message}`;
+            console.error(errorMsg);
+            process.stderr.write(errorMsg + '\n');
+            // Log additional debug info
+            if (error.response?.data) {
+                const debugMsg = `[UsageCollector] 🔍 Response data: ${JSON.stringify(error.response.data)}`;
+                console.error(debugMsg);
+                process.stderr.write(debugMsg + '\n');
+            }
+            // Put events back at the beginning of the queue for next try
+            this.events = [...events, ...this.events];
+            // Re-throw the error so the main server can log it too
+            throw error;
+        }
+    }
+    /**
+     * Shutdown the collector
+     */
+    shutdown() {
+        this.events = [];
+    }
+    /**
+     * Parse component name from file path
+     */
+    static parseComponentName(path) {
+        // Normalize path to have leading slash for consistent regex matching
+        const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+        // Match skills files: /skills/category/skill-name.md
+        if (normalizedPath.includes('/skills/')) {
+            const skillMatch = normalizedPath.match(/\/skills\/[^/]+\/([^/]+)\.md$/);
+            if (skillMatch) {
+                return { type: 'skill', name: skillMatch[1] };
+            }
+        }
+        // Match job files: /jobs/category/subcategory/job-name.md
+        if (normalizedPath.includes('/jobs/')) {
+            const jobMatch = normalizedPath.match(/\/jobs\/[^/]+\/[^/]+\/([^/]+)\.md$/);
+            if (jobMatch) {
+                return { type: 'job', name: jobMatch[1] };
+            }
+        }
+        // Match rule files: /rules/category/rule-name.md
+        if (normalizedPath.includes('/rules/')) {
+            const ruleMatch = normalizedPath.match(/\/rules\/[^/]+\/([^/]+)\.md$/);
+            if (ruleMatch) {
+                return { type: 'rule', name: ruleMatch[1] };
+            }
+        }
+        // For other paths that don't match the expected patterns, 
+        // we'll classify them as 'job' type with a generic name
+        // This ensures we track usage even for non-standard paths
+        const fileName = normalizedPath.split('/').pop();
+        if (fileName && fileName.endsWith('.md')) {
+            const baseName = fileName.replace(/\.md$/, '');
+            return { type: 'job', name: baseName };
+        }
+        return null;
+    }
+}
+exports.UsageCollector = UsageCollector;

package/index.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+/**
+ * FRAIM Framework - Smart Entry Point
+ * This file handles both production (dist/) and development (src/) environments.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+/**
+ * Runs the CLI using either the compiled JS or the source TS via tsx
+ */
+function runCLI() {
+    const distPath = path.join(__dirname, 'dist', 'src', 'cli', 'fraim.js');
+    const srcPath = path.join(__dirname, 'src', 'cli', 'fraim.ts');
+
+    // 1. Check if we have a compiled version (Production / CI)
+    if (fs.existsSync(distPath)) {
+        require(distPath);
+        return;
+    }
+
+    // 2. Explicitly fail in production if dist/ is missing
+    if (process.env.NODE_ENV === 'production') {
+        console.error('❌ FRAIM Error: Production build (dist/) not found.');
+        console.error('In production environments, you must run the compiled version.');
+        console.error(`Expected: ${distPath}`);
+        process.exit(1);
+    }
+
+    // 3. Fallback to source version using tsx (Development)
+    if (fs.existsSync(srcPath)) {
+        // We use spawnSync to run tsx so we don't have to require it in memory
+        // if it's not needed, and it handles the process arguments correctly.
+        // 
+        // IMPORTANT FIX: Directory names with spaces and dashes (e.g., "FRAIM - Issue 166")
+        // cause argument parsing issues on Windows when shell: true is used.
+        // Without quoting, a path like "C:\...\FRAIM - Issue 166\src\cli\fraim.ts" gets
+        // split into multiple arguments, with the dash interpreted as a command flag,
+        // resulting in "error: unknown command '-'".
+        // 
+        // Solution: On Windows with shell: true, quote paths containing spaces.
+        // On Unix with shell: false, pass the path unquoted (spawnSync handles it correctly).
+        const isWindows = process.platform === 'win32';
+
+        // On Windows with shell, quote paths with spaces to prevent shell misinterpretation
+        // On Unix without shell, pass path as-is (spawnSync handles spaces correctly)
+        const processedSrcPath = (isWindows && srcPath.includes(' '))
+            ? `"${srcPath}"`
+            : srcPath;
+
+        const result = spawnSync(
+            'npx',
+            ['tsx', processedSrcPath, ...process.argv.slice(2)],
+            {
+                stdio: 'inherit',
+                shell: isWindows, // Windows needs shell for npx, Unix doesn't
+                windowsHide: true
+            }
+        );
+        process.exit(result.status || 0);
+    }
+
+    console.error('❌ FRAIM Error: Could not find CLI entry point.');
+    console.error('Expected one of:');
+    console.error(` - ${distPath}`);
+    console.error(` - ${srcPath}`);
+    process.exit(1);
+}
+
+// Global programmatic exports
+module.exports = {
+    FRAIM_INFO: {
+        name: 'FRAIM',
+        version: '2.0.98',
+        repository: 'https://github.com/mathursrus/FRAIM'
+    }
+};
+
+// If this file is run directly (via npx or global link), run the CLI
+if (require.main === module) {
+    runCLI();
+}

package/package.json

@@ -0,0 +1,139 @@
+{
+  "name": "fraim",
+  "version": "2.0.100",
+  "description": "FRAIM CLI - Framework for Rigor-based AI Management (alias for fraim-framework)",
+  "main": "index.js",
+  "bin": {
+    "fraim": "./index.js",
+    "fraim-framework": "./index.js"
+  },
+  "scripts": {
+    "dev": "tsx --watch src/fraim-mcp-server.ts > server.log 2>&1",
+    "dev:prod": "npm run build && node dist/src/fraim-mcp-server.js > server.log 2>&1",
+    "build": "tsc && npm run build:stubs && npm run build:fraim-brain && node scripts/copy-registry.js && node -e \"require('fs').copyFileSync('src/core/types.ts', 'registry/templates/manager/fraim-config-schema.ts')\" && npm run validate:registry && npm run validate:fraim-pro-assets && tsx scripts/validate-purity.ts",
+    "build:stubs": "tsx scripts/build-stub-registry.ts",
+    "build:fraim-brain": "node scripts/generate-fraim-brain.js",
+    "test-all": "npm run test && npm run test:isolated && npm run test:ui",
+    "test": "node scripts/test-with-server.js",
+    "test:isolated": "npx tsx --test --test-reporter=spec tests/isolated/test-*.ts",
+    "test:smoke": "node scripts/test-with-server.js tests/test-*.ts --tags=smoke",
+    "test:stripe": "node scripts/test-with-server.js tests/test-stripe-payment-complete.ts",
+    "test:stripe:ui": "playwright test tests/ui/test-payment-ui.spec.ts",
+    "test:ui": "playwright test",
+    "test:ui:headed": "playwright test --headed",
+    "start:fraim": "tsx src/fraim-mcp-server.ts",
+    "dev:fraim": "tsx --watch src/fraim-mcp-server.ts",
+    "serve:website": "node fraim-pro/serve.js",
+    "watch:fraimlogs": "tsx scripts/watch-fraim-logs.ts > prodlogs.log 2>&1",
+    "manage-keys": "tsx scripts/fraim/manage-keys.ts",
+    "partner-discounts": "tsx scripts/fraim/manage-partner-discounts.ts",
+    "fix-key": "tsx scripts/fraim/fix-expired-key.ts",
+    "setup-stripe-webhook": "tsx scripts/fraim/setup-stripe-webhook.ts",
+    "view-signups": "tsx scripts/view-signups.ts",
+    "fraim:init": "npm run build && node index.js init",
+    "fraim:sync": "node index.js sync --local",
+    "postinstall": "fraim sync --skip-updates || echo 'FRAIM setup skipped.'",
+    "prepublishOnly": "npm run build",
+    "release": "npm version patch && npm run publish-both",
+    "publish-both": "node scripts/publish-both.js",
+    "publish-fraim-only": "node scripts/publish-fraim.js",
+    "publish-both-manual": "node scripts/publish-both.js",
+    "validate:registry": "tsx scripts/verify-registry-paths.ts && npm run validate:jobs && npm run validate:skills && npm run validate:registry-references && npm run validate:platform-agnostic && npm run validate:template-namespaces && npm run validate:config-fallbacks && npm run validate:bootstrap-config-coverage && npm run validate:provider-action-mappings && npm run validate:fidelity && npm run validate:config-tokens && npm run validate:brain-mapping && npm run validate:template-syntax",
+    "validate:registry-references": "tsx scripts/validate-registry-references.ts",
+    "validate:brain-mapping": "tsx scripts/validate-brain-mapping.ts",
+    "validate:fraim-pro-assets": "tsx scripts/validate-fraim-pro-assets.ts",
+    "validate:jobs": "tsx scripts/validate-jobs.ts",
+    "validate:platform-agnostic": "tsx scripts/validate-platform-agnostic.ts",
+    "validate:skills": "tsx scripts/validate-skills.ts",
+    "validate:template-namespaces": "tsx scripts/validate-template-namespaces.ts",
+    "validate:config-fallbacks": "tsx scripts/validate-config-fallbacks.ts",
+    "validate:bootstrap-config-coverage": "tsx scripts/validate-bootstrap-config-coverage.ts",
+    "validate:provider-action-mappings": "tsx scripts/validate-provider-action-mappings.ts",
+    "validate:fidelity": "tsx scripts/validate-fidelity.ts",
+    "validate:config-tokens": "tsx scripts/validate-config-tokens.ts",
+    "validate:template-syntax": "tsx scripts/validate-template-syntax.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mathursrus/FRAIM.git"
+  },
+  "keywords": [
+    "fraim",
+    "ai-management",
+    "ai-coordination",
+    "ai-agents",
+    "multi-agent",
+    "github",
+    "automation",
+    "gitops",
+    "cursor",
+    "claude",
+    "windsurf",
+    "rigor",
+    "enterprise",
+    "framework",
+    "ai-managers"
+  ],
+  "author": "Sid Mathur <sid.mathur@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mathursrus/FRAIM/issues"
+  },
+  "homepage": "https://github.com/mathursrus/FRAIM#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.58.2",
+    "@types/adm-zip": "^0.5.7",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/node": "^20.0.0",
+    "@types/prompts": "^2.4.9",
+    "@types/semver": "^7.7.1",
+    "fast-glob": "^3.3.3",
+    "html-to-docx": "^1.8.0",
+    "markdown-it": "^14.1.1",
+    "markdown-it-highlightjs": "^4.3.0",
+    "playwright": "^1.58.2",
+    "pptxgenjs": "^4.0.1",
+    "puppeteer": "^24.36.1",
+    "qrcode": "^1.5.4",
+    "sharp": "^0.34.5",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "dist/src/local-mcp-server/",
+    "dist/src/cli/",
+    "dist/src/core/",
+    "bin/fraim.js",
+    "bin/fraim-mcp.js",
+    "index.js",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "adm-zip": "^0.5.16",
+    "axios": "^1.7.0",
+    "chalk": "4.1.2",
+    "commander": "^14.0.2",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.7",
+    "express": "^5.2.1",
+    "mongodb": "^7.0.0",
+    "node-edge-tts": "^1.2.10",
+    "prompts": "^2.4.2",
+    "resend": "^6.9.3",
+    "semver": "^7.7.4",
+    "stripe": "^20.3.1",
+    "toml": "^3.0.0",
+    "tree-kill": "^1.2.2",
+    "xml2js": "^0.6.2"
+  }
+}