@mindstudio-ai/agent 0.1.17 → 0.1.19

package/dist/cli.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.17"
+            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.'
         });
@@ -5323,7 +5446,7 @@ function isNewerVersion(current, latest) {
   return false;
 }
 async function checkForUpdate() {
-  const currentVersion = "0.1.17";
+  const currentVersion = "0.1.19";
   if (!currentVersion) return null;
   try {
     const { loadConfig: loadConfig2, saveConfig: saveConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -5352,7 +5475,7 @@ async function checkForUpdate() {
   }
 }
 function printUpdateNotice(latestVersion) {
-  const currentVersion = "0.1.17";
+  const currentVersion = "0.1.19";
   process.stderr.write(
     `
   ${ansi2.cyanBright("Update available")} ${ansi2.gray(currentVersion + " \u2192")} ${ansi2.cyanBold(latestVersion)}
@@ -5427,7 +5550,7 @@ async function cmdLogin(options) {
   process.stderr.write("\n");
   printLogo();
   process.stderr.write("\n");
-  const ver = "0.1.17";
+  const ver = "0.1.19";
   process.stderr.write(
     `  ${ansi2.bold("MindStudio Agent")} ${ver ? " " + ansi2.gray("v" + ver) : ""}
 `
@@ -5513,6 +5636,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;
@@ -5735,6 +5861,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/dist/index.d.ts

@@ -726,6 +726,7 @@ declare class Query<T> implements PromiseLike<T[]> {
  * (fast path) or a fallback SELECT * with JS processing metadata.
  */
 interface CompiledQuery<T> {
+    type: 'query';
     /** Compiled SQL query, or null if JS fallback needed. */
     query: SqlQuery | null;
     /** SELECT * fallback query, or null if SQL compiled. */
@@ -744,12 +745,76 @@ interface CompiledQuery<T> {
     offset?: number;
 }
 
+/**
+ * Mutation<T> — a lazy write operation backed by SQLite.
+ *
+ * Created by Table write methods (push, update, remove, removeAll, clear).
+ * Like Query, implements PromiseLike so `await` triggers execution. Unlike
+ * Query, there's no chaining — a Mutation is a fixed set of SQL statements
+ * with a result processor.
+ *
+ * ## Batch support
+ *
+ * `db.batch()` calls `_compile()` to extract the SQL without executing,
+ * then bundles it with other operations into a single round trip. After
+ * execution, `_processResults()` deserializes the raw SQL results.
+ *
+ * ## Non-batchable mutations
+ *
+ * Some mutations (e.g. `removeAll` with a JS-fallback predicate) require
+ * multi-step execution that can't be expressed as a fixed SQL batch.
+ * These are created via `Mutation.fromExecutor()` and work fine when
+ * awaited standalone, but throw if passed to `db.batch()`.
+ */
+
+interface CompiledMutation<TResult> {
+    type: 'mutation';
+    queries: SqlQuery[];
+    config: TableConfig;
+    processResult: (results: SqlResult[]) => TResult;
+}
+declare class Mutation<TResult> implements PromiseLike<TResult> {
+    /** @internal */
+    private readonly _config;
+    /** @internal */
+    private readonly _queries;
+    /** @internal */
+    private readonly _processResult;
+    /** @internal Non-batchable executor for complex mutations (e.g. removeAll JS fallback). */
+    private readonly _executor;
+    constructor(config: TableConfig, queries: SqlQuery[], processResult: (results: SqlResult[]) => TResult);
+    /**
+     * 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<T>(config: TableConfig, executor: () => Promise<T>): Mutation<T>;
+    then<T1 = TResult, T2 = never>(onfulfilled?: ((value: TResult) => T1 | PromiseLike<T1>) | null, onrejected?: ((reason: unknown) => T2 | PromiseLike<T2>) | null): Promise<T1 | T2>;
+    /**
+     * @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(): CompiledMutation<TResult>;
+    /**
+     * @internal Process raw SQL results into the typed result.
+     * Used by db.batch() after executing the compiled queries.
+     */
+    static _processResults<T>(results: SqlResult[], compiled: CompiledMutation<T>): T;
+    private _execute;
+}
+
 /**
  * Table<T> — a typed persistent collection backed by SQLite.
  *
  * Created via `db.defineTable<T>(name)`. Every method either returns a
- * chainable Query<T> (for lazy reads) or a Promise (for terminal reads
- * and writes).
+ * chainable Query<T> (for lazy reads), a Mutation<T> (for lazy writes),
+ * or a Promise (for terminal reads).
  *
  * ## Write operations use RETURNING
  *
@@ -781,19 +846,19 @@ declare class Table<T> {
      * Uses `INSERT ... RETURNING *` so the created row comes back in a
      * single round trip — no separate SELECT needed.
      */
-    push(data: PushInput<T>): Promise<T>;
-    push(data: PushInput<T>[]): Promise<T[]>;
+    push(data: PushInput<T>): Mutation<T>;
+    push(data: PushInput<T>[]): Mutation<T[]>;
     /**
      * Update a row by ID. Only the provided fields are changed.
      * Returns the updated row via `UPDATE ... RETURNING *`.
      */
-    update(id: string, data: UpdateInput<T>): Promise<T>;
-    remove(id: string): Promise<void>;
+    update(id: string, data: UpdateInput<T>): Mutation<T>;
+    remove(id: string): Mutation<void>;
     /**
      * Remove all rows matching a predicate. Returns the count removed.
      */
-    removeAll(predicate: Predicate<T>): Promise<number>;
-    clear(): Promise<void>;
+    removeAll(predicate: Predicate<T>): Mutation<number>;
+    clear(): Mutation<void>;
 }
 
 /**
@@ -904,18 +969,21 @@ interface Db {
     /** Returns a unix timestamp for (now + duration). Use with days/hours/minutes. */
     fromNow(ms: number): number;
     /**
-     * Execute multiple queries in a single round trip. All queries run on
-     * the same database connection, eliminating per-query HTTP overhead.
+     * Execute multiple reads and writes in a single round trip. All
+     * operations run on the same database connection, eliminating
+     * per-operation HTTP overhead. Writes execute in argument order.
      *
-     * Accepts Query objects (lazy, not yet executed). Compiles them to SQL,
+     * Accepts Query objects (reads) and Mutation objects (writes from
+     * push, update, remove, removeAll, clear). Compiles them to SQL,
      * sends all in one batch request, and returns typed results.
      *
      * @example
      * ```ts
-     * const [orders, approvals, vendors] = await db.batch(
-     *   Orders.filter(o => o.status === 'active').take(10),
-     *   Approvals.filter(a => a.status === 'pending').take(25),
-     *   Vendors.sortBy(v => v.createdAt).reverse().take(5),
+     * // Mixed reads and writes in one round trip
+     * const [, newCard, cards] = await db.batch(
+     *   Cards.update(card1.id, { position: 1 }),
+     *   Cards.push({ title: 'New', columnId, position: 0 }),
+     *   Cards.filter(c => c.columnId === columnId),
      * );
      * ```
      */