@mindstudio-ai/agent 0.1.18 → 0.1.19

package/dist/postinstall.js

@@ -2201,10 +2201,11 @@ var init_query = __esm({
             limit: this._limit,
             offset: this._offset
           });
-          return { query, fallbackQuery: null, config: this._config };
+          return { type: "query", query, fallbackQuery: null, config: this._config };
         }
         const fallbackQuery = buildSelect(this._config.tableName);
         return {
+          type: "query",
           query: null,
           fallbackQuery,
           config: this._config,
@@ -2329,12 +2330,96 @@ var init_query = __esm({
   }
 });
 
+// src/db/mutation.ts
+var Mutation;
+var init_mutation = __esm({
+  "src/db/mutation.ts"() {
+    "use strict";
+    Mutation = class _Mutation {
+      /** @internal */
+      _config;
+      /** @internal */
+      _queries;
+      /** @internal */
+      _processResult;
+      /** @internal Non-batchable executor for complex mutations (e.g. removeAll JS fallback). */
+      _executor;
+      constructor(config, queries, processResult) {
+        this._config = config;
+        this._queries = queries;
+        this._processResult = processResult;
+        this._executor = void 0;
+      }
+      /**
+       * Create a non-batchable mutation that wraps an async executor.
+       * Used for operations that require multi-step execution (e.g. removeAll
+       * with a JS-fallback predicate: fetch all rows → filter → delete).
+       *
+       * Works fine when awaited standalone. Throws if passed to db.batch().
+       *
+       * @internal
+       */
+      static fromExecutor(config, executor) {
+        const m = new _Mutation(config, [], () => void 0);
+        Object.defineProperty(m, "_executor", { value: executor });
+        return m;
+      }
+      // -------------------------------------------------------------------------
+      // PromiseLike — executes on await
+      // -------------------------------------------------------------------------
+      then(onfulfilled, onrejected) {
+        return this._execute().then(onfulfilled, onrejected);
+      }
+      // -------------------------------------------------------------------------
+      // Batch compilation — used by db.batch()
+      // -------------------------------------------------------------------------
+      /**
+       * @internal Compile this mutation into SQL for batch execution.
+       * Returns the queries and a result processor.
+       *
+       * Throws if this is a non-batchable mutation (created via fromExecutor).
+       */
+      _compile() {
+        if (this._executor) {
+          throw new Error(
+            "This operation cannot be batched (e.g. removeAll with a predicate that cannot compile to SQL). Await it separately."
+          );
+        }
+        return {
+          type: "mutation",
+          queries: this._queries,
+          config: this._config,
+          processResult: this._processResult
+        };
+      }
+      /**
+       * @internal Process raw SQL results into the typed result.
+       * Used by db.batch() after executing the compiled queries.
+       */
+      static _processResults(results, compiled) {
+        return compiled.processResult(results);
+      }
+      // -------------------------------------------------------------------------
+      // Execution
+      // -------------------------------------------------------------------------
+      async _execute() {
+        if (this._executor) {
+          return this._executor();
+        }
+        const results = await this._config.executeBatch(this._queries);
+        return this._processResult(results);
+      }
+    };
+  }
+});
+
 // src/db/table.ts
 var Table;
 var init_table = __esm({
   "src/db/table.ts"() {
     "use strict";
     init_query();
+    init_mutation();
     init_predicate();
     init_sql();
     Table = class {
@@ -2399,7 +2484,7 @@ var init_table = __esm({
       sortBy(accessor) {
         return new Query(this._config).sortBy(accessor);
       }
-      async push(data) {
+      push(data) {
         const isArray = Array.isArray(data);
         const items = isArray ? data : [data];
         const queries = items.map(
@@ -2409,71 +2494,76 @@ var init_table = __esm({
             this._config.columns
           )
         );
-        const results = await this._config.executeBatch(queries);
-        const rows = results.map((r) => {
-          if (r.rows.length > 0) {
-            return deserializeRow(
-              r.rows[0],
-              this._config.columns
-            );
-          }
-          return void 0;
+        return new Mutation(this._config, queries, (results) => {
+          const rows = results.map((r) => {
+            if (r.rows.length > 0) {
+              return deserializeRow(
+                r.rows[0],
+                this._config.columns
+              );
+            }
+            return void 0;
+          });
+          return isArray ? rows : rows[0];
         });
-        return isArray ? rows : rows[0];
       }
       /**
        * Update a row by ID. Only the provided fields are changed.
        * Returns the updated row via `UPDATE ... RETURNING *`.
        */
-      async update(id, data) {
+      update(id, data) {
         const query = buildUpdate(
           this._config.tableName,
           id,
           data,
           this._config.columns
         );
-        const results = await this._config.executeBatch([query]);
-        return deserializeRow(
-          results[0].rows[0],
-          this._config.columns
+        return new Mutation(
+          this._config,
+          [query],
+          (results) => deserializeRow(
+            results[0].rows[0],
+            this._config.columns
+          )
         );
       }
-      async remove(id) {
+      remove(id) {
         const query = buildDelete(this._config.tableName, `id = ?`, [id]);
-        await this._config.executeBatch([query]);
+        return new Mutation(this._config, [query], () => void 0);
       }
       /**
        * Remove all rows matching a predicate. Returns the count removed.
        */
-      async removeAll(predicate) {
+      removeAll(predicate) {
         const compiled = compilePredicate(predicate);
         if (compiled.type === "sql") {
           const query = buildDelete(this._config.tableName, compiled.where);
-          const results = await this._config.executeBatch([query]);
-          return results[0].changes;
-        }
-        console.warn(
-          `[mindstudio] removeAll predicate on ${this._config.tableName} could not be compiled to SQL \u2014 fetching all rows first`
-        );
-        const allQuery = buildSelect(this._config.tableName);
-        const allResults = await this._config.executeBatch([allQuery]);
-        const allRows = allResults[0].rows.map(
-          (r) => deserializeRow(
-            r,
-            this._config.columns
-          )
-        );
-        const matching = allRows.filter((row) => predicate(row));
-        if (matching.length === 0) return 0;
-        const deleteQueries = matching.filter((row) => row.id).map((row) => buildDelete(this._config.tableName, `id = ?`, [row.id]));
-        if (deleteQueries.length > 0) {
-          await this._config.executeBatch(deleteQueries);
+          return new Mutation(this._config, [query], (results) => results[0].changes);
         }
-        return matching.length;
+        return Mutation.fromExecutor(this._config, async () => {
+          console.warn(
+            `[mindstudio] removeAll predicate on ${this._config.tableName} could not be compiled to SQL \u2014 fetching all rows first`
+          );
+          const allQuery = buildSelect(this._config.tableName);
+          const allResults = await this._config.executeBatch([allQuery]);
+          const allRows = allResults[0].rows.map(
+            (r) => deserializeRow(
+              r,
+              this._config.columns
+            )
+          );
+          const matching = allRows.filter((row) => predicate(row));
+          if (matching.length === 0) return 0;
+          const deleteQueries = matching.filter((row) => row.id).map((row) => buildDelete(this._config.tableName, `id = ?`, [row.id]));
+          if (deleteQueries.length > 0) {
+            await this._config.executeBatch(deleteQueries);
+          }
+          return matching.length;
+        });
       }
-      async clear() {
+      clear() {
         const query = buildDelete(this._config.tableName);
-        await this._config.executeBatch([query]);
+        return new Mutation(this._config, [query], () => void 0);
       }
     };
   }
@@ -2501,44 +2591,64 @@ function createDb(databases, executeBatch) {
     ago: (ms) => Date.now() - ms,
     fromNow: (ms) => Date.now() + ms,
     // --- Batch execution ---
-    batch: ((...queries) => {
+    batch: ((...operations) => {
       return (async () => {
-        const compiled = queries.map((q) => {
-          if (!(q instanceof Query)) {
-            throw new MindStudioError(
-              "db.batch() only accepts Query objects (from .filter(), .sortBy(), etc.)",
-              "invalid_batch_query",
-              400
-            );
+        const compiled = operations.map((op) => {
+          if (op instanceof Query) {
+            return op._compile();
+          }
+          if (op instanceof Mutation) {
+            return op._compile();
           }
-          return q._compile();
+          throw new MindStudioError(
+            "db.batch() only accepts Query and Mutation objects (from .filter(), .update(), .push(), etc.)",
+            "invalid_batch_operation",
+            400
+          );
         });
         const groups = /* @__PURE__ */ new Map();
         for (let i = 0; i < compiled.length; i++) {
           const c = compiled[i];
           const dbId = c.config.databaseId;
-          const sqlQuery = c.query ?? c.fallbackQuery;
           if (!groups.has(dbId)) groups.set(dbId, []);
-          groups.get(dbId).push({ index: i, sqlQuery });
+          if (c.type === "query") {
+            const sqlQuery = c.query ?? c.fallbackQuery;
+            groups.get(dbId).push({ opIndex: i, sqlQueries: [sqlQuery] });
+          } else {
+            groups.get(dbId).push({ opIndex: i, sqlQueries: c.queries });
+          }
         }
-        const allResults = new Array(compiled.length);
+        const opResults = /* @__PURE__ */ new Map();
         await Promise.all(
           Array.from(groups.entries()).map(async ([dbId, entries]) => {
-            const sqlQueries = entries.map((e) => e.sqlQuery);
-            const results = await executeBatch(dbId, sqlQueries);
-            for (let i = 0; i < entries.length; i++) {
-              allResults[entries[i].index] = results[i];
+            const flatQueries = [];
+            const slices = [];
+            for (const entry of entries) {
+              slices.push({
+                opIndex: entry.opIndex,
+                start: flatQueries.length,
+                count: entry.sqlQueries.length
+              });
+              flatQueries.push(...entry.sqlQueries);
+            }
+            const results = await executeBatch(dbId, flatQueries);
+            for (const { opIndex, start, count } of slices) {
+              opResults.set(opIndex, results.slice(start, start + count));
             }
           })
         );
         return compiled.map((c, i) => {
-          const result = allResults[i];
-          if (!c.query && c.predicates?.length) {
-            console.warn(
-              `[mindstudio] db.batch(): filter on ${c.config.tableName} could not be compiled to SQL \u2014 processing in JS`
-            );
+          const results = opResults.get(i);
+          if (c.type === "query") {
+            if (!c.query && c.predicates?.length) {
+              console.warn(
+                `[mindstudio] db.batch(): filter on ${c.config.tableName} could not be compiled to SQL \u2014 processing in JS`
+              );
+            }
+            return Query._processResults(results[0], c);
+          } else {
+            return Mutation._processResults(results, c);
           }
-          return Query._processResults(result, c);
         });
       })();
     })
@@ -2597,6 +2707,7 @@ var init_db = __esm({
     init_errors();
     init_table();
     init_query();
+    init_mutation();
     init_table();
   }
 });
@@ -4282,15 +4393,24 @@ function summarizeInput(input) {
 }
 async function cmdAsk(question, options) {
   try {
+    let lineBuffer = "";
     const response = await runAsk(question, options, (event) => {
       switch (event.type) {
         case "text":
-          process.stderr.write(event.text);
+          lineBuffer += event.text;
+          while (lineBuffer.includes("\n")) {
+            const idx = lineBuffer.indexOf("\n");
+            process.stderr.write(lineBuffer.slice(0, idx + 1));
+            lineBuffer = lineBuffer.slice(idx + 1);
+          }
           break;
         case "tool_start":
+          if (lineBuffer) {
+            process.stderr.write(lineBuffer + "\n");
+            lineBuffer = "";
+          }
           process.stderr.write(
-            `
- ${ansi.cyan("\u27E1")} ${ansi.bold(event.name)} ${ansi.dim(summarizeInput(event.input))}
+            ` ${ansi.cyan("\u27E1")} ${ansi.bold(event.name)} ${ansi.dim(summarizeInput(event.input))}
 `
           );
           break;
@@ -4298,6 +4418,9 @@ async function cmdAsk(question, options) {
           break;
       }
     });
+    if (lineBuffer) {
+      process.stderr.write(lineBuffer);
+    }
     if (process.stdout.isTTY) {
       process.stderr.write("\n");
     } else {
@@ -4389,7 +4512,7 @@ async function startMcpServer(options) {
           capabilities: { tools: {} },
           serverInfo: {
             name: "mindstudio-agent",
-            version: "0.1.18"
+            version: "0.1.19"
           },
           instructions: 'Welcome to MindStudio \u2014 a platform with 200+ AI models, 850+ third-party integrations, and pre-built agents.\n\nGetting started:\n1. Call `ask` with any question about the SDK \u2014 it knows every action, model, and connector and returns working code with real model IDs and config options. Examples: ask("generate an image with FLUX"), ask("what models support vision?"), ask("how do I send a Slack message?").\n2. Call `changeName` to set your display name \u2014 use your name or whatever your user calls you. This is how you\'ll appear in MindStudio request logs.\n3. If you have a profile picture or icon, call `uploadFile` to upload it, then `changeProfilePicture` with the returned URL.\n4. For manual browsing, call `listActions` to discover all available actions.\n\nThen use the tools to generate text, images, video, audio, search the web, work with data sources, run agents, and more.\n\nImportant:\n- AI-powered actions (text generation, image generation, video, audio, etc.) cost money. Before running these, call `estimateActionCost` and confirm with the user before proceeding \u2014 unless they\'ve explicitly told you to go ahead.\n- Not all agents from `listAgents` are configured for API use. Do not try to run an agent just because it appears in the list \u2014 it will likely fail. Only run agents the user specifically asks you to run.'
         });
@@ -5229,7 +5352,7 @@ function isNewerVersion(current, latest) {
   return false;
 }
 async function checkForUpdate() {
-  const currentVersion = "0.1.18";
+  const currentVersion = "0.1.19";
   if (!currentVersion) return null;
   try {
     const { loadConfig: loadConfig2, saveConfig: saveConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -5258,7 +5381,7 @@ async function checkForUpdate() {
   }
 }
 function printUpdateNotice(latestVersion) {
-  const currentVersion = "0.1.18";
+  const currentVersion = "0.1.19";
   process.stderr.write(
     `
   ${ansi2.cyanBright("Update available")} ${ansi2.gray(currentVersion + " \u2192")} ${ansi2.cyanBold(latestVersion)}
@@ -5313,7 +5436,7 @@ async function cmdLogin(options) {
   process.stderr.write("\n");
   printLogo();
   process.stderr.write("\n");
-  const ver = "0.1.18";
+  const ver = "0.1.19";
   process.stderr.write(
     `  ${ansi2.bold("MindStudio Agent")} ${ver ? " " + ansi2.gray("v" + ver) : ""}
 `
@@ -5399,6 +5522,9 @@ async function cmdLogin(options) {
   ${ansi2.bold("Using with Claude Code?")} Run once to enable the MCP server:
   ${ansi2.cyan("claude mcp add mindstudio -- mindstudio mcp")}
 
+  ${ansi2.bold("Need help?")} Ask the SDK anything:
+  ${ansi2.cyan('mindstudio ask "how do I generate an image?"')}
+
 `
       );
       return;
@@ -5612,6 +5738,12 @@ async function main() {
   const command = positionals[0];
   const updatePromise = command !== "mcp" && command !== "login" ? checkForUpdate() : Promise.resolve(null);
   try {
+    if (command === "version" || command === "-v") {
+      process.stdout.write(
+        "0.1.19\n"
+      );
+      return;
+    }
     if (command === "login") {
       await cmdLogin({
         baseUrl: values["base-url"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindstudio-ai/agent",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "TypeScript SDK for MindStudio direct step execution",
   "type": "module",
   "main": "./dist/index.js",