@bonginkan/maria 4.3.27 → 4.3.28

package/README.md

@@ -1,4 +1,4 @@
-# MARIA - AI Development Platform v4.3.27
+# MARIA - AI Development Platform v4.3.28
 
 [![npm version](https://img.shields.io/npm/v/@bonginkan/maria.svg)](https://www.npmjs.com/package/@bonginkan/maria)
 [![License](https://img.shields.io/badge/license-Multi--tier-blue.svg)](LICENSE)
@@ -10,7 +10,7 @@
 
 > **Enterprise-grade AI development platform with 100% command availability and comprehensive fallback support**
 
-## 🚀 What's New in v4.3.27 (September 16, 2025)
+## 🚀 What's New in v4.3.28 (September 16, 2025)
 
 ### 🎯 Interactive Improvements & Choice Memory
 - **Choice Memory System**: Smart persistence of user selections across sessions
@@ -922,7 +922,7 @@ await secureWorkflow.executeWithAuth(workflowDefinition, securityContext);
 ### Quick Installation
 ```bash
 # Install globally (recommended)
-npm install -g @bonginkan/maria@4.3.27
+npm install -g @bonginkan/maria@4.3.28
 
 # Verify installation
 maria --version  # Should show v4.3.9
@@ -1126,7 +1126,7 @@ MARIA CODE is distributed under a comprehensive licensing system designed for in
 
 *MARIA v4.1.4 represents the pinnacle of multimodal AI development platform evolution - combining revolutionary voice-to-code capabilities, advanced memory systems, and comprehensive command ecosystems with enterprise-grade security and performance. This release establishes MARIA as the definitive choice for developers and Fortune 500 enterprises seeking intelligent, multimodal development experiences with GraphRAG intelligence, multilingual support, and zero-anxiety coding workflows.*
 
-**Transform your development experience today**: `npm install -g @bonginkan/maria@4.3.27`
+**Transform your development experience today**: `npm install -g @bonginkan/maria@4.3.28`
 
 🌐 **Official Website**: [https://maria-code.ai](https://maria-code.ai)  
 💬 **Community**: [https://discord.gg/SMSmSGcEQy](https://discord.gg/SMSmSGcEQy)  

package/dist/READY.manifest.json

@@ -1,6 +1,6 @@
 {
   "version": "lite-1.0.0",
-  "generatedAt": "2025-09-26T02:10:52.909Z",
+  "generatedAt": "2025-09-26T05:40:48.488Z",
   "totalCommands": 16,
   "readyCount": 16,
   "partialCount": 0,

package/dist/bin/maria.cjs

@@ -26066,8 +26066,8 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@bonginkan/maria",
-      version: "4.3.27",
-      description: "\u{1F680} MARIA v4.3.27 - 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.28",
+      description: "\u{1F680} MARIA v4.3.28 - 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",
@@ -28099,7 +28099,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.27"}`
+              "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.3.28"}`
             }
           });
           if (response.status === 401) {
@@ -28731,7 +28731,7 @@ async function callApi(path60, init3 = {}) {
     "Authorization": `Bearer ${token}`,
     "X-Device-Id": getDeviceId(),
     "X-Session-Id": getSessionId() || "",
-    "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.3.27"}`,
+    "User-Agent": `maria-cli/${process.env.CLI_VERSION || "4.3.28"}`,
     "Content-Type": init3.headers?.["Content-Type"] || "application/json"
   });
   const doFetch = async (token) => {
@@ -44443,7 +44443,7 @@ async function applyPlans(plans, opts) {
   try {
     for (const plan of plans) {
       if (opts.signal?.aborted) throw abortErr();
-      const target = path11__namespace.default.join(opts.root, plan.path);
+      const target = plan.absPath ? plan.absPath : path11__namespace.default.join(opts.root, plan.path);
       const dir = path11__namespace.default.dirname(target);
       await fs21.promises.mkdir(dir, { recursive: true });
       const exists2 = await fileExists(target);
@@ -50625,7 +50625,7 @@ var init_about_command = __esm({
       async execute(args2, context2) {
         const output3 = [];
         output3.push("");
-        output3.push(chalk14__default.default.cyan.bold("\u{1F916} About MARIA v4.3.27"));
+        output3.push(chalk14__default.default.cyan.bold("\u{1F916} About MARIA v4.3.28"));
         output3.push(chalk14__default.default.gray("\u2550".repeat(40)));
         output3.push("");
         output3.push(chalk14__default.default.white.bold("MARIA - Minimal API, Maximum Power"));
@@ -54127,6 +54127,10 @@ async function normalizePlans(plans, opts) {
   const profile = await scanRepo(opts.root);
   const out = [];
   for (const fp of plans) {
+    if (fp.noNormalize) {
+      out.push(fp);
+      continue;
+    }
     const n = normalizePlanItem(fp, profile);
     if (!n.kind) n.kind = guessKindByPath(n.path);
     out.push(n);
@@ -54171,7 +54175,7 @@ async function validatePlan(plans, opts) {
       skipped.push(fp.path);
       continue;
     }
-    const full = path11__namespace.default.join(opts.root, rel);
+    const full = fp.absPath ? fp.absPath : path11__namespace.default.join(opts.root, rel);
     if (!full.startsWith(path11__namespace.default.resolve(opts.root))) {
       warnings.push(`Outside root denied: ${fp.path}`);
       skipped.push(fp.path);
@@ -54302,10 +54306,10 @@ function formatPlan(summary, opts) {
     budget.diffLines = Math.min(budget.diffLines, 20);
     lines.push("", `Diff preview (truncated to ${budget.diffLines} lines per file):`);
     for (const f3 of summary.files) {
-      if (f3.action === "skip") continue;
-      const before = readCurrentFileSafe(opts.root, f3.path);
+      if (f3.action !== "modify") continue;
+      const before = readCurrentFileSafe(opts.root, f3.path, f3.absPath);
       const after = f3.preview || "";
-      const diff = buildUnifiedDiff(f3.path, before, after, budget);
+      const diff = buildUnifiedDiff(f3.path, before, after, budget, f3.absPath);
       lines.push(diff, "");
     }
   }
@@ -54342,9 +54346,10 @@ function formatPlanAsDiff(files, opts) {
   let shownFiles = 0;
   for (const f3 of files) {
     if (budget.globalMaxFiles !== void 0 && shownFiles >= budget.globalMaxFiles) break;
-    const before = readCurrentFileSafe(opts.root, f3.path);
+    if (f3.action !== "modify") continue;
+    const before = readCurrentFileSafe(opts.root, f3.path, f3.absPath);
     const after = f3.preview || "";
-    const diff = buildUnifiedDiff(f3.path, before, after, budget);
+    const diff = buildUnifiedDiff(f3.path, before, after, budget, f3.absPath);
     const diffBytes = Buffer.byteLength(diff, "utf8");
     if (budget.globalMaxBytes !== void 0 && bytesUsed + diffBytes > budget.globalMaxBytes && shownFiles > 0) {
       lines.push(`
@@ -54361,11 +54366,11 @@ function formatPlanAsDiff(files, opts) {
   }
   return lines.join("\n");
 }
-function readCurrentFileSafe(root, rel) {
-  if (!root) return "";
+function readCurrentFileSafe(root, rel, abs) {
+  if (!root && !abs) return "";
   try {
     const fs49 = __require("fs");
-    const p = __require("path").join(root, rel);
+    const p = abs ? abs : __require("path").join(root, rel);
     return fs49.existsSync(p) ? fs49.readFileSync(p, "utf8") : "";
   } catch {
     return "";
@@ -54382,7 +54387,7 @@ function normalizeDiffBudget(b) {
     globalMaxFiles: Number.isFinite(b?.globalMaxFiles) ? b.globalMaxFiles : envGlobalFiles
   };
 }
-function buildUnifiedDiff(relPath, before, after, b) {
+function buildUnifiedDiff(relPath, before, after, b, abs) {
   const beforeLines = before.split(/\r?\n/);
   const afterLines = after.split(/\r?\n/);
   let i2 = 0;
@@ -54391,14 +54396,15 @@ function buildUnifiedDiff(relPath, before, after, b) {
   while (j < beforeLines.length - i2 && j < afterLines.length - i2 && beforeLines[beforeLines.length - 1 - j] === afterLines[afterLines.length - 1 - j]) j++;
   const oldMid = beforeLines.slice(i2, beforeLines.length - j);
   const newMid = afterLines.slice(i2, afterLines.length - j);
-  const header = [`--- a/${relPath}`, `+++ b/${relPath}`];
+  const headerPath = abs ? abs : relPath;
+  const header = [`--- ${headerPath}`, `+++ ${headerPath}`];
   const body = [];
   const ctxPrefix = Math.max(0, i2 - 3);
   Math.min(beforeLines.length, beforeLines.length - j + 3);
   const preCtx = beforeLines.slice(ctxPrefix, i2).map((l) => ` ${l}`);
   const postCtx = beforeLines.slice(beforeLines.length - j, Math.min(beforeLines.length - j + 3, beforeLines.length)).map((l) => ` ${l}`);
-  const del = oldMid.map((l) => `-${l}`);
-  const add = newMid.map((l) => `+${l}`);
+  const del = oldMid.map((l) => colorRed(`-${l}`));
+  const add = newMid.map((l) => colorGreen(`+${l}`));
   body.push(...preCtx);
   body.push(...del);
   body.push(...add);
@@ -54415,6 +54421,22 @@ function buildUnifiedDiff(relPath, before, after, b) {
   }
   return out;
 }
+function colorGreen(s2) {
+  try {
+    const chalk44 = __require("chalk");
+    return chalk44.green(s2);
+  } catch {
+    return s2;
+  }
+}
+function colorRed(s2) {
+  try {
+    const chalk44 = __require("chalk");
+    return chalk44.red(s2);
+  } catch {
+    return s2;
+  }
+}
 function languageLabel(lang, filePath) {
   if (lang) {
     const l = lang.toLowerCase();
@@ -55041,6 +55063,20 @@ var init_policy = __esm({
   }
 });
 
+// src/utils/esm-compat.ts
+var esm_compat_exports = {};
+__export(esm_compat_exports, {
+  loadGlobby: () => loadGlobby
+});
+async function loadGlobby() {
+  const mod = await import('globby');
+  return mod?.globby ?? mod?.default ?? mod;
+}
+var init_esm_compat = __esm({
+  "src/utils/esm-compat.ts"() {
+  }
+});
+
 // src/services/code-orchestrator/Orchestrator.ts
 var Orchestrator_exports = {};
 __export(Orchestrator_exports, {
@@ -55075,6 +55111,20 @@ async function orchestrate(request, opts) {
   const initial = [];
   const fallbackNotices = [];
   const withNotices = (base) => fallbackNotices.length > 0 ? [...fallbackNotices, ...base] : base;
+  const explicitFilesRaw = parseExplicitFilenames(request);
+  const explicitFiles = explicitFilesRaw.length > 0 ? await resolveExplicitPaths(opts.root, explicitFilesRaw, request) : [];
+  const explicitAbsMap = /* @__PURE__ */ Object.create(null);
+  if (explicitFiles.length > 0) {
+    const pathMod = await import('path');
+    for (const rel of explicitFiles) {
+      explicitAbsMap[rel] = pathMod.join(opts.root, rel);
+    }
+  }
+  const isEditIntent = detectEditIntent(request, {
+    hasAttachments: !!(opts.attachedFiles && opts.attachedFiles.length > 0),
+    explicitFilesCount: explicitFiles.length
+  });
+  const editContext = isEditIntent && explicitFiles.length > 0 ? await buildEditContext(opts.root, explicitFiles, 200, 512 * 1024) : "";
   if (opts.attachedFiles && opts.attachedFiles.length > 0) {
     const mapRes = await mapAttachmentsToTargets(opts.attachedFiles, {
       root: opts.root,
@@ -55094,7 +55144,6 @@ async function orchestrate(request, opts) {
     }
   }
   const onlyAttached = !!opts.flags.onlyAttached;
-  const explicitFiles = parseExplicitFilenames(request);
   if (!onlyAttached) {
     let codeOutput = "";
     if (process.env.MARIA_E2E_FAKE_CODE === "1") {
@@ -55114,9 +55163,17 @@ async function orchestrate(request, opts) {
               "[BEGIN file: path]\n<content>\n[END]",
               "Do not include any prose before/after; no menus/questions/suggestions; start immediately with ``` or [BEGIN file: ...]."
             ].join("\n");
+            const requestPreamble = isEditIntent ? [
+              "// EDIT MODE: modify existing files, preserve unrelated content.",
+              "// Follow existing structure and only touch requested files.",
+              editContext ? "// Current file snapshots provided below." : ""
+            ].filter(Boolean).join("\n") : "";
             const enriched = `${FILE_FORMAT_INSTRUCTIONS}
 
-${request}`;
+${requestPreamble}
+${request}
+
+${editContext}`;
             const response = await executeCode(enriched);
             const raw = (response.output || response?.data?.content || "").trim();
             if (!raw) {
@@ -55161,24 +55218,27 @@ ${request}`;
       const htmlIdx = blocks.findIndex((b) => /html/i.test(b.language));
       const htmlFile = explicitFiles.find((f3) => f3.toLowerCase().endsWith(".html"));
       if (htmlIdx >= 0 && htmlFile) {
-        initial.push({ path: htmlFile, kind: "source", action: "create", description: "HTML page", language: "html", preview: blocks[htmlIdx].code });
+        initial.push({ path: htmlFile, absPath: explicitAbsMap[htmlFile], noNormalize: true, kind: "source", action: "create", description: "HTML page", language: "html", preview: blocks[htmlIdx].code });
         mapped.add(htmlFile);
       }
       const jsIdx = blocks.findIndex((b) => /(ts|tsx|jsx|javascript|js)/i.test(b.language));
       const jsFile = explicitFiles.find((f3) => f3.toLowerCase().endsWith(".js"));
       if (jsIdx >= 0 && jsFile && !mapped.has(jsFile)) {
-        initial.push({ path: jsFile, kind: "source", action: "create", description: "Script", language: "javascript", preview: blocks[jsIdx].code });
+        initial.push({ path: jsFile, absPath: explicitAbsMap[jsFile], noNormalize: true, kind: "source", action: "create", description: "Script", language: "javascript", preview: blocks[jsIdx].code });
         mapped.add(jsFile);
       }
       const cssIdx = blocks.findIndex((b) => /css/i.test(b.language));
       const cssFile = explicitFiles.find((f3) => f3.toLowerCase().endsWith(".css"));
       if (cssIdx >= 0 && cssFile && !mapped.has(cssFile)) {
-        initial.push({ path: cssFile, kind: "source", action: "create", description: "Stylesheet", language: "css", preview: blocks[cssIdx].code });
+        initial.push({ path: cssFile, absPath: explicitAbsMap[cssFile], noNormalize: true, kind: "source", action: "create", description: "Stylesheet", language: "css", preview: blocks[cssIdx].code });
         mapped.add(cssFile);
       }
       for (const f3 of explicitFiles) {
         if (mapped.has(f3)) continue;
-        initial.push(scaffoldForFilename(f3, explicitFiles));
+        const plan = scaffoldForFilename(f3, explicitFiles);
+        plan.absPath = explicitAbsMap[f3];
+        plan.noNormalize = true;
+        initial.push(plan);
       }
     } else {
       for (let i2 = 0; i2 < blocks.length; i2++) {
@@ -55196,12 +55256,26 @@ ${request}`;
       }
     }
   }
+  if (!isEditIntent) {
+    const proposedTop = deriveProjectFolderName(request);
+    const { folderName, detectedTop } = await ensureTopFolder(opts.root, proposedTop, initial);
+    if (folderName) {
+      for (const p of initial) {
+        if (!startsWithTopFolder(p.path, detectedTop || folderName)) {
+          p.path = prefixWithTopFolder(p.path, folderName);
+        }
+      }
+    }
+  }
   if (explicitFiles.length > 0 && initial.filter((f3) => !!f3.preview).length === 0) {
     for (const f3 of explicitFiles) {
       initial.push(scaffoldForFilename(f3, explicitFiles));
     }
   }
-  const normalized = await normalizePlans(initial, { root: opts.root });
+  const normalized = await normalizePlans(
+    initial.map((p) => p.noNormalize ? p : p),
+    { root: opts.root }
+  );
   try {
     const [{ access: access18 }, path60] = await Promise.all([
       import('fs/promises'),
@@ -55209,8 +55283,12 @@ ${request}`;
     ]);
     for (const p of normalized) {
       try {
-        await access18(path60.join(opts.root, p.path));
+        const absCandidate = p.absPath ? p.absPath : path60.join(opts.root, p.path);
+        await access18(absCandidate);
         p.action = "modify";
+        if (isEditIntent) {
+          p.overwritePolicy = "allow";
+        }
       } catch {
         p.action = "create";
       }
@@ -55218,10 +55296,12 @@ ${request}`;
   } catch {
   }
   const validated = await validatePlan(normalized, { root: opts.root, profile, flags: { maxFiles: opts.flags.maxFiles, yes: opts.flags.yes, interactive: !!opts.flags.interactive, ...opts.flags } });
-  const outputMode = resolveOutputMode(opts.flags.output, validated.files.length, !!opts.flags.hideCode);
-  const displayFiles = validated.files.concat(
-    (validated.skipped || []).map((p) => ({ path: p, kind: "source", action: "skip", description: "" }))
-  );
+  const hasAnyModify = validated.files.some((f3) => f3.action === "modify") || isEditIntent;
+  const outputMode = !opts.flags.hideCode && hasAnyModify ? "diff" : resolveOutputMode(opts.flags.output, validated.files.length, !!opts.flags.hideCode);
+  const skippedSetForLookup = new Set(validated.skipped || []);
+  const skippedPlans = normalized.filter((f3) => skippedSetForLookup.has(f3.path));
+  const remainingSkipped = (validated.skipped || []).filter((p) => !skippedPlans.some((sp) => sp.path === p)).map((p) => ({ path: p, kind: "source", action: "skip", description: "" }));
+  const displayFiles = validated.files.concat(skippedPlans).concat(remainingSkipped);
   const summary = summarizePlan(displayFiles);
   const lines = [
     formatPlan(summary, {
@@ -55259,6 +55339,7 @@ ${request}`;
     if (softIssues.hasTrailingWhitespace) lines.push(warnLine("Proposed changes contain trailing whitespace"));
     if (softIssues.hasConflictMarkers) lines.push(warnLine("Proposed changes contain conflict markers"));
   }
+  const preApplyOutput = withNotices(lines);
   let appliedCount = 0;
   let durationMs = 0;
   let rolledBack = false;
@@ -55270,7 +55351,7 @@ ${request}`;
         return { plan: normalized, validated, summaryLines: withNotices([errorLine("working tree not clean (commit or stash first). Re-run after cleaning your git status.")]) };
       }
     }
-    const allowOverwrite = opts.flags.overwriteAllowed === true || !!opts.flags.yes;
+    const allowOverwrite = opts.flags.overwriteAllowed === true || !!opts.flags.yes || isEditIntent;
     const applyRes = await applyPlans(approved, { root: opts.root, overwriteAllowed: allowOverwrite, rollback: opts.flags.rollback !== false, signal: opts.abortSignal, onProgress: (w, t2) => {
     }, eol: profile.eol });
     appliedCount = applyRes.appliedCount;
@@ -55300,7 +55381,7 @@ ${request}`;
     const savedList = [].concat(applyRes.created, applyRes.modified);
     const savedAbs = savedList.map((rel) => path11__namespace.default.resolve(opts.root, rel));
     const footer = savedAbs.length > 0 ? ["Saved files (full paths):", ...savedAbs.map((p) => `- ${p}`)] : [];
-    return { plan: normalized, validated, applied: { count: appliedCount, durationMs, rolledBack }, summaryLines: withNotices([msg, ...footer]) };
+    return { plan: normalized, validated, applied: { count: appliedCount, durationMs, rolledBack }, summaryLines: [...preApplyOutput, "", msg, ...footer] };
   } catch (e2) {
     if (e2?.name === "AbortError") {
       await journalResume(opts.root, request, validated.files);
@@ -55521,6 +55602,218 @@ function parseExplicitFilenames(request) {
   }
   return out;
 }
+function detectEditIntent(request, ctx2) {
+  const r2 = request.toLowerCase();
+  const editKeywords = ["modify", "edit", "update", "fix", "refactor", "change", "patch", "\u5DEE\u5206", "\u4FEE\u6B63", "\u5909\u66F4", "\u65E2\u5B58", "\u8FFD\u8A18"];
+  const mentionsEdit = editKeywords.some((k) => r2.includes(k));
+  return ctx2.hasAttachments || ctx2.explicitFilesCount > 0 || mentionsEdit;
+}
+function sanitizeFolderName(name2) {
+  const base = name2.toLowerCase().replace(/[`~!@#$%^&*()+=\[\]{}|;:'",<>/?\\]/g, " ").replace(/\s+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+  return base || "project";
+}
+function deriveProjectFolderName(request) {
+  const words = request.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 2).slice(0, 4).join("-");
+  return sanitizeFolderName(words || "project");
+}
+function startsWithTopFolder(p, folder) {
+  if (!folder) return false;
+  const seg = p.replace(/^\/+/, "").split("/")[0];
+  return seg.toLowerCase() === folder.toLowerCase();
+}
+function prefixWithTopFolder(p, folder) {
+  const rel = p.replace(/^\/+/, "");
+  return `${folder}/${rel}`;
+}
+async function ensureTopFolder(root, proposed, plans) {
+  const tops = /* @__PURE__ */ new Set();
+  for (const p of plans) {
+    const seg = p.path.replace(/^\/+/, "").split("/")[0] || "";
+    if (seg) tops.add(seg);
+  }
+  if (tops.size === 1) {
+    const only = Array.from(tops)[0];
+    const unique2 = await ensureUniqueFolder(root, only);
+    return { folderName: unique2, detectedTop: only };
+  }
+  const unique = await ensureUniqueFolder(root, proposed);
+  return { folderName: unique };
+}
+async function ensureUniqueFolder(root, base) {
+  const fs49 = await import('fs/promises');
+  const pathMod = await import('path');
+  let name2 = sanitizeFolderName(base);
+  let suffix = 0;
+  for (; suffix < Number.MAX_SAFE_INTEGER; ) {
+    const candidate = suffix === 0 ? name2 : `${name2}-${String(suffix).padStart(2, "0")}`;
+    try {
+      await fs49.access(pathMod.join(root, candidate));
+      suffix += 1;
+    } catch {
+      return candidate;
+    }
+  }
+  throw new Error("ensureUniqueFolder: exhausted attempts to find a unique folder name");
+}
+async function buildEditContext(root, files, maxLines, maxBytes) {
+  try {
+    const fs49 = await import('fs/promises');
+    const pathMod = await import('path');
+    const sections = [];
+    for (const rel of files) {
+      const full = pathMod.join(root, rel);
+      try {
+        const buf = await fs49.readFile(full);
+        const clipped = buf.length > maxBytes ? buf.subarray(0, maxBytes) : buf;
+        const text = clipped.toString("utf8").replace(/\r\n/g, "\n");
+        const lines = text.split("\n").slice(0, maxLines).join("\n");
+        sections.push(`[BEGIN file: ${rel}]
+${lines}
+[END]`);
+      } catch {
+      }
+    }
+    if (sections.length === 0) return "";
+    return ["// Current repository files (read-only context):", ...sections].join("\n");
+  } catch {
+    return "";
+  }
+}
+async function resolveExplicitPaths(root, files, hintText) {
+  const fs49 = await import('fs/promises');
+  const pathMod = await import('path');
+  const { loadGlobby: loadGlobby2 } = await Promise.resolve().then(() => (init_esm_compat(), esm_compat_exports));
+  const globby = await loadGlobby2();
+  const ignore = [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.maria/**",
+    "**/.next/**",
+    "**/coverage/**"
+  ];
+  const hintTokens = Array.from(new Set(hintText.toLowerCase().replace(/[^a-z0-9_/.-]+/g, " ").split(/\s+/).filter(Boolean)));
+  async function findBest(rel) {
+    const normalized = rel.replace(/^\/+/, "").replace(/\\/g, "/");
+    const fullExact = pathMod.join(root, normalized);
+    try {
+      await fs49.access(fullExact);
+      return normalized;
+    } catch {
+    }
+    const lowerRel = normalized.toLowerCase();
+    const ext2 = (pathMod.extname(normalized) || "").toLowerCase();
+    const base = pathMod.basename(normalized);
+    const nameNoExt = base.replace(/\.[^.]+$/, "").toLowerCase();
+    const parentPath = pathMod.dirname(normalized);
+    const parent = parentPath.split("/").pop() || "";
+    const dirParts = parentPath === "." ? [] : parentPath.split("/").filter(Boolean).map((s2) => s2.toLowerCase());
+    const patterns = [];
+    patterns.push(`**/${normalized}`);
+    if (parent && parent !== "." && parent !== "/") patterns.push(`**/${parent}/${base}`);
+    if (base) patterns.push(`**/${base}`);
+    patterns.push(`**/*${base}`);
+    if (!ext2) {
+      patterns.push(`**/${nameNoExt}.*`);
+    }
+    const uniqPatterns = Array.from(new Set(patterns));
+    const candidatesSet = /* @__PURE__ */ new Set();
+    for (const pat of uniqPatterns) {
+      const found = await globby(pat, { cwd: root, absolute: false, gitignore: true, ignore });
+      for (const f3 of found) {
+        candidatesSet.add(f3.replace(/\\/g, "/"));
+      }
+      if (candidatesSet.size > 200) break;
+    }
+    let candidates = Array.from(candidatesSet);
+    if (dirParts.length > 0) {
+      const filtered = candidates.filter((relp) => {
+        const segs = relp.toLowerCase().split("/");
+        let pos = -1;
+        for (const part of dirParts) {
+          const next = segs.indexOf(part, pos + 1);
+          if (next === -1) return false;
+          pos = next;
+        }
+        return true;
+      });
+      if (filtered.length > 0) candidates = filtered;
+    }
+    if (candidates.length === 0) {
+      const prefixes = ["", "src/", "app/", "pages/"];
+      for (const pre of prefixes) {
+        const cand = pathMod.join(root, pre + normalized);
+        try {
+          await fs49.access(cand);
+          return (pre + normalized).replace(/^\/+/, "");
+        } catch {
+        }
+      }
+      if (dirParts.length > 0) {
+        if (/^(src|app|pages)\//i.test(normalized)) return normalized;
+        const pref = await pickExistingFolderPrefix(root, parentPath);
+        const combined = (pref + normalized).replace(/^\/+/, "").replace(/^(src\/)src\//i, "$1");
+        return combined;
+      }
+      return normalized.replace(/^(src\/)src\//i, "$1");
+    }
+    function score(relPath) {
+      const lower2 = relPath.toLowerCase();
+      let s2 = 0;
+      if (lower2.endsWith(lowerRel)) s2 += 80;
+      if (lower2.split("/").pop() === base.toLowerCase()) s2 += 40;
+      if (ext2 && lower2.endsWith(ext2)) s2 += 10;
+      if (lower2.startsWith("src/")) s2 += 18;
+      if (parent && lower2.includes(`/${parent.toLowerCase()}/`)) s2 += 15;
+      if (parentPath && lower2.endsWith(`/${parentPath.toLowerCase()}/${base.toLowerCase()}`)) s2 += 40;
+      if (dirParts.length > 0) {
+        for (const part of dirParts) {
+          if (lower2.includes(`/${part}/`)) s2 += 20;
+          else s2 -= 120;
+        }
+      }
+      for (const t2 of hintTokens) {
+        if (t2.length >= 3 && lower2.includes(`/${t2}/`)) {
+          s2 += 2;
+        }
+      }
+      s2 -= Math.min(10, Math.floor(relPath.length / 80));
+      return s2;
+    }
+    let best = candidates[0];
+    let bestScore = score(best);
+    for (let i2 = 1; i2 < candidates.length; i2++) {
+      const c = candidates[i2];
+      const sc = score(c);
+      if (sc > bestScore) {
+        best = c;
+        bestScore = sc;
+      }
+    }
+    return best.replace(/^\/+/, "");
+  }
+  const out = [];
+  for (const f3 of files) {
+    out.push(await findBest(f3));
+  }
+  return out;
+}
+async function pickExistingFolderPrefix(root, parentPath) {
+  const fs49 = await import('fs/promises');
+  const pathMod = await import('path');
+  const parts = parentPath.replace(/^\/+/, "").split("/").filter(Boolean);
+  const prefixes = ["src", "app", "pages", ""];
+  for (const pre of prefixes) {
+    const test = pre ? pathMod.join(root, pre, ...parts) : pathMod.join(root, ...parts);
+    try {
+      await fs49.access(test);
+      return pre ? `${pre}/` : "";
+    } catch {
+    }
+  }
+  return "src/";
+}
 function scaffoldForFilename(filename, all) {
   const lower2 = filename.toLowerCase();
   if (lower2.endsWith(".html")) {
@@ -56495,16 +56788,6 @@ var init_resume_command = __esm({
   }
 });
 
-// src/utils/esm-compat.ts
-async function loadGlobby() {
-  const mod = await import('globby');
-  return mod?.globby ?? mod?.default ?? mod;
-}
-var init_esm_compat = __esm({
-  "src/utils/esm-compat.ts"() {
-  }
-});
-
 // src/services/init/scanner.ts
 var scanner_exports = {};
 __export(scanner_exports, {