Add reasoning effort selection and streaming responses

.prettierrc

@@ -1,5 +1,5 @@
 {
-  "printWidth": 120,
+  "printWidth": 154,
   "proseWrap": "preserve",
   "semi": true,
   "singleQuote": false,

CONVENTIONS.md

@@ -58,22 +58,10 @@ Favour static types, explicit data flow, immutability, pure functions, compositi
     s.variant({ type: "error", message: s.string, code: s.optional(s.string) })
   ]);
   ```
-- Embed **immutable snapshots** in event payloads when referencing mutable external data (e.g. a property's price at the time of booking).
-  ```ts
-  const schema_UserActions = s.discriminatedUnion([
-    s.variant({ type: "view_property", property: schema_PropertySnapshot }),
-    s.variant({ type: "start_booking", property: schema_PropertySnapshot, draftId: DraftId.schema }),
-    s.variant({ type: "confirm_booking", draftId: DraftId.schema })
-  ]);
-  ```
 - Bundle related state into **union-driven state machines**. Don't use loose boolean flags (`isStreaming`, `isError`, `isLoading`) spread across stores.
 
   ```ts
-  type Stream<E, R> =
-    | { type: "not_started" }
-    | { type: "streaming"; results: R[] }
-    | { type: "done"; results: R[] }
-    | { type: "error"; error: E };
+  type Stream<E, R> = { type: "not_started" } | { type: "streaming"; results: R[] } | { type: "done"; results: R[] } | { type: "error"; error: E };
 
   type VoiceConnection =
     | { type: "disconnected" }
@@ -232,28 +220,74 @@ Use `Future<E, T>` instead of `Promise` for lazy, cancelable async.
 - `TreeSet`: `.insert()`, `.remove()`, `.union()` mutate in place. Use `TreeSet.from()` to clone first.
 - Use `.has()` for O(log n) membership. Don't use `.values().includes()` — that's O(n).
 
-### MVar & BoundedBuffer — Async Coordination
+### MVar — Async Coordination
 
-- Use `MVar<T>` for async synchronization. `put(v)` blocks if full, `take()` blocks if empty. Resolves in FIFO order.
-- Use `BoundedBuffer<T>` for backpressure queues with max capacity. `enqueue(v)` blocks if full, `dequeue()` blocks if empty.
+Use `MVar<T>` to coordinate concurrent operations through a single mutable cell. Operations are FIFO — fair across waiters, no starvation.
 
-  ```ts
-  const textBuffer = new BoundedBuffer<string>(100);
-  const endSignal = MVar.newEmpty<null>();
+- Construct with `MVar.new(v)` (full) or `MVar.newEmpty()` (empty).
+- `put`/`take`/`read`/`modify` block; `tryPut`/`tryTake`/`tryRead` don't.
+- `tryPut` returns `boolean`; `tryTake`/`tryRead` return `Maybe<A>` — pattern match with `instanceof Just` / `instanceof Nothing`.
+- Use `modify` (not external locks) to atomically transform shared state — the original value is restored if the callback rejects.
+- Don't busy-loop on `tryTake` — use `take` to block.
+- Don't use boolean flags or unbounded arrays for "done" state — use `MVar` to block until populated.
 
-  model.onToken((token) => {
-    textBuffer.enqueue(token);
-  });
-  model.onDone(() => {
-    endSignal.put(null);
-  });
+**Completion/error latch with `MVar<Maybe<Error>>`** — surface either "closed cleanly" or "closed with error" from a callback-based lifecycle.
 
-  for await (const text of iterable) {
-    await ttsService.synthesize(text);
-  }
-  ```
+```ts
+const done: MVar<Maybe<Error>> = MVar.newEmpty();
+ws.on("close", () => {
+  done.tryPut(Nothing());
+});
+ws.on("error", (err) => {
+  done.tryPut(Just(err));
+});
+
+const result = await done.take();
+if (result instanceof Just) throw result.value;
+```
 
