@bonginkan/maria 4.3.31 → 4.3.32

package/dist/cli.cjs

@@ -1704,7 +1704,7 @@ var init_AuthenticationManager = __esm({
           const response = await fetch(`${this.apiBase}/api/user/profile`, {
             headers: {
               "Authorization": `Bearer ${tokens2.accessToken}`,
-              "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.3.31"}`
+              "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.3.32"}`
             }
           });
           if (response.status === 401) {
@@ -2407,7 +2407,7 @@ async function callApi(path64, init3 = {}) {
     "Authorization": `Bearer ${token}`,
     "X-Device-Id": getDeviceId(),
     "X-Session-Id": getSessionId() || "",
-    "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.3.31"}`,
+    "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.3.32"}`,
     "Content-Type": init3.headers?.["Content-Type"] || "application/json"
   });
   const doFetch = async (token) => {
@@ -16121,8 +16121,8 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@bonginkan/maria",
-      version: "4.3.31",
-      description: "\u{1F680} MARIA v4.3.31 - Enterprise AI Development Platform with identity system and character voice implementation. Features 74 production-ready commands with comprehensive fallback implementation, local LLM support, and zero external dependencies. Includes natural language coding, AI safety evaluation, intelligent evolution system, episodic memory with PII masking, and real-time monitoring dashboard. Built with TypeScript AST-powered code generation, OAuth2.0 + PKCE authentication, quantum-resistant cryptography, and enterprise-grade performance.",
+      version: "4.3.32",
+      description: "\u{1F680} MARIA v4.3.32 - Enterprise AI Development Platform with identity system and character voice implementation. Features 74 production-ready commands with comprehensive fallback implementation, local LLM support, and zero external dependencies. Includes natural language coding, AI safety evaluation, intelligent evolution system, episodic memory with PII masking, and real-time monitoring dashboard. Built with TypeScript AST-powered code generation, OAuth2.0 + PKCE authentication, quantum-resistant cryptography, and enterprise-grade performance.",
       keywords: [
         "ai",
         "cli",
@@ -25817,7 +25817,7 @@ var init_about_command = __esm({
       async execute(args2, context2) {
         const output3 = [];
         output3.push("");
-        output3.push(chalk40__default.default.cyan.bold("\u{1F916} About MARIA v4.3.31"));
+        output3.push(chalk40__default.default.cyan.bold("\u{1F916} About MARIA v4.3.32"));
         output3.push(chalk40__default.default.gray("\u2550".repeat(40)));
         output3.push("");
         output3.push(chalk40__default.default.white.bold("MARIA - Minimal API, Maximum Power"));
@@ -57562,16 +57562,7 @@ var init_EvaluationOrchestrator = __esm({
           code: options.code,
           files
         };
-        let result;
-        if (options.llmScoring !== false) {
-          try {
-            result = await this.scoreWithLLM(input3, criteria);
-          } catch {
-            result = await this.engine.evaluate(input3, criteria);
-          }
-        } else {
-          result = await this.engine.evaluate(input3, criteria);
-        }
+        const result = await this.scoreWithLLM(input3, criteria);
         result.files = input3.files || [];
         return { criteriaPath, result };
       }
@@ -57590,7 +57581,7 @@ var init_EvaluationOrchestrator = __esm({
         await fs19.promises.mkdir(dir, { recursive: true });
         const system = [
           "You are an expert evaluation designer.",
-          "Create a JSON criteria file for evaluating the given idea/code/files.",
+          "Create a JSON criteria file for evaluating the given idea/code/files. If a local file path is provided, make sure you read the uploaded file before taking any actions.",
           "Respond ONLY with a single multi-file section in this exact format:",
           `[BEGIN file: ${targetPath}]`,
           "{JSON}",
@@ -57648,12 +57639,22 @@ ${user}`,
         return map;
       }
       extractFirstJsonObject(text) {
-        const fence = /```json\r?\n([\s\S]*?)```/i.exec(text);
-        if (fence) return fence[1];
-        const start = text.indexOf("{");
-        const end = text.lastIndexOf("}");
+        const fenceJson = /```\s*json\s*\r?\n([\s\S]*?)```/i.exec(text);
+        if (fenceJson) return fenceJson[1];
+        const fencePlain = /```\s*\r?\n([\s\S]*?)```/i.exec(text);
+        if (fencePlain) {
+          const body = fencePlain[1];
+          try {
+            JSON.parse(body);
+            return body;
+          } catch {
+          }
+        }
+        const defenced = text.replace(/```[a-zA-Z]*\s*\r?\n([\s\S]*?)```/g, "$1");
+        const start = defenced.indexOf("{");
+        const end = defenced.lastIndexOf("}");
         if (start >= 0 && end > start) {
-          const cand = text.slice(start, end + 1);
+          const cand = defenced.slice(start, end + 1);
           try {
             JSON.parse(cand);
             return cand;
@@ -57664,18 +57665,20 @@ ${user}`,
       }
       async scoreWithLLM(input3, criteria) {
         const criteriaPreview = criteria.items.map((it) => ({ id: it.id, name: it.name, weight: it.weight, rubric: it.rubric })).slice(0, 20);
-        const bundleParts = [];
-        if (input3.idea) bundleParts.push(`Idea:
+        const parts = [];
+        if (input3.idea) parts.push(`Idea:
 ${input3.idea}`);
-        if (input3.code) bundleParts.push(`Code:
+        if (input3.code) parts.push(`Code:
 ${input3.code}`);
-        if (input3.files && input3.files.length) {
-          bundleParts.push(`Files:
-${input3.files.slice(0, 5).map((f3) => `- ${f3.path}`).join("\n")}`);
+        const files = input3.files || [];
+        if (files.length) {
+          parts.push(`Files attached:
+${files.slice(0, 20).map((f3) => `- ${f3.path}`).join("\n")}`);
         }
-        const bundle = bundleParts.join("\n\n");
+        const bundle = parts.join("\n\n");
         const system = [
           "You are an impartial evaluator. Score each criterion between 0 and 1.",
+          "If a local file path is provided, make sure you read the uploaded file before taking any actions.",
           "Return JSON only in the following schema:",
           '{ "totalScore": number (0..1), "details": [{ "id": string, "score": number (0..1), "reason": string }] }',
           "Keep reasons short (<= 120 chars)."
@@ -57685,15 +57688,23 @@ ${input3.files.slice(0, 5).map((f3) => `- ${f3.path}`).join("\n")}`);
           "Input to evaluate:",
           bundle
         ].join("\n\n");
+        (input3.files || []).some((f3) => f3.mime && f3.mime !== "text/plain");
+        const provider = "google";
+        const model = "gemini-2.5-flash";
         const response = await callAPI("/v1/ai-proxy", {
           method: "POST",
           body: {
+            provider,
+            model,
             prompt: `${system}
 
 ---
 
 ${user}`,
-            taskType: "evaluation"
+            taskType: "evaluation",
+            metadata: {
+              attachments: (input3.files || []).map((f3) => this.toAttachmentPayload(f3))
+            }
           }
         });
         const raw = (response?.data?.content || response?.output || "").trim();
@@ -57703,7 +57714,12 @@ ${user}`,
         if (sections.size > 0) {
           jsonText = Array.from(sections.values())[0];
         }
-        const parsed = JSON.parse(jsonText);
+        let parsed;
+        try {
+          parsed = JSON.parse(jsonText);
+        } catch {
+          return { totalScore: 0, details: criteria.items.map((it) => ({ id: it.id, name: it.name, weight: it.weight, score: 0, reason: "" })), passThroughText: raw };
+        }
         const details = criteria.items.map((it) => {
           const found = parsed.details.find((d) => d.id === it.id);
           const score = Math.max(0, Math.min(1, found?.score ?? 0));
@@ -57714,22 +57730,61 @@ ${user}`,
         const totalScore = Number.isFinite(parsed.totalScore) ? Math.max(0, Math.min(1, parsed.totalScore)) : weighted;
         return { totalScore, details };
       }
+      toAttachmentPayload(file) {
+        const ext2 = path10__namespace.default.extname(file.path).toLowerCase();
+        const mime = file.mime || (ext2 === ".pdf" ? "application/pdf" : "text/plain");
+        const b64 = file.binaryBase64 || Buffer.from(file.content || "", "utf8").toString("base64");
+        return { name: path10__namespace.default.basename(file.path), path: file.path, mime, data_base64: b64 };
+      }
       async readFiles(pathsInput) {
         const out = [];
         for (const p of pathsInput) {
-          const abs = path10__namespace.default.isAbsolute(p) ? p : path10__namespace.default.join(this.projectRoot, p);
+          const normalized = p.replace(/^"|"$/g, "").replace(/^'|'$/g, "");
+          const abs = path10__namespace.default.isAbsolute(normalized) ? normalized : path10__namespace.default.join(this.projectRoot, normalized);
           try {
             const stat13 = await fs19.promises.stat(abs);
             if (stat13.isDirectory()) {
               continue;
             }
-            const content = await fs19.promises.readFile(abs, "utf8");
-            out.push({ path: abs, content });
+            const ext2 = path10__namespace.default.extname(abs).toLowerCase();
+            const raw = await fs19.promises.readFile(abs);
+            let content = "";
+            if (/\.pdf$/i.test(abs)) {
+              content = await this.tryExtractPdfText(abs);
+            } else {
+              try {
+                content = raw.toString("utf8");
+              } catch {
+                content = "";
+              }
+            }
+            const mime = ext2 === ".pdf" ? "application/pdf" : "text/plain";
+            const binaryBase64 = raw.toString("base64");
+            out.push({ path: abs, content, binaryBase64, mime });
           } catch {
           }
         }
         return out;
       }
+      async tryExtractPdfText(absPath) {
+        try {
+          const buf = await fs19.promises.readFile(absPath);
+          try {
+            const mod = await import('pdf-parse');
+            const pdfParse = mod?.default || mod;
+            if (typeof pdfParse === "function") {
+              const res = await pdfParse(buf);
+              const text = (res?.text || "").trim();
+              if (text) return text;
+            }
+          } catch {
+          }
+          const kb = Math.round(buf.byteLength / 1024);
+          return `[[PDF ${absPath} (${kb} KB) \u2014 text extraction unavailable in this environment]]`;
+        } catch {
+          return "[[PDF read error]]";
+        }
+      }
     };
   }
 });
@@ -57761,6 +57816,7 @@ async function inferAssessParams(rawText, cwd2) {
     "You extract structured options for an evaluation command.",
     'Return JSON only with keys: { "criteriaPath"?: string, "regenerate"?: boolean, "criteriaOnly"?: boolean, "files"?: string[], "idea"?: string, "code"?: string }.',
     'Prefer concise relative paths for criteria (e.g., "AGI-hackathon-ideathon/evaluation.criteria.json").',
+    'If the text says "do not regenerate" or "DO NOT regenerate", set regenerate=false (override any other hint).',
     "If the text asks to create/save criteria/rubric (without asking for evaluation), set criteriaOnly=true.",
     "If the text mentions saving criteria to a folder, set criteriaPath accordingly and regenerate=true.",
     "If it references files or folders, include them in files[] (relative to cwd).",
@@ -57922,7 +57978,9 @@ var init_evaluate_command = __esm({
         }
         const filesOption = options["file"];
         const filesFromFlags = Array.isArray(filesOption) ? filesOption : filesOption ? [filesOption] : [];
-        const files = Array.from(/* @__PURE__ */ new Set([...inferred.files || [], ...filesFromFlags]));
+        const detectedFromText = Array.from(rawText.match(/[A-Za-z]:\\[^\r\n]+/g) || []).map((s2) => s2.trim().replace(/[\s\.,;\)]*$/, ""));
+        const noRegen = /\bdo\s*not\s*regenerate\b|\bdo\s*not\s*re\s*gen\b|\bdo\s*not\s*re\s*create\b|\bno\s*regen\b|\bDO\s*NOT\s*REGENERATE\b/i.test(rawText);
+        const files = Array.from(/* @__PURE__ */ new Set([...inferred.files || [], ...filesFromFlags, ...detectedFromText]));
         const orchestrator = new EvaluationOrchestrator(root);
         const spinner = new ProcessAnimation();
         spinner.start();
@@ -57935,7 +57993,7 @@ var init_evaluate_command = __esm({
             files,
             idea: options["idea"] || inferred.idea || void 0,
             code: options["code"] || inferred.code || void 0,
-            regenerateCriteria: !!options["regenerate"] || !!options["regen"] || !options["criteria"] || !!inferred.regenerate,
+            regenerateCriteria: noRegen ? false : !!options["regenerate"] || !!options["regen"] || !options["criteria"] || !!inferred.regenerate,
             llmScoring: options["no-llm-scoring"] ? false : true,
             criteriaOnly: !!options["criteria-only"] || !!inferred.criteriaOnly
           });
@@ -57953,29 +58011,34 @@ var init_evaluate_command = __esm({
           "- A one-line overall verdict",
           "- A weighted score (0-100)",
           "- A short bullet breakdown per criterion (name: score/100 - brief reason)",
-          "Be direct and professional."
+          "Be direct and professional.",
+          // Strong guard: attachments are uploaded; do not ask for local file content
+          "The input files are already uploaded and referenced via file URIs.",
+          "Use the provided attachments; do not ask the user to paste file contents.",
+          "Do not claim you cannot access local file paths."
         ].join("\n");
         if (result === null) {
           const rel = path10__namespace.default.relative(root, criteriaPath);
           return this.success(`Criteria file created: ${rel}`);
         }
+        if (result?.passThroughText) {
+          return this.success(result.passThroughText, {
+            type: "evaluation-assess-passthrough",
+            total: 0
+          });
+        }
         const breakdown = result.details.map((d) => `- ${d.name} (${Math.round(d.weight * 100)}%): ${Math.round(d.score * 100)}/100 - ${d.reason}`).join("\n");
         const user = [
           `Project root: ${path10__namespace.default.basename(root)}`,
           `Criteria file: ${path10__namespace.default.relative(root, criteriaPath)}`,
-          `Heuristic total: ${Math.round(result.totalScore * 100)}/100`,
+          `Weighted total: ${Math.round(result.totalScore * 100)}/100`,
           `Breakdown:
 ${breakdown}`,
           options["idea"] || inferred.idea ? `Idea:
 ${options["idea"] || inferred.idea}` : void 0,
           options["code"] || inferred.code ? `Code snippet:
-${options["code"] || inferred.code}` : void 0,
-          files.length ? `File contents:
-${files.map((f3) => {
-            const fObj = result?.files?.find?.((x2) => x2.path === f3);
-            return fObj ? `### ${fObj.path}
-${fObj.content}` : `### ${f3}`;
-          }).join("\n\n")}` : void 0
+${options["code"] || inferred.code}` : void 0
+          // No inline file contents; rely on attachments only
         ].filter(Boolean).join("\n\n");
         const llmSpinner = new ProcessAnimation();
         llmSpinner.start();
@@ -57985,42 +58048,53 @@ ${fObj.content}` : `### ${f3}`;
             "\n---\n",
             user
           ].join("\n");
+          const attachments = Array.isArray(result?.files) ? result.files.map((f3) => ({
+            name: path10__namespace.default.basename(String(f3.path || "attachment.txt")),
+            path: String(f3.path || ""),
+            mime: String(f3.mime || "text/plain"),
+            data_base64: f3.binaryBase64 ? String(f3.binaryBase64) : f3.content ? Buffer.from(f3.content, "utf8").toString("base64") : void 0
+          })).filter((a) => !!a.data_base64) : [];
           const response = await callAPI("/v1/ai-proxy", {
             method: "POST",
             body: {
+              // Force Google route and always use the attachments-capable model
+              provider: "google",
+              model: "gemini-2.5-flash",
               prompt: enriched,
-              taskType: "evaluation"
+              taskType: "evaluation",
+              metadata: attachments.length ? { attachments } : void 0
             }
           });
           const routedModel = response?.data?.routedModel;
           const content = (response?.data?.content || response?.output || "").trim();
+          const uploads = response?.data?.uploads || [];
           if (content) {
-            return this.success(content, {
+            const uploadNote = uploads.length ? `Attached ${uploads.length} file(s) uploaded and referenced.` : attachments.length ? `Attached ${attachments.length} local file(s).` : void 0;
+            const finalText = uploadNote ? `${uploadNote}
+
+${content}` : content;
+            return this.success(finalText, {
               type: "evaluation-assess",
               total: result.totalScore,
               details: result.details,
-              routedModel
+              routedModel,
+              uploads
             });
           }
         } catch (e2) {
+          try {
+            llmSpinner.stop();
+          } catch {
+          }
+          const msg = e2?.message || "LLM scoring failed";
+          return this.error(`Evaluation failed: ${msg}`, "EVALUATION_ERROR", "LLM scoring is required and fallback is disabled");
         } finally {
           try {
             llmSpinner.stop();
           } catch {
           }
         }
-        const lines = [];
-        lines.push("Evaluation Summary (local fallback)");
-        lines.push(`Weighted Score: ${Math.round(result.totalScore * 100)}/100`);
-        lines.push("\nBreakdown:");
-        for (const d of result.details) {
-          lines.push(`- ${d.name} (${Math.round(d.weight * 100)}%): ${Math.round(d.score * 100)}/100 - ${d.reason}`);
-        }
-        return this.success(lines.join("\n"), {
-          type: "evaluation-assess",
-          total: result.totalScore,
-          details: result.details
-        });
+        return this.error("Evaluation failed: unknown state", "EVALUATION_ERROR");
       }
       /**
        * Run A/B evaluation test