@kenkaiiii/gg-boss 4.14.1 → 4.14.2

package/dist/{chunk-JBIIZOVS.js → chunk-U6NZD74R.js}

@@ -70649,6 +70649,20 @@ var SHARP_FORMAT_TO_MEDIA = {
   gif: "image/gif",
   webp: "image/webp"
 };
+var VISION_MEDIA_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
+async function validateVisionImage(buffer) {
+  try {
+    const sharp = await loadSharp();
+    const meta3 = await sharp(buffer).metadata();
+    const mediaType = meta3.format ? SHARP_FORMAT_TO_MEDIA[meta3.format] : void 0;
+    if (!mediaType || !VISION_MEDIA_TYPES.has(mediaType))
+      return null;
+    await sharp(buffer, { failOn: "error" }).resize(256, 256, { fit: "inside", withoutEnlargement: true }).raw().toBuffer();
+    return mediaType;
+  } catch {
+    return null;
+  }
+}
 async function shrinkToFit(buffer, mediaType) {
   const sharp = await loadSharp();
   const meta3 = await sharp(buffer).metadata();
@@ -70751,12 +70765,22 @@ async function readImageFile(filePath) {
   try {
     const mediaType = MEDIA_TYPES[ext] ?? "image/png";
     const rawBuffer = await fs11.readFile(filePath);
-    const { buffer, mediaType: finalMediaType } = await shrinkToFit(rawBuffer, mediaType);
+    const { buffer } = await shrinkToFit(rawBuffer, mediaType);
+    const validatedType = await validateVisionImage(buffer);
+    if (!validatedType) {
+      return {
+        kind: "text",
+        fileName,
+        filePath,
+        mediaType: "text/plain",
+        data: `[image ${fileName} is not a valid/supported image (corrupt or unsupported format); saved at ${filePath} \u2014 inspect it with your tools if needed]`
+      };
+    }
     return {
       kind: "image",
       fileName,
       filePath,
-      mediaType: finalMediaType,
+      mediaType: validatedType,
       data: buffer.toString("base64")
     };
   } catch (err) {
@@ -75240,6 +75264,76 @@ var MARKERS = {
   terraform: { manifests: [], extensions: [".tf", ".tfvars"] }
 };
 var ALL_LANGUAGES = Object.keys(MARKERS);
+var SCAN_DIRS = ["src", "lib", "app", "scripts", "internal", "cmd", "pkg"];
+var MAX_ENTRIES_PER_DIR = 50;
+function detectLanguages(cwd2) {
+  const detected = /* @__PURE__ */ new Set();
+  for (const lang of ALL_LANGUAGES) {
+    const manifests = MARKERS[lang].manifests;
+    if (!manifests || manifests.length === 0)
+      continue;
+    for (const manifest of manifests) {
+      if (fileExists2(path25.join(cwd2, manifest))) {
+        detected.add(lang);
+        break;
+      }
+    }
+  }
+  const dirsToScan = [cwd2, ...SCAN_DIRS.map((d) => path25.join(cwd2, d))];
+  for (const dir of dirsToScan) {
+    let entries;
+    try {
+      entries = fs17.readdirSync(dir).slice(0, MAX_ENTRIES_PER_DIR);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const ext = path25.extname(entry).toLowerCase();
+      if (!ext)
+        continue;
+      for (const lang of ALL_LANGUAGES) {
+        if (detected.has(lang))
+          continue;
+        const exts = MARKERS[lang].extensions;
+        if (exts && exts.includes(ext)) {
+          detected.add(lang);
+        }
+      }
+    }
+  }
+  if (detected.has("typescript") && detected.has("javascript")) {
+    detected.delete("javascript");
+  }
+  if (detected.has("java") && detected.has("kotlin")) {
+    const hasKotlinSources = dirsToScan.some((d) => hasExtensionAt(d, [".kt"]));
+    if (!hasKotlinSources)
+      detected.delete("kotlin");
+  }
+  if (detected.has("c") && detected.has("cpp")) {
+    const hasCppSources = dirsToScan.some((d) => hasExtensionAt(d, [".cpp", ".cc", ".cxx", ".hpp"]));
+    if (hasCppSources)
+      detected.delete("c");
+  }
+  return detected;
+}
+function fileExists2(p) {
+  try {
+    return fs17.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function hasExtensionAt(dir, exts) {
+  try {
+    const entries = fs17.readdirSync(dir).slice(0, MAX_ENTRIES_PER_DIR);
+    for (const entry of entries) {
+      if (exts.includes(path25.extname(entry).toLowerCase()))
+        return true;
+    }
+  } catch {
+  }
+  return false;
+}
 function languagesToSortedArray(set2) {
   const sorted = [...set2];
   sorted.sort();
@@ -75272,6 +75366,86 @@ var LANGUAGE_DISPLAY_NAMES = {
   bash: "Bash",
   terraform: "Terraform"
 };
+var JS_FRAMEWORK_DEPS = [
+  ["next", "Next.js"],
+  ["nuxt", "Nuxt"],
+  ["@remix-run/react", "Remix"],
+  ["@sveltejs/kit", "SvelteKit"],
+  ["astro", "Astro"],
+  ["expo", "React Native (Expo)"],
+  ["react-native", "React Native"],
+  ["@angular/core", "Angular"],
+  ["solid-js", "SolidJS"],
+  ["svelte", "Svelte"],
+  ["vue", "Vue"],
+  ["react", "React"],
+  ["@nestjs/core", "NestJS"],
+  ["@tauri-apps/api", "Tauri"],
+  ["electron", "Electron"],
+  ["hono", "Hono"],
+  ["fastify", "Fastify"],
+  ["express", "Express"],
+  ["tailwindcss", "Tailwind CSS"]
+];
+var IMPLIES = {
+  "Next.js": "React",
+  Remix: "React",
+  "React Native": "React",
+  "React Native (Expo)": "React",
+  Nuxt: "Vue",
+  SvelteKit: "Svelte"
+};
+function detectJsFrameworks(cwd2) {
+  let pkg;
+  try {
+    pkg = JSON.parse(fs17.readFileSync(path25.join(cwd2, "package.json"), "utf-8"));
+  } catch {
+    return [];
+  }
+  const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+  const found = JS_FRAMEWORK_DEPS.filter(([dep]) => dep in deps).map(([, display]) => display);
+  const implied = new Set(found.map((f) => IMPLIES[f]).filter(Boolean));
+  return found.filter((f) => !implied.has(f));
+}
+function detectFromManifest(cwd2, file2, markers) {
+  let content;
+  try {
+    content = fs17.readFileSync(path25.join(cwd2, file2), "utf-8").toLowerCase();
+  } catch {
+    return [];
+  }
+  return markers.filter(([needle]) => content.includes(needle)).map(([, display]) => display);
+}
+function detectProjectStack(cwd2) {
+  const langs = languagesToSortedArray(detectLanguages(cwd2)).map((l) => LANGUAGE_DISPLAY_NAMES[l]);
+  const frameworks = [
+    ...detectJsFrameworks(cwd2),
+    ...detectFromManifest(cwd2, "Gemfile", [
+      ["rails", "Ruby on Rails"],
+      ["sinatra", "Sinatra"]
+    ]),
+    ...detectFromManifest(cwd2, "requirements.txt", [
+      ["django", "Django"],
+      ["flask", "Flask"],
+      ["fastapi", "FastAPI"]
+    ]),
+    ...detectFromManifest(cwd2, "pyproject.toml", [
+      ["django", "Django"],
+      ["flask", "Flask"],
+      ["fastapi", "FastAPI"]
+    ]),
+    ...detectFromManifest(cwd2, "composer.json", [["laravel/framework", "Laravel"]])
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const parts = [];
+  for (const item of [...frameworks, ...langs]) {
+    if (item && !seen.has(item)) {
+      seen.add(item);
+      parts.push(item);
+    }
+  }
+  return parts.slice(0, 6).join(", ");
+}
 
 // ../ggcoder/dist/core/style-packs/packs.js
 init_esm_shims();
@@ -75562,7 +75736,7 @@ function detectVerifyCommands(cwd2, active) {
       const testScript = pick2("test", "test:unit");
       if (testScript)
         cmds.push({ label: "test", command: `${runner} ${testScript}`, language: lang });
-    } else if (active.has("typescript") && fileExists2(path27.join(cwd2, "tsconfig.json"))) {
+    } else if (active.has("typescript") && fileExists3(path27.join(cwd2, "tsconfig.json"))) {
       cmds.push({ label: "typecheck", command: "tsc --noEmit", language: "typescript" });
     }
   }
@@ -75599,10 +75773,10 @@ function detectVerifyCommands(cwd2, active) {
   }
   if (active.has("java") || active.has("kotlin")) {
     const lang = active.has("kotlin") ? "kotlin" : "java";
-    if (fileExists2(path27.join(cwd2, "gradlew"))) {
+    if (fileExists3(path27.join(cwd2, "gradlew"))) {
       cmds.push({ label: "build", command: "./gradlew build", language: lang });
       cmds.push({ label: "test", command: "./gradlew test", language: lang });
-    } else if (fileExists2(path27.join(cwd2, "pom.xml"))) {
+    } else if (fileExists3(path27.join(cwd2, "pom.xml"))) {
       cmds.push({ label: "verify", command: "mvn verify", language: lang });
     }
   }
@@ -75616,7 +75790,7 @@ function detectVerifyCommands(cwd2, active) {
     cmds.push({ label: "test", command: "dotnet test", language: "csharp" });
   }
   if (active.has("ruby")) {
-    if (fileExists2(path27.join(cwd2, "Gemfile"))) {
+    if (fileExists3(path27.join(cwd2, "Gemfile"))) {
       cmds.push({ label: "lint", command: "bundle exec rubocop", language: "ruby" });
       cmds.push({ label: "test", command: "bundle exec rspec", language: "ruby" });
     }
@@ -75626,7 +75800,7 @@ function detectVerifyCommands(cwd2, active) {
     cmds.push({ label: "test", command: "mix test", language: "elixir" });
   }
   if (active.has("php")) {
-    if (fileExists2(path27.join(cwd2, "composer.json"))) {
+    if (fileExists3(path27.join(cwd2, "composer.json"))) {
       cmds.push({ label: "test", command: "composer test", language: "php" });
     }
   }
@@ -75643,7 +75817,7 @@ function detectVerifyCommands(cwd2, active) {
   }
   return cmds;
 }
-function fileExists2(p) {
+function fileExists3(p) {
   try {
     return fs19.statSync(p).isFile();
   } catch {
@@ -75669,11 +75843,11 @@ function readPackageJsonScripts(cwd2) {
   }
 }
 function detectNodeRunner(cwd2) {
-  if (fileExists2(path27.join(cwd2, "pnpm-lock.yaml")))
+  if (fileExists3(path27.join(cwd2, "pnpm-lock.yaml")))
     return "pnpm";
-  if (fileExists2(path27.join(cwd2, "yarn.lock")))
+  if (fileExists3(path27.join(cwd2, "yarn.lock")))
     return "yarn";
-  if (fileExists2(path27.join(cwd2, "bun.lockb")))
+  if (fileExists3(path27.join(cwd2, "bun.lockb")))
     return "bun";
   return "npm run";
 }
@@ -75815,7 +75989,7 @@ ${planContent.trim()}
 function renderResearchSection() {
   return `## Research & Verification
 
-Do not assume APIs, CLI flags, config schema, internals, or error wording. Use \`source_path\` for installed deps and inspect with read/grep/find/ls; use \`web_search\` then \`web_fetch\` for authoritative docs. For public code, use ReferenceSources for curated repos or DiscoverRepos for current/top repos, then verify exact snippets with SearchCode literal text/RE2 (not semantic); \`path\` is a literal path substring and \`repo\` only after broad/peek proof. Run targeted checks when they are relevant to the change; read/fix failures; never report unrun or failing checks as passing.`;
+Your training data has a cutoff; the real current date is the final line of this prompt. Assume your knowledge of library versions, APIs, CLI flags, config schema, defaults, and best practices has changed since then \u2014 treat it as a stale hint to verify, never as ground truth. Do not rely on memory for APIs, CLI flags, config schema, internals, or error wording \u2014 verify first. Use \`source_path\` for installed deps and inspect with read/grep/find/ls; use \`web_search\` then \`web_fetch\` for authoritative docs. For public code, use ReferenceSources for curated repos or DiscoverRepos for current/top repos, then verify exact snippets with SearchCode literal text/RE2 (not semantic); \`path\` is a literal path substring and \`repo\` only after broad/peek proof. Run targeted checks when they are relevant to the change; read/fix failures; never report unrun or failing checks as passing.`;
 }
 function renderCodeQualitySection() {
   return `## Code Quality
@@ -84683,6 +84857,94 @@ function fallbackTitle(userMessage) {
   return (sp > 20 ? t.slice(0, sp) : t) + "\u2026";
 }
 
+// ../ggcoder/dist/utils/prompt-enhancer.js
+init_esm_shims();
+var OPEN = "\u27E6";
+var CLOSE = "\u27E7";
+var BAR = "\xA6";
+var ENHANCER_SYSTEM_PROMPT = `You rewrite a developer's rough request into a tight, well-structured prompt for a CODING AGENT, and you teach them the correct vocabulary as you go. You only rewrite it \u2014 never answer, plan, or implement the request, never ask the user questions, and never add code snippets.
+
+The teaching part: when the user described something in plain or informal words that has a precise, conventional software-engineering name, use that real name AND wrap it so the user learns the term. This highlighting is the main point \u2014 using the right term but failing to wrap it is a miss.
+
+Marker format \u2014 wrap each introduced technical term EXACTLY like this, with BOTH fields always present:
+  ${OPEN}correct term${BAR}the user's own words for it${BAR}short note${CLOSE}
+The third field (note) is an optional plain-language gloss and may be omitted: ${OPEN}correct term${BAR}the user's own words${CLOSE}. Never emit a marker without the user's-own-words field (no bare ${OPEN}term${CLOSE}). The user's-own-words field must quote the relevant part of THEIR phrasing, not a paraphrase.
+
+Mark ONLY genuine vocabulary lessons \u2014 a real plain-words \u2192 established-technical-term upgrade, where the wrapped word is named software/CS jargon (e.g. debounce, throttle, lazy loading, caching, memoization, retry with backoff, concurrency, race, optimistic locking, idempotent, infinite scroll, virtualization, skeleton UI, mock/stub, persistence, WebSocket, cron job, deep copy, hot reload). Usually 0\u20133 per prompt, and often 0 \u2014 many requests have no jargon to teach, and that is fine. Do NOT wrap: plain descriptive English that is not a named technical concept (positions like "to the right of", directions, sizes, colors, "between", "reorder"), ordinary words (updates, changes, loading, bottom, the whole app), terms the user already used correctly, or generic rewording. If the only candidates are plain English, wrap nothing. When in doubt, leave it unwrapped.
+
+Other rules:
+- Keep it concise and easy to follow (usually 1\u20133 sentences). No preamble, no headings, no code fences, no commentary.
+- Preserve every concrete detail the user gave (file names, numbers, identifiers, intent) and never invent requirements or scope.
+- NEVER ask the user for clarification or more detail, and never replace their request with a question. If the request is too vague or trivial to add real terminology (e.g. "fix the bug", "make the button blue"), return it essentially unchanged with no markers \u2014 the result must always read as the user's own instruction to the agent, never a message back to the user.
+- Output ONLY the rewritten prompt, with markers inline. Nothing else.`;
+function parseEnhanced(raw) {
+  let cleaned = stripWrapping(raw);
+  cleaned = cleaned.replace(new RegExp(`${OPEN}([^${BAR}${CLOSE}]*)${CLOSE}`, "g"), (_full, inner) => inner);
+  const segments = [];
+  const re = new RegExp(`${OPEN}([^${BAR}${CLOSE}]+)${BAR}([^${BAR}${CLOSE}]+)(?:${BAR}([^${CLOSE}]+))?${CLOSE}`, "g");
+  let lastIndex = 0;
+  let m;
+  while ((m = re.exec(cleaned)) !== null) {
+    if (m.index > lastIndex) {
+      segments.push({ kind: "text", text: cleaned.slice(lastIndex, m.index) });
+    }
+    const term = m[1].trim();
+    const original = m[2].trim();
+    const note = m[3]?.trim();
+    segments.push({ kind: "term", text: term, original, ...note ? { note } : {} });
+    lastIndex = re.lastIndex;
+  }
+  if (lastIndex < cleaned.length) {
+    segments.push({ kind: "text", text: cleaned.slice(lastIndex) });
+  }
+  const stripOrphans = (s) => s.replace(new RegExp(`[${OPEN}${CLOSE}${BAR}]`, "g"), " ").replace(/ {2,}/g, " ");
+  for (const seg of segments) {
+    if (seg.kind === "text")
+      seg.text = stripOrphans(seg.text);
+  }
+  const trimmed = segments.filter((s) => s.kind !== "text" || s.text.length > 0);
+  if (trimmed.length === 0) {
+    trimmed.push({ kind: "text", text: stripOrphans(cleaned) });
+  }
+  const enhanced = trimmed.map((s) => s.text).join("");
+  return { enhanced, segments: trimmed };
+}
+function stripWrapping(raw) {
+  let text = raw.trim();
+  const fence = text.match(/^```[^\n]*\n([\s\S]*?)\n```$/);
+  if (fence)
+    text = fence[1].trim();
+  text = text.replace(/^(?:sure|okay|ok|here(?:'s| is)|here you go)[^\n]*:\s*\n+/i, "");
+  return text.trim();
+}
+async function enhancePrompt(opts) {
+  const system = opts.stack?.trim() ? `${ENHANCER_SYSTEM_PROMPT}
+
+Project stack: ${opts.stack.trim()}. Prefer terminology idiomatic to this stack, but never invent stack-specific files, APIs, or scope the user didn't mention.` : ENHANCER_SYSTEM_PROMPT;
+  const messages = [
+    { role: "system", content: system },
+    { role: "user", content: opts.prompt }
+  ];
+  const result2 = stream({
+    provider: opts.provider,
+    model: opts.model,
+    messages,
+    maxTokens: 700,
+    // No temperature — the enhancer runs on whatever model is active, and some
+    // (e.g. OpenAI reasoning models like gpt-5.5) reject the parameter outright.
+    apiKey: opts.apiKey,
+    baseUrl: opts.baseUrl,
+    accountId: opts.accountId,
+    signal: opts.signal
+  });
+  result2.response.catch(() => {
+  });
+  const response = await result2;
+  const msg = response.message;
+  const text = typeof msg.content === "string" ? msg.content : msg.content.filter((c2) => c2.type === "text").map((c2) => c2.text).join("");
+  return parseEnhanced(text);
+}
+
 // ../ggcoder/dist/core/ideal-review.js
 init_esm_shims();
 var IDEAL_REVIEW_PROMPT = "Ideal? Review the actual work against the user's request before the final response. Is it simple, focused, correct, and aligned? Did you over-edit, leave TODOs, miss an obvious case the request called for, or introduce risk? Judge this by reading the code you changed \u2014 do NOT run builds, typechecks, linters, or test suites now; that happens at commit time via /commit. If anything is wrong, fix it now. If everything is good, respond with the final answer only; do not mention this ideal review unless it changed the work.";
@@ -85604,6 +85866,33 @@ ${fileNotes.join("\n")}`);
       return null;
     }
   }
+  /**
+   * Rewrite a draft prompt into a tighter, terminology-correct version using
+   * the ACTIVE provider/model. A stateless one-off LLM call (no agent loop, no
+   * tools, no session mutation) — safe to run even mid-run. Returns the plain
+   * enhanced text plus typed segments marking each corrected term. Errors throw
+   * so the caller can surface them (unlike best-effort title generation).
+   */
+  async enhancePrompt(text) {
+    if (!text.trim())
+      return { enhanced: text, segments: [{ kind: "text", text }] };
+    const creds = await this.authStorage.resolveCredentials(this.provider);
+    let stack = "";
+    try {
+      stack = detectProjectStack(this.cwd);
+    } catch {
+    }
+    return enhancePrompt({
+      provider: this.provider,
+      model: this.model,
+      prompt: text,
+      stack,
+      apiKey: creds.accessToken,
+      baseUrl: this.baseUrl ?? creds.baseUrl,
+      accountId: creds.accountId,
+      signal: this.opts.signal
+    });
+  }
   /** Current reasoning/thinking level, or undefined when thinking is off. */
   getThinkingLevel() {
     return this.thinkingLevel;
@@ -117777,4 +118066,4 @@ react/cjs/react-jsx-runtime.development.js:
    * LICENSE file in the root directory of this source tree.
    *)
 */
-//# sourceMappingURL=chunk-JBIIZOVS.js.map
+//# sourceMappingURL=chunk-U6NZD74R.js.map