-- Don't use unbounded arrays for streaming — memory leak risk. Don't use boolean flags for "done" state — use `MVar` to block until populated.
+**End-of-stream latch with `MVar<null>`** — convert a callback-based "done" signal into a value awaitable from an `AsyncIterable`.
+
+```ts
+const end = MVar.newEmpty<null>();
+const finished = end.take();
+
+const iterable: AsyncIterable<string> = {
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => Promise.race([buffer.dequeue().then((value) => ({ done: false, value })), finished.then(() => ({ done: true, value: undefined }))])
+    };
+  }
+};
+
+model.onDone(() => {
+  end.put(null);
+});
+```
+
+**Atomic state via `modify`** — guard mutable shared state with automatic rollback on rejection.
+
+```ts
+const counter = MVar.new(0);
+const previous = await counter.modify(async (n) => [n + 1, n]);
+```
+
+### Queue & MQueue — Functional Queues
+
+- Use `Queue<T>` for immutable persistent queues — `enqueue` returns a new `Queue`; safe to share across async boundaries without copying.
+- Use `MQueue<T>` for transient producer-consumer queues where mutation is local (e.g. waiter queues inside coordination primitives).
+- `Queue.dequeue()` returns `Maybe<[T, Queue<T>]>`; `MQueue.dequeue()` returns `Maybe<T>` — both must be pattern-matched.
+- Both have amortised O(1) enqueue/dequeue via two-list (front/back) representation.
+- Don't reach for native `Array.shift()` for FIFO — it's O(n) and mutates.
+
+```ts
+let q = Queue.fromArray([1, 2, 3]);
+const r = q.dequeue();
+if (r instanceof Just) {
+  const [head, rest] = r.value;
+  q = rest; // thread the new queue
+}
+```
 
 ---
 

README.md

@@ -1,6 +1,6 @@
 # commit-tools
 
-[![Version](https://img.shields.io/badge/version-0.2.0-blue.svg)](#)
+[![Version](https://img.shields.io/badge/version-0.2.5-blue.svg)](#)
 
 Writing good commit messages _can_ have a high cognitive cost, especially when you make dozens of commits a day. That energy should be directed toward solving hard problems and shipping features, not summarizing them.
 
@@ -113,6 +113,12 @@ After setup, you can switch AI models from your configured provider at any time:
 commit model
 ```
 
+This flow also lets you adjust the reasoning effort for the chosen model. If the model is already the one you want and you only need to change the effort level, run:
+
+```bash
+commit effort
+```
+
 ### 3. Generate a Commit
 
 Stage your changes, then run:
@@ -144,16 +150,17 @@ To see all available commands at any time, run:
 commit --help
 ```
 
-| Command                  | Description                              |
-| ------------------------ | ---------------------------------------- |
-| `commit`                 | Generate a commit message (default)      |
-| `commit generate`        | Generate a commit message                |
-| `commit setup`           | Configure authentication and conventions |
-| `commit login`           | Alias for setup — re-authenticate        |
-| `commit doctor`          | Check installation and environment       |
-| `commit model`           | Select a different AI model              |
-| `commit --version`, `-v` | Show version                             |
-| `commit --help`, `-h`    | Show help                                |
+| Command                  | Description                                       |
+| ------------------------ | ------------------------------------------------- |
+| `commit`                 | Generate a commit message (default)               |
+| `commit generate`        | Generate a commit message                         |
+| `commit setup`           | Configure authentication and conventions          |
+| `commit login`           | Alias for setup — re-authenticate                 |
+| `commit doctor`          | Check installation and environment                |
+| `commit model`           | Select a different AI model                       |
+| `commit effort`          | Adjust the reasoning effort for the current model |
+| `commit --version`, `-v` | Show version                                      |
+| `commit --help`, `-h`    | Show help                                         |
 
 ## Providers
 

index.ts

@@ -2,6 +2,7 @@ import { Commit } from "@/cli/commit";
 import { Setup } from "@/cli/setup";
 import { Doctor } from "@/cli/doctor";
 import { ModelCommand } from "@/cli/model";
+import { EffortCommand } from "@/cli/effort";
 import { parseArgs, showHelp, showVersion } from "@/cli/parser";
 import { Future } from "@/libs/future";
 
@@ -26,6 +27,8 @@ const main = () => {
           return Doctor.create().run();
         case "model":
           return ModelCommand.create().chain((m) => m.run());
+        case "effort":
+          return EffortCommand.create().chain((e) => e.run());
         case "version":
           showVersion();
           return Future.resolve(undefined);

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rafaeelricco/commit-tools",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "type": "module",
   "bin": {
     "commit": "./dist/index.js"
@@ -45,17 +45,17 @@
     "typescript": "^5"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.87.0",
+    "@anthropic-ai/sdk": "0.90.0",
     "@clack/prompts": "^1.0.1",
-    "@google/generative-ai": "^0.24.1",
+    "@google/genai": "1.50.1",
     "chalk": "^5.6.2",
     "cli-table3": "^0.6.5",
     "fluture": "^14.0.0",
     "google-auth-library": "^10.5.0",
     "ink": "^6.8.0",
     "luxon": "^3.7.2",
     "open": "^11.0.0",
-    "openai": "^6.25.0",
+    "openai": "6.34.0",
     "picocolors": "^1.1.1",
     "react": "^19.2.4"
   }