@wanasapps/deluge-core 1.2.0 → 1.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wanasapps/deluge-core",
-  "version": "1.2.0",
-  "description": "Deluge language tooling for every Zoho product: formatter, source transforms, TextMate grammar, snippets, an editor-agnostic linter, and AI-agent skills \u2014 a guide with runtime traps verified on a live org, plus a complete reference of every statement, data type, built-in function and integration task generated from Zoho's Deluge documentation. No I/O, no HTTP, no editor dependency.",
+  "version": "1.3.0",
+  "description": "Deluge language tooling for every Zoho product: formatter, source transforms, TextMate grammar, snippets, an editor-agnostic linter, and AI-agent skills — a guide with runtime traps verified on a live org, plus a complete reference of every statement, data type, built-in function and integration task generated from Zoho's Deluge documentation. No I/O, no HTTP, no editor dependency.",
   "main": "src/index.js",
   "files": [
     "src",

package/scripts/check-cores-published.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+/**
+ * Refuse to publish before the @wanasapps packages this one depends on.
+ *
+ * These five packages are independent repos, not a workspace. Publishing a
+ * consumer before its cores yields a package npm cannot install — it has
+ * happened before (zone 0.4.3). CI runs this before `npm ci`, so the failure
+ * names the missing package instead of surfacing as a bare ETARGET.
+ */
+'use strict';
+const cp = require('child_process');
+const pj = require('../package.json');
+
+const deps = { ...(pj.dependencies || {}), ...(pj.peerDependencies || {}) };
+const wanas = Object.entries(deps).filter(([n]) => n.startsWith('@wanasapps'));
+
+if (!wanas.length) {
+  console.log('no @wanasapps dependencies — nothing to check');
+  process.exit(0);
+}
+
+// A lockfile that records a local link resolves on the dev machine and
+// nowhere else: `npm ci` creates the link, exits 0, and the module is
+// missing at runtime. Caught zoho-api 1.1.1 in CI.
+try {
+  const lock = require('../package-lock.json');
+  const linked = Object.entries(lock.packages || {})
+    .filter(([, v]) => v && v.link)
+    .map(([k]) => k.replace('node_modules/', ''));
+  if (linked.length) {
+    console.error(`  LINKED   ${linked.join(', ')} recorded as a local link in package-lock.json`);
+    console.error('           Regenerate it against the registry: npm install --package-lock-only');
+    process.exit(1);
+  }
+} catch { /* no lockfile is fine */ }
+
+let missing = 0;
+for (const [name, range] of wanas) {
+  let found = '';
+  try {
+    // --json so a range matching several versions returns an array, rather
+    // than npm's "<name>@<ver> '<ver>'" lines, which are awkward to parse.
+    const raw = cp.execSync(`npm view ${name}@"${range}" version --json`, {
+      encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore']
+    }).trim();
+    const parsed = raw ? JSON.parse(raw) : null;
+    found = Array.isArray(parsed) ? parsed[parsed.length - 1] : (parsed || '');
+  } catch { /* not published, or the range matches nothing */ }
+
+  if (found) {
+    console.log(`  ok       ${name}@${range} -> ${found}`);
+  } else {
+    console.error(`  MISSING  ${name}@${range} does not resolve on npm`);
+    missing++;
+  }
+}
+
+if (missing) {
+  console.error('\nPublish bottom-up:');
+  console.error('  deluge-core -> zoho-auth -> zoho-api -> zcrm-core -> wanas-zone-cli');
+  process.exit(1);
+}
+console.log('all @wanasapps dependencies resolve on npm');

package/scripts/gen-skill.js

@@ -55,10 +55,13 @@ const prodOrder = ['crm', ...[...taskByProd.keys()].filter((k) => k !== 'crm').s
 // ---------------------------------------------------------------------------
 // DELUGE_SKILL.md — guide + complete name index
 // ---------------------------------------------------------------------------
+const fnCount = [...fnByCat.values()].reduce((n, v) => n + v.length, 0);
+const taskCount = [...taskByProd.values()].reduce((n, v) => n + v.length, 0);
+
 const skill = [];
 skill.push(guide.trimEnd(), '', '---', '');
 skill.push('# Part 2 — Everything that exists (names only)', '');
-skill.push(`Every documented statement, built-in function and integration task, by name, generated from ${ref.source}. If a name is not here, it does not exist in Deluge — do not invent one. For a function's exact syntax, parameters and return type, load the companion skill \`zoho-deluge-reference\` (or run \`zone llm deluge-reference\`).`, '');
+skill.push(`What exists in Deluge, generated from ${ref.source}. Statements and data types are listed in full below because they are few. The ${fnCount} built-in functions and ${taskCount} integration tasks are summarised by category — **every one of them is named, with its exact syntax, parameters and return type, in the companion reference**: read \`references/REFERENCE.md\` in this skill folder, or run \`zone llm deluge-reference\`. If a name is not there, it does not exist in Deluge — do not invent one.`, '');
 
 skill.push('## Statements', '');
 skill.push((ref.statements || []).map((s) => `\`${s.name}\``).concat(['`invokeurl`', '`info`', '`return`']).join(' · '), '');
@@ -66,17 +69,16 @@ skill.push((ref.statements || []).map((s) => `\`${s.name}\``).concat(['`invokeur
 skill.push('## Data types', '');
 skill.push((ref.datatypes || []).map((d) => `\`${d.name}\``).join(' · '), '');
 
-skill.push('## Built-in functions', '');
-for (const cat of catOrder) {
-  const names = fnByCat.get(cat).slice().sort(byName).map((f) => `\`${f.name}\``);
-  skill.push(`**${cat}** (${names.length}): ${names.join(', ')}`, '');
-}
+// Categories and counts, not 337 names. Every one of those names already
+// appears in DELUGE_REFERENCE.md WITH its syntax, so listing them here bought
+// nothing and cost ~1,800 tokens on every trigger — pushing the skill body over
+// the Agent Skills spec's 5,000-token recommendation. The agent is told where
+// to look instead, which preserves the "do not invent a name" guarantee.
+skill.push('## Built-in functions — ' + fnCount + ' across ' + catOrder.length + ' categories', '');
+skill.push(catOrder.map((cat) => `**${cat}** (${fnByCat.get(cat).length})`).join(' · '), '');
 
-skill.push('## Integration tasks', '');
-for (const prod of prodOrder) {
-  const names = taskByProd.get(prod).slice().sort(byName).map((t) => `\`${t.name}\``);
-  skill.push(`**${LABEL[prod] || prod}** (${names.length}): ${names.join(', ')}`, '');
-}
+skill.push('## Integration tasks — ' + taskCount + ' across ' + prodOrder.length + ' products', '');
+skill.push(prodOrder.map((prod) => `**${LABEL[prod] || prod}** (${taskByProd.get(prod).length})`).join(' · '), '');
 
 skill.push('## System variables', '');
 skill.push('`zoho.currentdate`, `zoho.currenttime`, `zoho.loginuser`, `zoho.loginuser.name` (Creator), `zoho.loginuserid`, `zoho.adminuser`, `zoho.adminuserid`, `zoho.appname` (Creator), `zoho.appuri` (Creator), `zoho.ipaddress`, `zoho.device.type` (Creator).', '');

package/src/format/signature.js

@@ -1,70 +1,70 @@
-/**
- * Minimal parser for the *signature line* of a Deluge function script.
- *
- * Zoho stores a function's code with its signature on the first meaningful
- * line, e.g.:
- *
- *   string standalone.Get_Assistants()
- *   void   automation.k_test(String Data)
- *
- * We only need the signature to learn the function's namespace + api name (to
- * build the test URL and enforce the standalone-only rule) and its declared
- * arguments (to prompt for values). The full script is still submitted verbatim
- * to Zoho — this parser never rewrites the code.
- */
-
-/**
- * Parse the signature of a Deluge script.
- * @param {string} scriptText - The full Deluge source.
- * @returns {{returnType: string|null, namespace: string|null, apiName: string|null, args: Array<{type:string,name:string}>}}
- */
-function parseSignature(scriptText) {
-  const result = { returnType: null, namespace: null, apiName: null, args: [] };
-  if (!scriptText || typeof scriptText !== 'string') return result;
-
-  // Find the first non-comment, non-blank line — that's the signature.
-  let sigLine = null;
-  let inBlockComment = false;
-  for (const raw of scriptText.split('\n')) {
-    let line = raw.trim();
-    if (!line) continue;
-
-    if (inBlockComment) {
-      const end = line.indexOf('*/');
-      if (end === -1) continue;
-      line = line.slice(end + 2).trim();
-      inBlockComment = false;
-      if (!line) continue;
-    }
-    if (line.startsWith('//')) continue;
-    if (line.startsWith('/*')) {
-      const end = line.indexOf('*/');
-      if (end === -1) { inBlockComment = true; continue; }
-      line = line.slice(end + 2).trim();
-      if (!line) continue;
-    }
-    sigLine = line;
-    break;
-  }
-  if (!sigLine) return result;
-
-  // <returnType> <namespace>.<apiName>(<args>)
-  const m = sigLine.match(/^(\w+)\s+([A-Za-z0-9_]+)\.([A-Za-z0-9_]+)\s*\(([^)]*)\)/);
-  if (!m) return result;
-
-  result.returnType = m[1];
-  result.namespace = m[2];
-  result.apiName = m[3];
-
-  const argsRaw = m[4].trim();
-  if (argsRaw) {
-    for (const part of argsRaw.split(',')) {
-      // each param is "<type> <name>" (e.g. "String Data", "int count")
-      const am = part.trim().match(/^(\S+)\s+([A-Za-z0-9_]+)$/);
-      if (am) result.args.push({ type: am[1], name: am[2] });
-    }
-  }
-  return result;
-}
-
-module.exports = { parseSignature };
+/**
+ * Minimal parser for the *signature line* of a Deluge function script.
+ *
+ * Zoho stores a function's code with its signature on the first meaningful
+ * line, e.g.:
+ *
+ *   string standalone.Get_Assistants()
+ *   void   automation.k_test(String Data)
+ *
+ * We only need the signature to learn the function's namespace + api name (to
+ * build the test URL and enforce the standalone-only rule) and its declared
+ * arguments (to prompt for values). The full script is still submitted verbatim
+ * to Zoho — this parser never rewrites the code.
+ */
+
+/**
+ * Parse the signature of a Deluge script.
+ * @param {string} scriptText - The full Deluge source.
+ * @returns {{returnType: string|null, namespace: string|null, apiName: string|null, args: Array<{type:string,name:string}>}}
+ */
+function parseSignature(scriptText) {
+  const result = { returnType: null, namespace: null, apiName: null, args: [] };
+  if (!scriptText || typeof scriptText !== 'string') return result;
+
+  // Find the first non-comment, non-blank line — that's the signature.
+  let sigLine = null;
+  let inBlockComment = false;
+  for (const raw of scriptText.split('\n')) {
+    let line = raw.trim();
+    if (!line) continue;
+
+    if (inBlockComment) {
+      const end = line.indexOf('*/');
+      if (end === -1) continue;
+      line = line.slice(end + 2).trim();
+      inBlockComment = false;
+      if (!line) continue;
+    }
+    if (line.startsWith('//')) continue;
+    if (line.startsWith('/*')) {
+      const end = line.indexOf('*/');
+      if (end === -1) { inBlockComment = true; continue; }
+      line = line.slice(end + 2).trim();
+      if (!line) continue;
+    }
+    sigLine = line;
+    break;
+  }
+  if (!sigLine) return result;
+
+  // <returnType> <namespace>.<apiName>(<args>)
+  const m = sigLine.match(/^(\w+)\s+([A-Za-z0-9_]+)\.([A-Za-z0-9_]+)\s*\(([^)]*)\)/);
+  if (!m) return result;
+
+  result.returnType = m[1];
+  result.namespace = m[2];
+  result.apiName = m[3];
+
+  const argsRaw = m[4].trim();
+  if (argsRaw) {
+    for (const part of argsRaw.split(',')) {
+      // each param is "<type> <name>" (e.g. "String Data", "int count")
+      const am = part.trim().match(/^(\S+)\s+([A-Za-z0-9_]+)$/);
+      if (am) result.args.push({ type: am[1], name: am[2] });
+    }
+  }
+  return result;
+}
+
+module.exports = { parseSignature };