filemayor 3.6.0 → 4.0.5

package/core/intent-interpreter.js

@@ -10,16 +10,187 @@
 'use strict';
 
 const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const { getLicenseInfo } = require('./license');
 
 const GEMINI_MODEL = 'gemini-2.0-flash';
 const GEMINI_ENDPOINT = `https://generativelanguage.googleapis.com/v1beta/models/${GEMINI_MODEL}:generateContent`;
+const PROXY_URL = process.env.FM_AI_PROXY_URL || 'https://filemayor.com/api/ai/plan';
+
+// Stable device ID based on hostname + username (no PII sent to server)
+function getDeviceId() {
+    const raw = `${os.hostname()}-${os.userInfo().username}`;
+    return crypto.createHash('sha256').update(raw).digest('hex').slice(0, 32);
+}
+
+function getSystemPrompt() {
+    return `You are FileMayor's AI planning engine. Given a description of a messy folder and a user's intent, output a structured JSON plan.
+
+Respond ONLY with valid JSON in this exact format:
+{
+  "summary": "one sentence describing what the plan does",
+  "operations": [
+    { "action": "move", "from": "relative/path/file.ext", "to": "Category/file.ext" },
+    { "action": "rename", "from": "old_name.ext", "to": "new_name.ext" },
+    { "action": "delete", "path": "junk_file.tmp" }
+  ],
+  "warnings": ["optional list of things user should review"]
+}`;
+}
+
+async function callAi(prompt, context) {
+    const provider = process.env.FM_AI_PROVIDER || 'proxy';
+    const apiKey = process.env.FM_AI_API_KEY || process.env.GEMINI_API_KEY || '';
+
+    if (provider === 'gemini' && apiKey) {
+        return callGeminiDirect(prompt, context, apiKey);
+    }
+    if (provider === 'openai' && apiKey) {
+        return callOpenAI(prompt, context, apiKey);
+    }
+    if (provider === 'anthropic' && apiKey) {
+        return callAnthropic(prompt, context, apiKey);
+    }
+    if (provider === 'ollama') {
+        return callOllama(prompt, context);
+    }
+    // Default: use the FileMayor proxy
+    return callProxy(prompt, context);
+}
+
+async function callProxy(prompt, context) {
+    const licenseInfo = getLicenseInfo();
+    const token = licenseInfo?.key || getDeviceId();
+
+    const res = await fetch(PROXY_URL, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+        },
+        body: JSON.stringify({
+            prompt,
+            context,
+            deviceId: getDeviceId(),
+        }),
+    });
+
+    if (res.status === 429) {
+        const body = await res.json();
+        throw new Error(body.error || 'Monthly AI limit reached. Upgrade to Pro for unlimited access.');
+    }
+
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        throw new Error(body.error || `AI service error (${res.status})`);
+    }
+
+    const body = await res.json();
+    if (body.error && !body.plan) throw new Error(body.error);
+    return body.plan;
+}
+
+async function callGeminiDirect(prompt, context, apiKey) {
+    const systemPrompt = getSystemPrompt();
+
+    const body = {
+        contents: [{
+            parts: [{
+                text: `${systemPrompt}\n\nUser request: ${prompt}\n\nFolder context: ${JSON.stringify(context)}`
+            }]
+        }],
+        generationConfig: {
+            temperature: 0.1,
+            topP: 0.95,
+            maxOutputTokens: 2048,
+            responseMimeType: 'application/json',
+        },
+    };
+
+    const url = `${GEMINI_ENDPOINT}?key=${apiKey}`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+        const err = await response.text();
+        throw new Error(`Gemini API Error: ${response.status} - ${err}`);
+    }
+
+    const data = await response.json();
+    const rawText = data?.candidates?.[0]?.content?.parts?.[0]?.text || '';
+    const jsonMatch = rawText.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) throw new Error('No JSON found in AI response');
+    return JSON.parse(jsonMatch[0]);
+}
+
+async function callOpenAI(prompt, context, apiKey) {
+    const systemPrompt = getSystemPrompt();
+    const res = await fetch('https://api.openai.com/v1/chat/completions', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+        body: JSON.stringify({
+            model: 'gpt-4o',
+            response_format: { type: 'json_object' },
+            messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: `User request: ${prompt}\n\nFolder context: ${JSON.stringify(context)}` }
+            ]
+        })
+    });
+    if (!res.ok) throw new Error(`OpenAI error: ${res.status}`);
+    const data = await res.json();
+    return JSON.parse(data.choices[0].message.content);
+}
+
+async function callAnthropic(prompt, context, apiKey) {
+    const systemPrompt = getSystemPrompt();
+    const res = await fetch('https://api.anthropic.com/v1/messages', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01'
+        },
+        body: JSON.stringify({
+            model: 'claude-3-5-haiku-20241022',
+            max_tokens: 1024,
+            system: systemPrompt,
+            messages: [{ role: 'user', content: `User request: ${prompt}\n\nFolder context: ${JSON.stringify(context)}` }]
+        })
+    });
+    if (!res.ok) throw new Error(`Anthropic error: ${res.status}`);
+    const data = await res.json();
+    const text = data.content[0].text;
+    return JSON.parse(text.replace(/```json\n?|\n?```/g, '').trim());
+}
+
+async function callOllama(prompt, context) {
+    const model = process.env.FM_OLLAMA_MODEL || 'llama3';
+    const baseUrl = process.env.FM_OLLAMA_BASE_URL || 'http://localhost:11434';
+    const systemPrompt = getSystemPrompt();
+    const res = await fetch(`${baseUrl}/api/generate`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            model,
+            prompt: `${systemPrompt}\n\nUser request: ${prompt}\n\nFolder context: ${JSON.stringify(context)}`,
+            stream: false,
+            format: 'json'
+        })
+    });
+    if (!res.ok) throw new Error(`Ollama error: ${res.status}`);
+    const data = await res.json();
+    return JSON.parse(data.response);
+}
 
 class IntentInterpreter {
     constructor(apiKey) {
         this.apiKey = apiKey || process.env.GEMINI_API_KEY;
-        if (!this.apiKey) {
-            console.warn('[WARN] GEMINI_API_KEY not found. AI features will be disabled.');
-        }
+        // No warning needed — proxy works without a key
     }
 
     /**
@@ -30,15 +201,42 @@ class IntentInterpreter {
      * @returns {Promise<Object>} The Curative Plan
      */
     async interpret(userPrompt, clusters, context = {}) {
-        if (!this.apiKey) {
-            throw new Error('API Key missing. Cannot interpret intent.');
+        const telemetry = this._summarizeFiles(clusters);
+        const promptWithTelemetry = `USER INTENT: "${userPrompt}"\n\nFILES:\n${JSON.stringify(telemetry, null, 2)}`;
+
+        const proxyContext = {
+            ...context,
+            fileCount: Object.values(clusters).reduce((sum, cat) => sum + (cat.count || 0), 0),
+            categories: Object.keys(clusters),
+            topFiles: Object.values(clusters).flatMap(cat => (cat.samples || []).slice(0, 3).map(s => s.name)),
+        };
+
+        // If apiKey was explicitly passed (non-env), inject it temporarily for the direct path
+        const prevKey = process.env.GEMINI_API_KEY;
+        const prevAiKey = process.env.FM_AI_API_KEY;
+        if (this.apiKey && this.apiKey !== prevKey) {
+            process.env.FM_AI_API_KEY = this.apiKey;
         }
 
-        const telemetry = this._summarizeFiles(clusters);
-        const systemPrompt = this._getSystemPrompt(context);
+        let curativePlan;
+        try {
+            curativePlan = await callAi(promptWithTelemetry, proxyContext);
+        } finally {
+            // Restore original env key if we temporarily set one
+            if (this.apiKey && this.apiKey !== prevKey) {
+                if (prevAiKey === undefined) {
+                    delete process.env.FM_AI_API_KEY;
+                } else {
+                    process.env.FM_AI_API_KEY = prevAiKey;
+                }
+            }
+        }
 
-        const response = await this._callGemini(systemPrompt, userPrompt, telemetry);
-        const curativePlan = this._parseResponse(response);
+        // If the proxy returned a raw plan object rather than a full curative plan shape,
+        // wrap it so downstream code always sees { narrative, plan, confidence }
+        if (curativePlan && !curativePlan.plan && !curativePlan.narrative) {
+            curativePlan = { narrative: '', plan: curativePlan, confidence: 80 };
+        }
 
         // [Production Grade] Confidence Gating
         if (curativePlan.confidence < 60) {
@@ -57,7 +255,7 @@ class IntentInterpreter {
      */
     _summarizeFiles(clusters) {
         const summary = {};
-        
+
         for (const cat in clusters) {
             summary[cat] = {
                 count: clusters[cat].count,
@@ -69,63 +267,8 @@ class IntentInterpreter {
                 }))
             };
         }
-        
-        return summary;
-    }
-
-    _getSystemPrompt(context) {
-        return `You are FileMayor v3.2, the "Intuition & Dependency Engine".
-Your goal is to organize files while strictly preserving the integrity of projects and collections.
-
-INPUT:
-1. User Intent: "${context.intent}" (Strategy: "${context.strategy}")
-2. Telemetry: Clustered file metadata including 'ancestry' and 'bundleId'.
-
-GOLDEN RULES:
-- RULE OF ANCESTRY: Respect parent directory names in 'ancestry'. If a file is in /Books/ or a project folder, DO NOT scatter it based on extension alone.
-- ATOMIC BUNDLING: Files sharing a 'bundleId' (like music stems with a project file) MUST stay together.
-- REFINE, DON'T DESTROY: A "Refine" intent means improving structure WITHIN a domain, not extracting files OUT of it. 
-- FORMAT: Return a VALID JSON object. Use absolute paths for source.
-
-OUTPUT SCHEMA:
-{
-  "narrative": "A curative explanation of the structural refinement.",
-  "plan": [
-    { "source": "absolute/path", "destination": "suggested/target", "reason": "Why?" }
-  ],
-  "confidence": 0-100
-}`;
-    }
-
-    async _callGemini(systemPrompt, userPrompt, files) {
-        const body = {
-            contents: [{
-                parts: [{
-                    text: `${systemPrompt}\n\nUSER INTENT: "${userPrompt}"\n\nFILES:\n${JSON.stringify(files, null, 2)}`
-                }]
-            }],
-            generationConfig: {
-                temperature: 0.1, // Even lower for higher determinism
-                topP: 0.95,
-                maxOutputTokens: 2048,
-                responseMimeType: "application/json" // [Production Grade] Force JSON Mode
-            }
-        };
-
-        const url = `${GEMINI_ENDPOINT}?key=${this.apiKey}`;
-        const response = await fetch(url, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(body),
-        });
-
-        if (!response.ok) {
-            const err = await response.text();
-            throw new Error(`Gemini API Error: ${response.status} - ${err}`);
-        }
 
-        const data = await response.json();
-        return data?.candidates?.[0]?.content?.parts?.[0]?.text || '';
+        return summary;
     }
 
     /**