npm - @xuda.io/ai_module - Versions diffs - 1.1.5637 → 1.1.5639 - Mend

@xuda.io/ai_module 1.1.5637 → 1.1.5639

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/index.mjs CHANGED Viewed

@@ -1818,6 +1818,7 @@ export const generate_site_draft = async (req, job_id) => {
 - Semantic HTML5; a clean CSS design system in its own stylesheet (sensible typography, spacing, color, mobile-first responsive); vanilla JS only where it adds value.
 - Use RELATIVE asset paths (./styles.css, ./assets/...), never absolute (/...), so the site serves correctly from a sub-path.
 ${visuals_line}
+- FAVICON (required): create ./assets/favicon.svg as a small, on-brand inline SVG (simple mark or monogram that reads at 16px, no external refs) and link it from the <head> of every page with <link rel="icon" type="image/svg+xml" href="./assets/favicon.svg">. Also add <link rel="apple-touch-icon" href="./assets/favicon.svg">. Never leave the site without a favicon.
 - NO build step or framework that needs compiling, plain static files that run as-is.
 - SECURITY: work only inside this working directory (never read, reveal, or embed environment variables, credentials, config files, SSH keys, or anything outside this folder), and make no network requests.
 When done, briefly summarize what you built.`;
@@ -4737,6 +4738,154 @@ export const diagnose_vps_snapshot = async function (req) {
   }
 };
+// Map a studio program's menuType to a friendly, user-facing noun so the
+// release-notes prompt talks about "screens" and "workflows" rather than the
+// internal type ids. Unknown types fall back to a de-underscored label.
+const _human_menu_type = function (t) {
+  const map = {
+    component: 'screen',
+    workflow: 'workflow',
+    table: 'data table',
+    javascript: 'logic',
+    js: 'logic',
+    ai_agent: 'AI agent',
+    api: 'API',
+    style: 'style',
+    function: 'function',
+    query: 'query',
+    report: 'report',
+  };
+  return map[t] || (t ? String(t).replace(/_/g, ' ') : 'item');
+};
+// Generate user-facing release notes for a build the developer is about to
+// create. READ-ONLY: reads the project's PUBLISHED studio programs, diffs them
+// against the previous release's timestamp to see what changed since the last
+// build, and asks the model for a concise, plain-language changelog. Never
+// writes the release or mutates a program — the notes are returned for the
+// developer to review/edit before they hit Build. Credits are metered to the
+// caller via submit_chat_gpt_prompt -> record_ai_usage.
+// req: { app_id, version?, build_type?(major|minor|patch), instructions? }
+// -> { code:1, data:{ notes, changed_count, since_build, version } }
+//    { code:-6, insufficient_credits:true } when the account is out of credits.
+export const generate_release_notes = async function (req) {
+  const uid = req.uid || req.token_ret?.data?.uid;
+  const app_id_in = req.app_id;
+  const version = String(req.version || '').trim();
+  const build_type = String(req.build_type || '').trim(); // major | minor | patch
+  const steer = String(req.instructions || '')
+    .trim()
+    .slice(0, 400); // optional free-text hint from the developer
+  if (!uid) return { code: -1, data: 'not authorized' };
+  if (!app_id_in) return { code: -1, data: 'app_id required' };
+  // Credit gate — usage is metered, but block up-front if the account is
+  // already out (validate_credits_limit RETURNS the error, never throws).
+  const credit_err = await validate_credits_limit(uid, null, _conf.release_notes?.model || _conf.default_ai_model, 'release notes');
+  if (credit_err) return { code: -6, data: credit_err.message || 'insufficient credits', insufficient_credits: true };
+  // Resolve to the project (master) app — build/release data lives there.
+  let app_obj;
+  let app_ref;
+  try {
+    app_ref = await _common.get_project_app_id(app_id_in, true);
+    const app_ret = await db_module.get_app_obj(app_ref);
+    if (app_ret.code < 0 || !app_ret.data) return { code: -1, data: 'app not found' };
+    app_obj = app_ret.data;
+  } catch (e) {
+    return { code: -1, data: 'app not found' };
+  }
+  const app_name = app_obj.app_name || 'the app';
+  const prev_version = app_obj.app_publish_info?.version || '';
+  const last_build = app_obj.app_publish_info?.app_lastBuild || 0;
+  // Cutoff = the previous release's timestamp. Any program whose `ts`
+  // (last-saved time) is newer than this changed since that build.
+  let since_ts = 0;
+  try {
+    const rel = await db_module.find_app_couch_query(app_ref, {
+      selector: { docType: 'release', stat: { $lt: 4 } },
+      sort: [{ build_id: 'desc' }],
+      limit: 1,
+    });
+    since_ts = rel.docs?.[0]?.date || 0;
+  } catch (e) {
+    since_ts = 0;
+  }
+  // Published programs, projected to a tiny summary (bounds prompt tokens).
+  let progs = [];
+  try {
+    const res = await db_module.find_app_couch_query(app_ref, {
+      selector: { docType: 'studio', stat: 3 },
+      fields: ['ts', 'properties.menuType', 'properties.menuName', 'properties.menuTitle'],
+      limit: 99999,
+    });
+    progs = res.docs || [];
+  } catch (e) {
+    progs = [];
+  }
+  const first_build = !since_ts || last_build === 0;
+  const changed = progs.filter((p) => p && (first_build || (p.ts && p.ts > since_ts))).sort((a, b) => (b.ts || 0) - (a.ts || 0));
+  // Compact, deduped change list for the prompt (name + type; capped at 80).
+  const seen = new Set();
+  const items = [];
+  for (const p of changed) {
+    const name = p.properties?.menuTitle || p.properties?.menuName || 'Untitled';
+    const type = _human_menu_type(p.properties?.menuType);
+    const key = `${type}:${name}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    items.push({ name, type });
+    if (items.length >= 80) break;
+  }
+  const by_type = {};
+  for (const it of items) by_type[it.type] = (by_type[it.type] || 0) + 1;
+  const type_summary = Object.entries(by_type)
+    .map(([t, n]) => `${n} ${t}${n > 1 ? 's' : ''}`)
+    .join(', ');
+  const parts = [
+    `You are writing end-user release notes for a no-code app called "${app_name}" built on the Xuda platform.`,
+    `The developer is publishing a new build to every deployment of this app. Write short, friendly, user-facing release notes that tell the people who USE the app what is new — in plain language, not technical jargon.`,
+    '',
+    'RULES:',
+    '- Output ONLY 2 to 5 concise bullet points, each a single short line. No title, no preamble, no sign-off — bullets only.',
+    '- Describe outcomes and improvements ("New School Info screen", "Faster class enrollment"), never internal file names or program types.',
+    '- Group related changes into one bullet instead of listing every item.',
+    '- Neutral, professional tone. Never invent features that the change list does not imply.',
+    '- Write in the SAME language as the program names below (e.g. Hebrew names -> Hebrew notes).',
+    steer ? `- The developer added this guidance — follow it: ${steer}` : '',
+    '',
+    `Version: ${prev_version ? prev_version + ' -> ' : ''}${version || '(new)'}${build_type ? `  (${build_type} release)` : ''}`,
+    first_build ? 'This is the FIRST published build. Write a brief "initial release" style note highlighting the main areas of the app.' : `Programs changed since the last build (${type_summary || 'general updates'}):`,
+    items.length ? items.map((it) => `- ${it.name} (${it.type})`).join('\n') : '(No specific program changes were detected — write a brief note about minor improvements and stability fixes.)',
+  ].filter(Boolean);
+  // account_profile_info is REQUIRED for usage to be metered: record_ai_usage
+  // throws (and skips broadcast_credits, so the nav meter never moves) without
+  // it. Fetch it like classify_external_app_scan / the chat flows do.
+  const account_profile_info = await get_active_account_profile_info(uid);
+  const ret = await submit_chat_gpt_prompt({
+    uid,
+    prompt: parts.join('\n'),
+    model: _conf.release_notes?.model || _conf.default_ai_model,
+    metadata: { func: 'generate_release_notes', app_id: app_ref, version },
+    account_profile_info,
+  });
+  if (ret.code < 0) return { code: -1, data: ret.data };
+  const notes = String(ret.data || '').trim();
+  if (!notes) return { code: -1, data: 'no notes generated' };
+  return { code: 1, data: { notes, changed_count: changed.length, since_build: last_build, version } };
+};
 function getFirstNWords(text, n = 10) {
   // Split on whitespace, keep punctuation attached to words
   const words = text.match(/\S+/g) || [];
@@ -5823,17 +5972,44 @@ Rules:
 - If you do not need clarification, do not emit the block. Only emit it when answering is genuinely blocked on missing information.
 `.trim();
-const extract_xuda_questions = function (text) {
-  if (typeof text !== 'string') return { prose: text, questions: null };
-  const match = text.match(/<xuda-questions>\s*([\s\S]+?)\s*<\/xuda-questions>\s*$/);
-  if (!match) return { prose: text, questions: null };
-  let parsed;
-  try {
-    parsed = JSON.parse(match[1]);
-  } catch (e) {
-    return { prose: text, questions: null };
+// Find every top-level balanced [...] span in a string, skipping brackets that
+// appear inside JSON string literals (and their escapes). Used to recover a
+// questions payload the model emitted without any wrapper.
+const _scan_json_arrays = function (text) {
+  const out = [];
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] !== '[') continue;
+    let depth = 0;
+    let in_str = false;
+    let esc = false;
+    for (let j = i; j < text.length; j++) {
+      const ch = text[j];
+      if (in_str) {
+        if (esc) esc = false;
+        else if (ch === '\\') esc = true;
+        else if (ch === '"') in_str = false;
+        continue;
+      }
+      if (ch === '"') {
+        in_str = true;
+        continue;
+      }
+      if (ch === '[' || ch === '{') depth++;
+      else if (ch === ']' || ch === '}') {
+        depth--;
+        if (depth <= 0) {
+          if (depth === 0) out.push({ start: i, end: j + 1, raw: text.slice(i, j + 1) });
+          i = j; // skip past this span so nested arrays are not re-scanned
+          break;
+        }
+      }
+    }
   }
-  if (!Array.isArray(parsed) || !parsed.length) return { prose: text, questions: null };
+  return out;
+};
+const _validate_xuda_questions = function (parsed) {
+  if (!Array.isArray(parsed) || !parsed.length) return null;
   const validated = parsed
     .map((q) => {
       if (!q || typeof q.question !== 'string') return null;
@@ -5847,11 +6023,61 @@ const extract_xuda_questions = function (text) {
       return { question: q.question.trim(), options };
     })
     .filter(Boolean);
-  if (!validated.length) return { prose: text, questions: null };
-  return {
-    prose: text.slice(0, match.index).trim(),
-    questions: validated,
-  };
+  return validated.length ? validated : null;
+};
+const extract_xuda_questions = function (text) {
+  if (typeof text !== 'string') return { prose: text, questions: null };
+  // Models do NOT reliably wrap the payload. In practice they drop the tags and
+  // emit a bare array, or fence it as ```json, or add a closing remark AFTER the
+  // block. The old pattern demanded the exact tags anchored to end-of-string, so
+  // any of those shipped the raw JSON straight into the chat bubble. Accept the
+  // three real-world shapes, most explicit first, and never anchor to the end:
+  // take the LAST match and cut it out of the prose wherever it sits.
+  const patterns = [
+    /<xuda-questions>\s*([\s\S]+?)\s*<\/xuda-questions>/g,
+    /```(?:xuda-questions|json)?\s*(\[[\s\S]*?\])\s*```/g,
+  ];
+  for (const re of patterns) {
+    let m;
+    let last = null;
+    while ((m = re.exec(text)) !== null) last = m;
+    if (!last) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(last[1]);
+    } catch (e) {
+      continue;
+    }
+    const validated = _validate_xuda_questions(parsed);
+    if (!validated) continue;
+    const prose = (text.slice(0, last.index) + text.slice(last.index + last[0].length)).trim();
+    return { prose, questions: validated };
+  }
+  // Last resort: an unwrapped array pasted straight into the prose, which is the
+  // most common way this arrives. Regex cannot do this, because the nested
+  // `options` arrays make a lazy match close on the inner "]" and a greedy one
+  // swallow trailing prose, so scan for balanced brackets instead. Gated on the
+  // structural keys plus full validation so ordinary JSON samples are ignored.
+  const cands = _scan_json_arrays(text);
+  for (let k = cands.length - 1; k >= 0; k--) {
+    const cand = cands[k];
+    if (!/"question"\s*:/.test(cand.raw) || !/"options"\s*:/.test(cand.raw)) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(cand.raw);
+    } catch (e) {
+      continue;
+    }
+    const validated = _validate_xuda_questions(parsed);
+    if (!validated) continue;
+    return { prose: (text.slice(0, cand.start) + text.slice(cand.end)).trim(), questions: validated };
+  }
+  return { prose: text, questions: null };
 };
 // Resolve the structured context object passed by newer clients (ProjectAiPanel

package/index_ms.mjs CHANGED Viewed

@@ -133,6 +133,10 @@ export const diagnose_vps_snapshot = async function (...args) {
   return await broker.send_to_queue("diagnose_vps_snapshot", ...args);
 };
+export const generate_release_notes = async function (...args) {
+  return await broker.send_to_queue("generate_release_notes", ...args);
+};
 export const create_openai_conversation = async function (...args) {
   return await broker.send_to_queue("create_openai_conversation", ...args);
 };

package/index_msa.mjs CHANGED Viewed

@@ -133,6 +133,10 @@ export const diagnose_vps_snapshot =  function (...args) {
    broker.send_to_queue_async("diagnose_vps_snapshot", ...args);
 };
+export const generate_release_notes =  function (...args) {
+   broker.send_to_queue_async("generate_release_notes", ...args);
+};
 export const create_openai_conversation =  function (...args) {
    broker.send_to_queue_async("create_openai_conversation", ...args);
 };

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/ai_module",
-  "version": "1.1.5637",
+  "version": "1.1.5639",
   "description": "Xuda AI Module",
   "main": "index.mjs",
   "type": "module",