orbit-code-ai 0.1.35 → 0.1.36

package/dist/cli.mjs

@@ -83759,7 +83759,7 @@ async function printStartupScreen() {
   const sLen = ` ● ${sL}    Ready — type /help to begin`.length;
   out.push(boxRow(sRow, W2, sLen));
   out.push(`${rgb(...BORDER)}╚${"═".repeat(W2 - 2)}╝${RESET}`);
-  out.push(`  ${DIM}${rgb(...DIMCOL)}orbit-code ${RESET}${rgb(...ACCENT)}v${"0.1.35"}${RESET}`);
+  out.push(`  ${DIM}${rgb(...DIMCOL)}orbit-code ${RESET}${rgb(...ACCENT)}v${"0.1.36"}${RESET}`);
   out.push("");
   process.stdout.write(out.join(`
 `) + `
@@ -334266,7 +334266,7 @@ function getAnthropicEnvMetadata() {
 function getBuildAgeMinutes() {
   if (false)
     ;
-  const buildTime = new Date("2026-07-01T09:45:32.083Z").getTime();
+  const buildTime = new Date("2026-07-01T10:12:07.638Z").getTime();
   if (isNaN(buildTime))
     return;
   return Math.floor((Date.now() - buildTime) / 60000);
@@ -358683,7 +358683,7 @@ function buildPrimarySection() {
   }, undefined, false, undefined, this);
   return [{
     label: "Version",
-    value: "0.1.35"
+    value: "0.1.36"
   }, {
     label: "Session name",
     value: nameValue
@@ -470794,7 +470794,7 @@ function WelcomeV2() {
             dimColor: true,
             children: [
               "v",
-              "0.1.35",
+              "0.1.36",
               " "
             ]
           }, undefined, true, undefined, this)
@@ -470994,7 +470994,7 @@ function WelcomeV2() {
           dimColor: true,
           children: [
             "v",
-            "0.1.35",
+            "0.1.36",
             " "
           ]
         }, undefined, true, undefined, this)
@@ -471220,7 +471220,7 @@ function AppleTerminalWelcomeV2(t0) {
         dimColor: true,
         children: [
           "v",
-          "0.1.35",
+          "0.1.36",
           " "
         ]
       }, undefined, true, undefined, this);
@@ -471474,7 +471474,7 @@ function AppleTerminalWelcomeV2(t0) {
       dimColor: true,
       children: [
         "v",
-        "0.1.35",
+        "0.1.36",
         " "
       ]
     }, undefined, true, undefined, this);
@@ -510010,6 +510010,35 @@ async function describeProcedure(conn, schema, name) {
   }
   return { schema, name, params, resultSet, resultSetUndescribable };
 }
+async function findProcedures(conn, name) {
+  const bare = name.replace(/^.*\./, "");
+  const rows = await runQuery(conn, `SELECT s.name AS [schema],
+            p.name AS [name],
+            CAST(ISNULL(OBJECTPROPERTY(p.object_id, 'IsEncrypted'), 0) AS INT) AS [isEncrypted],
+            CAST(HAS_PERMS_BY_NAME(QUOTENAME(s.name) + N'.' + QUOTENAME(p.name),
+                 'OBJECT', 'VIEW DEFINITION') AS INT) AS [canViewDef]
+       FROM sys.procedures p
+       JOIN sys.schemas s ON p.schema_id = s.schema_id
+      WHERE p.name = @name
+      ORDER BY CASE WHEN s.name = 'dbo' THEN 0 ELSE 1 END, s.name`, [{ name: "name", type: "NVarChar", value: bare }]);
+  return rows.map((r) => ({
+    schema: String(r.schema),
+    name: String(r.name),
+    isEncrypted: Number(r.isEncrypted) === 1,
+    canViewDefinition: Number(r.canViewDef) === 1
+  }));
+}
+async function getDbContext(conn) {
+  const rows = await runQuery(conn, `SELECT DB_NAME() AS [database],
+            SUSER_SNAME() AS [login],
+            (SELECT COUNT(*) FROM sys.procedures) AS [visibleProcCount]`);
+  const r = rows[0] ?? {};
+  return {
+    database: String(r.database ?? "(unknown)"),
+    login: String(r.login ?? "(unknown)"),
+    visibleProcCount: Number(r.visibleProcCount ?? 0)
+  };
+}
 async function getProcedureDefinition(conn, schema, name) {
   const rows = await runQuery(conn, `SELECT OBJECT_DEFINITION(OBJECT_ID(@obj)) AS definition`, [{ name: "obj", type: "NVarChar", value: `${schema}.${name}` }]);
   const def2 = rows[0]?.definition;
@@ -510191,11 +510220,52 @@ ${params}
 First result set:
 ${cols}${GROUND}`;
 }
+async function resolveProc(conn, schema, name) {
+  let matches;
+  try {
+    matches = await findProcedures(conn, name);
+  } catch {
+    return { schema, name };
+  }
+  if (matches.length === 0)
+    return { schema, name };
+  const exact = matches.find((m) => m.schema.toLowerCase() === schema.toLowerCase());
+  const readable2 = matches.find((m) => m.canViewDefinition && !m.isEncrypted);
+  const chosen = exact ?? readable2 ?? matches[0];
+  return { schema: chosen.schema, name: chosen.name };
+}
+async function diagnoseMissingProc(conn, name) {
+  let matches;
+  let ctx;
+  try {
+    [matches, ctx] = await Promise.all([
+      findProcedures(conn, name),
+      getDbContext(conn)
+    ]);
+  } catch (e2) {
+    return `Could not read "${name}", and the diagnostic query also failed: ${e2.message}. Ask the user to re-check the /sql connection.`;
+  }
+  const where = `database "${ctx.database}" as login "${ctx.login}" (${ctx.visibleProcCount} procedure(s) visible to this login)`;
+  if (matches.length === 0) {
+    return `No stored procedure named "${name}" is VISIBLE in ${where}. SQL Server hides objects a login has no permission on, so this means EITHER it does not exist in this database OR the connected login cannot see it. Do NOT tell the user the procedure "doesn't exist" — instead: (1) confirm the connection is on the right database (run /sql status); (2) confirm this login has VIEW DEFINITION / metadata access, or reconnect with a login that does. Then retry.`;
+  }
+  const lines = matches.map((m) => `  - ${m.schema}.${m.name}${m.isEncrypted ? " [WITH ENCRYPTION]" : ""}${m.canViewDefinition ? "" : " [login lacks VIEW DEFINITION]"}`).join(`
+`);
+  const readable2 = matches.find((m) => m.canViewDefinition && !m.isEncrypted);
+  const guidance = readable2 ? `It IS present and readable as ${readable2.schema}.${readable2.name} — re-run with that exact schema-qualified name.` : matches.some((m) => m.isEncrypted) ? `It exists but is defined WITH ENCRYPTION; its T-SQL cannot be read. Tell the user the source is unavailable.` : `It exists but login "${ctx.login}" lacks VIEW DEFINITION on it. Grant VIEW DEFINITION or reconnect with a privileged login.`;
+  return `"${name}" was found in ${where}, under:
+${lines}
+
+${guidance}`;
+}
 async function runSource(conn, schema, name) {
-  const def2 = await getProcedureDefinition(conn, schema, name);
+  const r = await resolveProc(conn, schema, name);
+  const def2 = await getProcedureDefinition(conn, r.schema, r.name);
   if (!def2) {
-    return `Could not read the source of ${schema}.${name}. Either it does not exist, or it is defined WITH ENCRYPTION (OBJECT_DEFINITION returns NULL for encrypted procedures). Do not guess its contents — tell the user it is unavailable.`;
+    return await diagnoseMissingProc(conn, name);
   }
+  schema = r.schema;
+  name = r.name;
   const MAX = 24000;
   const body = def2.length > MAX ? `${def2.slice(0, MAX)}
 -- …[truncated; ${def2.length} chars total]…` : def2;
@@ -510265,42 +510335,39 @@ ${lines}
 
 These are ACTUAL values from the database. Use them exactly as returned — never alter, round, or invent field values. State only what appears above; if a value is not shown, say it is not shown.`;
 }
-async function runTestData(conn, schema, name, caseHint) {
-  const def2 = await getProcedureDefinition(conn, schema, name);
-  if (!def2) {
-    return `Could not read the source of ${schema}.${name} (missing or WITH ENCRYPTION). Without the real T-SQL I cannot know which tables/columns to sample. Ask the user for the correct procedure name (try /sql procs) — do NOT guess test data.`;
-  }
-  const sp = await describeProcedure(conn, schema, name);
-  const params = sp.params.map((p) => `  - ${p.isOutput ? "OUT" : "IN "} @${p.name} : ${p.dataType}${p.maxLength ? `(${p.maxLength})` : ""}`).join(`
-`) || "  (no parameters)";
-  const MAX = 24000;
-  const body = def2.length > MAX ? `${def2.slice(0, MAX)}
--- …[truncated]…` : def2;
+function runTestData(appName, caseHint) {
   const wanted = caseHint || "happy";
-  return `Goal: produce REAL, runnable test-data for a "${wanted}" case, expressed as the application's input body.
+  return `Goal: produce REAL, runnable "${wanted}" test-data for the ACE application "${appName}", expressed as the application's request input body.
 
-Ground truth for ${schema}.${name} (live database):
+IMPORTANT: "${appName}" is an APPLICATION name (a project/folder in this workspace), NOT a stored procedure. One application typically calls one OR MORE stored procedures — you must find them ALL and gather test data for each.
 
-Parameters (these are what the SP consumes — trace each back to a request-body field):
-${params}
+Do this, in order:
 
-Actual T-SQL source:
-\`\`\`sql
-${body}
-\`\`\`
+1. Locate the application in the workspace. Glob for its folder (e.g. \`**/${appName}/**\`); its ESQL lives under \`.../com/qiwa/esb/<appnamelowercase>/*.esql\` and its contract under \`.../${appName}/XSD&Swagger/\`.
+   - If NO application named "${appName}" exists but a stored procedure by that name does, fall back to treating it as a single SP.
 
-Do this, in order:
-1. From the T-SQL above, identify the driving table(s) and the WHERE/branch conditions the input parameters flow into. For a "${wanted}" case:
-   - happy    → conditions that make the SP's main/success path return a row.
-   - error/not-found → a key that does NOT exist, or values that hit the SP's empty-result / validation branch.
-   - boundary → real extremes (e.g. longest value, min/max, nullable edges) drawn from the actual data.
-2. Write ONE read-only SELECT that pulls a REAL row supplying the parameter values for that case (e.g. \`SELECT TOP 1 <param-columns> FROM <table> WHERE <branch conditions>\`). It MUST be a single SELECT/CTE — no other statements.
-3. Run it by invoking the /sql skill with:  query <your SELECT>
-   (This executes it against the live DB through the read-only gate and returns the actual rows.)
-4. Take the returned real values and map each SP parameter back to its request-body field by reading this project's ESQL (Grep the working directory for "${name}" to find the CALL and the field-to-parameter mapping) and the app's XSD (the input body field names).
-5. Return the finished input body (XML matching the app's request schema) with the concrete real values filled in, and show the exact SELECT you ran so the developer can see where each value came from.
-
-Data-handling notice (state this once to the user): these values are REAL data pulled from the connected database and may include personal/production data. Return them as-is; do not fabricate or substitute values. If the SELECT returns no rows, say so plainly — for a happy case it means no qualifying data exists; do not invent a row.`;
+2. Read the app's REQUEST contract: its XSD (\`XSD&Swagger/XSD/${appName}.xsd\`) → the input-body field names and types; skim the msgflow/ESQL to see how the request is shaped.
+
+3. Enumerate EVERY stored procedure the app calls. Grep the app's ESQL for:
+   - \`EXTERNAL NAME "<schema>.<proc>"\` (LANGUAGE DATABASE procedure declarations), and their CALL sites,
+   - any PASSTHRU / Database-node inline SQL.
+   Collect the real \`schema.proc\` for each. List them for the user before continuing.
+
+4. For EACH stored procedure found:
+   a. Fetch its REAL T-SQL by invoking the /sql skill with:  source <schema.proc>
+      (If the source is unavailable — encrypted or no VIEW DEFINITION — say so for that SP and skip to the next; do not fabricate its logic.)
+   b. From that source, identify the driving table(s) and the WHERE/branch conditions the SP's input parameters flow into, for a "${wanted}" case:
+      - happy    → values that make the SP's main/success path return a row.
+      - error/not-found → a key that does NOT exist, or values that hit the empty-result / validation branch.
+      - boundary → real extremes (longest value, min/max, nullable edges) drawn from the actual data.
+   c. Write ONE read-only SELECT that pulls a REAL row supplying those parameter values, and run it by invoking the /sql skill with:  query <your SELECT>
+      (single SELECT/CTE only; it runs through the read-only gate and returns actual rows).
+
+5. Combine the real values from all the SPs and map them back onto the app's REQUEST input-body fields — trace each SP parameter to the request field that feeds it (via the ESQL field→parameter mapping) and use the XSD field names.
+
+6. Return the finished request input body (XML matching the app's request schema) with concrete REAL values filled in. Then, per SP, show the exact SELECT you ran so the developer can see exactly where each value came from.
+
+Data-handling notice (state once): these are REAL values from the connected database and may include personal/production data. Return them as-is; never fabricate. If a SELECT returns no rows, say so plainly — for a happy case it means no qualifying data exists; do not invent a row. If the app calls no stored procedures at all, build the input body from the XSD types alone and clearly mark those values as synthetic (no DB row backs them).`;
 }
 async function handle(args) {
   const trimmed = args.trim();
@@ -510403,16 +510470,12 @@ Do NOT attempt to answer database questions — you have no connection or data.`
   }
   if (firstTok === "testdata" || firstTok === "test-data") {
     if (!restStr)
-      return "Usage: /sql testdata <schema.proc|AppName> [happy|error|boundary] [notes]";
-    const tokens = restStr.split(/\s+/);
-    const target = extractProcName(restStr) ?? tokens[0];
-    const { schema: schema2, name: name2 } = splitProc(target);
-    const caseHint = restStr.match(/\b(happy|error|not[- ]?found|boundary|edge)\b/i)?.[1] ?? "";
-    try {
-      return await runTestData(conn, schema2, name2, caseHint.toLowerCase());
-    } catch (e2) {
-      return `Failed to prepare test data for ${schema2}.${name2}: ${e2.message}`;
-    }
+      return "Usage: /sql testdata <AppName> [happy|error|boundary]  (AppName is the ACE application, not a stored procedure)";
+    const caseMatch = restStr.match(/\b(happy|error|not[- ]?found|boundary|edge)\b/i);
+    const caseHint = caseMatch?.[1]?.toLowerCase() ?? "";
+    const withoutCase = caseMatch ? restStr.replace(caseMatch[0], " ") : restStr;
+    const appName = withoutCase.trim().split(/\s+/)[0].replace(/[[\]"';,]/g, "");
+    return runTestData(appName, caseHint);
   }
   const intent = inferIntent(trimmed);
   if (intent === "list" && !extractProcName(trimmed)) {
@@ -510443,7 +510506,7 @@ function registerSqlSkill() {
   registerBundledSkill({
     name: "sql",
     description: "Connect to a SQL Server database (read-only) to list/describe stored procedures, generate the ESQL SP call, verify how an ACE app calls an SP, or produce real test-data input for an application from live tables — all from live DB metadata and gated read-only SELECTs.",
-    whenToUse: "When the user asks about the SQL database, stored procedures (their inputs/outputs), wants an ESQL stored-procedure CALL generated from the DB, wants to verify SP parameters used inside an ACE application, or wants real test-data (a happy/error/boundary input body) for an application built from actual rows in the database.",
+    whenToUse: "When the user asks about the SQL database, stored procedures (their inputs/outputs), wants an ESQL stored-procedure CALL generated from the DB, wants to verify SP parameters used inside an ACE application, or wants real test-data for an ACE APPLICATION (a happy/error/boundary request input body) — discovering every SP the app calls and sampling actual rows from the database.",
     argumentHint: "connect|status|procs|describe|gen|verify|testdata|query … (or plain English)",
     userInvocable: true,
     allowedTools: ["Read", "Glob", "Grep"],
@@ -510475,7 +510538,7 @@ Subcommands (also understands plain English, e.g. "/sql details of the SP Get_Us
 - \`/sql source <schema.proc>\` — the actual T-SQL body of the procedure (read the real code).
 - \`/sql gen <schema.proc>\` — generate the ESQL PROCEDURE declaration + CALL.
 - \`/sql verify <schema.proc>\` — pull the real SP signature, then check how this project's ESQL calls it.
-- \`/sql testdata <schema.proc|AppName> [happy|error|boundary] [notes]\` — read the SP's real T-SQL, pull a REAL matching row from the database, and return it as the application's input body.
+- \`/sql testdata <AppName> [happy|error|boundary]\` — for an ACE APPLICATION, find EVERY stored procedure it calls, read each SP's real T-SQL, pull REAL matching rows from the database, and return the application's request input body.
 - \`/sql query <SELECT …>\` — run one read-only SELECT (SELECT/CTE only, capped to ${READONLY_ROW_CAP} rows). Used by /sql testdata to fetch real rows.
 
 Metadata/verify/gen are read-only catalog lookups. \`testdata\`/\`query\` execute a single gated SELECT against real tables and return ACTUAL data (which may include personal/production data).`;
@@ -527130,7 +527193,7 @@ Usage: orbit --remote "your task description"`, () => gracefulShutdown(1));
         pendingHookMessages
       }, renderAndRun);
     }
-  }).version("0.1.35 (Orbit AI)", "-v, --version", "Output the version number");
+  }).version("0.1.36 (Orbit AI)", "-v, --version", "Output the version number");
   program2.option("-w, --worktree [name]", "Create a new git worktree for this session (optionally specify a name)");
   program2.option("--tmux", "Create a tmux session for the worktree (requires --worktree). Uses iTerm2 native panes when available; use --tmux=classic for traditional tmux.");
   if (canUserConfigureAdvisor()) {
@@ -527652,7 +527715,7 @@ if (false) {}
 async function main2() {
   const args = process.argv.slice(2);
   if (args.length === 1 && (args[0] === "--version" || args[0] === "-v" || args[0] === "-V")) {
-    console.log(`${"0.1.35"} (Orbit AI)`);
+    console.log(`${"0.1.36"} (Orbit AI)`);
     return;
   }
   if (args.includes("--provider")) {
@@ -527756,4 +527819,4 @@ async function main2() {
 }
 main2();
 
-//# debugId=29BC5C9893E4168464756E2164756E21
+//# debugId=AFCC06C9D77C087364756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orbit-code-ai",
-  "version": "0.1.35",
+  "version": "0.1.36",
   "description": "Orbit AI – Your AI-powered IBM ACE coding companion",
   "type": "module",
   "author": "moenawaf",