orbit-code-ai 0.1.34 → 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.34"}${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-01T08:02:14.526Z").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.34"
+    value: "0.1.36"
   }, {
     label: "Session name",
     value: nameValue
@@ -470794,7 +470794,7 @@ function WelcomeV2() {
             dimColor: true,
             children: [
               "v",
-              "0.1.34",
+              "0.1.36",
               " "
             ]
           }, undefined, true, undefined, this)
@@ -470994,7 +470994,7 @@ function WelcomeV2() {
           dimColor: true,
           children: [
             "v",
-            "0.1.34",
+            "0.1.36",
             " "
           ]
         }, undefined, true, undefined, this)
@@ -471220,7 +471220,7 @@ function AppleTerminalWelcomeV2(t0) {
         dimColor: true,
         children: [
           "v",
-          "0.1.34",
+          "0.1.36",
           " "
         ]
       }, undefined, true, undefined, this);
@@ -471474,7 +471474,7 @@ function AppleTerminalWelcomeV2(t0) {
       dimColor: true,
       children: [
         "v",
-        "0.1.34",
+        "0.1.36",
         " "
       ]
     }, undefined, true, undefined, this);
@@ -509921,9 +509921,39 @@ async function testConnection(conn) {
   await runQuery(conn, "SELECT 1 AS ok");
   return true;
 }
-var import_tedious;
+function assertReadOnlySelect(sql) {
+  const cleaned = sql.trim().replace(/;\s*$/, "").trim();
+  if (!cleaned)
+    throw new ReadOnlyGuardError("Empty query.");
+  if (cleaned.includes(";"))
+    throw new ReadOnlyGuardError('Only a single statement is allowed (no ";" chaining).');
+  if (cleaned.includes("--") || cleaned.includes("/*"))
+    throw new ReadOnlyGuardError("Comments are not allowed in the query.");
+  if (!/^(with|select)\b/i.test(cleaned))
+    throw new ReadOnlyGuardError("Query must start with SELECT (or WITH … SELECT).");
+  const banned = cleaned.match(FORBIDDEN_TOKENS);
+  if (banned)
+    throw new ReadOnlyGuardError(`Query contains a disallowed keyword: "${banned[0]}". Only read-only SELECTs are permitted.`);
+  return cleaned;
+}
+async function runReadOnlySelect(conn, sql, maxRows = READONLY_ROW_CAP) {
+  const gated = assertReadOnlySelect(sql);
+  const cap = Math.max(1, Math.min(maxRows, READONLY_ROW_CAP));
+  const batch = `SET ROWCOUNT ${cap};
+${gated};
+SET ROWCOUNT 0;`;
+  return runQuery(conn, batch);
+}
+var import_tedious, READONLY_ROW_CAP = 50, FORBIDDEN_TOKENS, ReadOnlyGuardError;
 var init_mssqlClient = __esm(() => {
   import_tedious = __toESM(require_tedious(), 1);
+  FORBIDDEN_TOKENS = /\b(insert|update|delete|merge|drop|alter|truncate|create|exec|execute|grant|revoke|into|waitfor|shutdown|reconfigure|backup|restore|openrowset|openquery|opendatasource|bulk|sp_[a-z0-9_]+|xp_[a-z0-9_]+)\b/i;
+  ReadOnlyGuardError = class ReadOnlyGuardError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "ReadOnlyGuardError";
+    }
+  };
 });
 
 // src/utils/sql/spMetadata.ts
@@ -509980,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;
@@ -510161,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;
@@ -510205,6 +510305,70 @@ How to judge matches (ESQL LANGUAGE DATABASE rules):
 - REAL mismatches are: parameter COUNT, ORDER, direction (IN/OUT), type incompatibility, and \`DYNAMIC RESULT SETS <n>\` not matching the actual result-set count above (e.g. declaring RESULT SETS 1 when the DB proc returns none — this breaks any code reading the result set).
 Report concrete functional mismatches with file:line, or confirm it matches.${GROUND}`;
 }
+function renderCell(v) {
+  if (v === null || v === undefined)
+    return "NULL";
+  if (v instanceof Date)
+    return v.toISOString();
+  if (typeof v === "object" && v !== null && "length" in v)
+    return `0x${Buffer.from(v).toString("hex")}`;
+  return String(v);
+}
+async function runQueryCmd(conn, sql) {
+  let rows;
+  try {
+    rows = await runReadOnlySelect(conn, sql);
+  } catch (e2) {
+    if (e2 instanceof ReadOnlyGuardError)
+      return `Query rejected by the read-only gate: ${e2.message}
+
+Rewrite it as a single SELECT (or WITH … SELECT) with no other statements.`;
+    return `Query failed: ${e2.message}. This is the real database error — report it; do not invent rows.`;
+  }
+  if (rows.length === 0)
+    return `The SELECT returned NO rows. This is a real result — it means no row in the database matches those conditions. Do NOT fabricate values; tell the user no matching data exists (for an "error/not-found" case this may be exactly what you want).`;
+  const cols = Object.keys(rows[0]);
+  const lines = rows.map((r, i3) => `${i3 + 1}. ${cols.map((c6) => `${c6}=${renderCell(r[c6])}`).join(", ")}`).join(`
+`);
+  return `Real rows from the live database (${rows.length}, capped at ${READONLY_ROW_CAP}):
+${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.`;
+}
+function runTestData(appName, caseHint) {
+  const wanted = caseHint || "happy";
+  return `Goal: produce REAL, runnable "${wanted}" test-data for the ACE application "${appName}", expressed as the application's request input body.
+
+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.
+
+Do this, in order:
+
+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.
+
+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();
   if (!trimmed)
@@ -510299,6 +510463,20 @@ Do NOT attempt to answer database questions — you have no connection or data.`
       return `Failed to verify ${restStr}: ${e2.message}`;
     }
   }
+  if (firstTok === "query") {
+    if (!restStr)
+      return "Usage: /sql query <SELECT …>";
+    return await runQueryCmd(conn, restStr);
+  }
+  if (firstTok === "testdata" || firstTok === "test-data") {
+    if (!restStr)
+      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)) {
     try {
@@ -510327,9 +510505,9 @@ Do NOT attempt to answer database questions — you have no connection or data.`
 function registerSqlSkill() {
   registerBundledSkill({
     name: "sql",
-    description: "Connect to a SQL Server database (read-only) to list/describe stored procedures, generate the ESQL SP call, or verify how an ACE app calls an SP — all from live DB metadata.",
-    whenToUse: "When the user asks about the SQL database, stored procedures (their inputs/outputs), wants an ESQL stored-procedure CALL generated from the DB, or wants to verify SP parameters used inside an ACE application.",
-    argumentHint: "connect|status|procs|describe|gen|verify … (or plain English)",
+    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 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"],
     async getPromptForCommand(args) {
@@ -510341,7 +510519,15 @@ function registerSqlSkill() {
     }
   });
 }
-var HELP = `# /sql — SQL Server helper (native connection)
+var HELP, GROUND = `
+
+IMPORTANT: The metadata above is the ONLY database information you have — you cannot query the DB yourself. State only what appears above; never invent, guess, or "fill in" parameters, columns, types, or procedures. If something is not shown, say it is not shown.`, STOPWORDS;
+var init_sql = __esm(() => {
+  init_bundledSkills();
+  init_connectionStore();
+  init_mssqlClient();
+  init_spMetadata();
+  HELP = `# /sql — SQL Server helper (native connection)
 
 Subcommands (also understands plain English, e.g. "/sql details of the SP Get_UserInformation"):
 - \`/sql connect server=HOST database=DB user=USER password=PASS [port=1433] [encrypt=false]\` — save the connection once (OS secure vault; password never written to disk in plaintext).
@@ -510352,15 +510538,10 @@ 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 <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.
 
-Everything is read-only and every answer comes from live DB metadata.`, GROUND = `
-
-IMPORTANT: The metadata above is the ONLY database information you have — you cannot query the DB yourself. State only what appears above; never invent, guess, or "fill in" parameters, columns, types, or procedures. If something is not shown, say it is not shown.`, STOPWORDS;
-var init_sql = __esm(() => {
-  init_bundledSkills();
-  init_connectionStore();
-  init_mssqlClient();
-  init_spMetadata();
+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).`;
   STOPWORDS = new Set([
     "sp",
     "the",
@@ -527012,7 +527193,7 @@ Usage: orbit --remote "your task description"`, () => gracefulShutdown(1));
         pendingHookMessages
       }, renderAndRun);
     }
-  }).version("0.1.34 (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()) {
@@ -527534,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.34"} (Orbit AI)`);
+    console.log(`${"0.1.36"} (Orbit AI)`);
     return;
   }
   if (args.includes("--provider")) {
@@ -527638,4 +527819,4 @@ async function main2() {
 }
 main2();
 
-//# debugId=2DF01C013452CDF264756E2164756E21
+//# debugId=AFCC06C9D77C087364756E2164756E21

package/package.json

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