@johpaz/hive-sdk 0.1.4 → 0.1.5

package/packages/core/src/tools/web/artifact-inspect.ts

@@ -0,0 +1,23 @@
+import type { Tool } from "../types";
+import { inspectArtifact } from "../../artifacts/store";
+
+export const artifactInspectTool: Tool = {
+  name: "artifact_inspect",
+  description: "Inspect managed artifact metadata, integrity, MIME type and dimensions without returning or modifying its binary content.",
+  parameters: {
+    type: "object",
+    properties: {
+      artifactId: {
+        type: "string",
+        description: "Managed artifact identifier returned by a Hive tool.",
+      },
+    },
+    required: ["artifactId"],
+  },
+  execute: async (params, config) => {
+    const artifactId = String(params.artifactId ?? "").trim();
+    if (!artifactId) return { ok: false, error: "artifactId is required" };
+    const userId = config?.configurable?.user_id as string | undefined;
+    return inspectArtifact(artifactId, { userId });
+  },
+};

package/packages/core/src/tools/web/browser-screenshot.ts

@@ -9,6 +9,7 @@
 import type { Tool } from "../types.ts";
 import { logger } from "../../utils/logger.ts";
 import { getBrowserService, screenshotElement } from "./browser-service.ts";
+import { createArtifact } from "../../artifacts/store.ts";
 
 const log = logger.child("browser-screenshot");
 
@@ -53,7 +54,7 @@ export const browserScreenshotTool: Tool = {
     },
     required: [],
   },
-  execute: async (params: Record<string, unknown>) => {
+  execute: async (params: Record<string, unknown>, config?: any) => {
     const url = params.url as string | undefined;
     const fullPage = (params.fullPage as boolean) ?? false;
     const selector = params.selector as string | undefined;
@@ -99,14 +100,34 @@ export const browserScreenshotTool: Tool = {
       }
 
       const currentUrl = view.url;
-      log.info(`Screenshot captured: ${currentUrl} (${screenshot.length} base64 chars, ${format})`);
+      const bytes = Buffer.from(screenshot, "base64");
+      const effectiveFormat = selector ? "png" : format;
+      const mimeType = effectiveFormat === "png" ? "image/png" : "image/jpeg";
+      const configurable = config?.configurable ?? {};
+      const artifact = await createArtifact({
+        bytes,
+        mimeType,
+        kind: "browser_screenshot",
+        userId: String(configurable.user_id ?? ""),
+        runId: configurable.run_id ? String(configurable.run_id) : null,
+        taskId: configurable.task_id ? String(configurable.task_id) : null,
+        rootDir: configurable.artifact_dir ? String(configurable.artifact_dir) : undefined,
+        width,
+        height,
+      });
+      log.info(`Screenshot stored as artifact ${artifact.id} (${artifact.size} bytes, ${mimeType})`);
 
       return {
         ok: true,
         url: currentUrl,
-        screenshot,
-        format,
-        encoding: "base64",
+        artifact_id: artifact.id,
+        kind: artifact.kind,
+        mime_type: artifact.mime_type,
+        size: artifact.size,
+        sha256: artifact.sha256,
+        status: artifact.status,
+        expires_at: artifact.expires_at,
+        format: effectiveFormat,
         fullPage,
         selector,
         viewport: { width, height },

package/packages/core/src/tools/web/browser-service.ts

@@ -178,6 +178,11 @@ export class AgentBrowserView {
       args.push("--screenshot-quality", String(options.quality));
     }
 
+    // If clip/selector is provided, agent-browser screenshot accepts a positional selector
+    // For element screenshots, we can pass a selector as first positional arg
+    // But we don't have selector in options here — the old CDPClient didn't use it either
+    // screenshotElement helper handles element-specific screenshots
+
     const res = await this.run(args);
     if (!res.success) throw new Error(res.error || "screenshot failed");
 

package/packages/core/src/tools/web/browser-type.ts

@@ -68,17 +68,12 @@ export const browserTypeTool: Tool = {
         await Bun.sleep(500);
       }
 
-      // click(selector) waits for actionability then focuses the element
-      await view.click(selector, { timeout });
-
       if (clear) {
-        // Ctrl+A → Backspace to clear existing content
-        await view.press("a", { modifiers: ["Control"] });
-        await view.press("Backspace");
+        await (view as any).fill(selector, text);
+      } else {
+        await (view as any).typeIn(selector, text);
       }
 
-      await view.type(text);
-
       const currentUrl = view.url;
       log.info(`Type successful: "${text.substring(0, 50)}${text.length > 50 ? "..." : ""}" into ${selector}`);
 

package/packages/core/src/tools/web/index.ts

@@ -1,13 +1,12 @@
 /**
  * Web Tools - Browser automation + Web utilities
  * 
- * Browser tools use Puppeteer/Chromium (auto-managed).
+ * Browser tools use agent-browser (Rust CLI, auto-managed).
  */
 
 import type { Tool } from "../types.ts";
 import { webSearchTool } from "./web-search.ts";
 import { webFetchTool } from "./web-fetch.ts";
-import { apiRequestTool } from "./api-request.ts";
 import { browserNavigateTool } from "./browser-navigate.ts";
 import { browserScreenshotTool } from "./browser-screenshot.ts";
 import { browserClickTool } from "./browser-click.ts";
@@ -15,12 +14,12 @@ import { browserTypeTool } from "./browser-type.ts";
 import { browserExtractTool } from "./browser-extract.ts";
 import { browserScriptTool } from "./browser-script.ts";
 import { browserWaitTool } from "./browser-wait.ts";
+import { artifactInspectTool } from "./artifact-inspect.ts";
 
 export function createTools(): Tool[] {
   return [
     webSearchTool,
     webFetchTool,
-    apiRequestTool,
     browserNavigateTool,
     browserScreenshotTool,
     browserClickTool,
@@ -28,12 +27,12 @@ export function createTools(): Tool[] {
     browserExtractTool,
     browserScriptTool,
     browserWaitTool,
+    artifactInspectTool,
   ];
 }
 
 export * from "./web-search.ts";
 export * from "./web-fetch.ts";
-export * from "./api-request.ts";
 export * from "./browser-navigate.ts";
 export * from "./browser-screenshot.ts";
 export * from "./browser-click.ts";
@@ -42,3 +41,4 @@ export * from "./browser-extract.ts";
 export * from "./browser-script.ts";
 export * from "./browser-wait.ts";
 export * from "./browser-service.ts";
+export * from "./artifact-inspect.ts";

package/packages/core/src/voice/index.ts

@@ -1,4 +1,5 @@
-import { getDb } from "../storage/SQLiteStorage";
+import { col } from "../storage/hive";
+import type { ChannelDoc, ModelDoc } from "../storage/collections";
 import { loadProviderApiKey } from "../storage/crypto";
 import { logger } from "../utils/logger";
 
@@ -79,20 +80,11 @@ class VoiceService {
     return VoiceService.instance;
   }
 
-  getChannelVoiceConfig(channelId: string): VoiceConfig {
-    const db = getDb();
-    const result = db.query(`
-      SELECT voice_enabled, tts_enabled, stt_provider, tts_provider, tts_voice_id
-      FROM channels WHERE id = ?
-    `).get(channelId) as {
-      voice_enabled: number;
-      tts_enabled: number;
-      stt_provider: string | null;
-      tts_provider: string | null;
-      tts_voice_id: string | null;
-    } | undefined;
-
-    if (!result) {
+  async getChannelVoiceConfig(channelId: string): Promise<VoiceConfig> {
+    const channelsCol = await col<ChannelDoc>("channels");
+    const entry = await channelsCol.get(channelId);
+
+    if (!entry) {
       return {
         voiceEnabled: false,
         ttsEnabled: false,
@@ -103,26 +95,62 @@ class VoiceService {
     }
 
     return {
-      voiceEnabled: result.voice_enabled === 1,
-      ttsEnabled: result.tts_enabled === 1,
-      sttProvider: result.stt_provider,
-      ttsProvider: result.tts_provider,
-      ttsVoiceId: result.tts_voice_id,
+      voiceEnabled: entry.doc.voice_enabled,
+      ttsEnabled: entry.doc.tts_enabled,
+      sttProvider: entry.doc.stt_provider,
+      ttsProvider: entry.doc.tts_provider,
+      ttsVoiceId: entry.doc.tts_voice_id,
     };
   }
 
+  /** Provider de un modelo según la BD; acepta también un id de provider (canales antiguos). */
+  private async getModelProvider(modelId: string): Promise<string | null> {
+    try {
+      const modelsCol = await col<ModelDoc>("models");
+      const model = await modelsCol.get(modelId);
+      if (model?.doc.provider_id) return model.doc.provider_id;
+      const providersCol = await col<import("../storage/collections").ProviderDoc>("providers");
+      const provider = await providersCol.get(modelId);
+      return provider?.doc.id || null;
+    } catch {
+      return null;
+    }
+  }
+
+  /** Primer modelo STT/TTS activo de un provider activo, como fallback desde la BD. */
+  private async getFirstActiveVoiceModel(type: "stt" | "tts"): Promise<{ id: string; provider: string } | null> {
+    try {
+      const modelsCol = await col<ModelDoc>("models");
+      const providersCol = await col<import("../storage/collections").ProviderDoc>("providers");
+      const models = (await modelsCol.findBy("model_type", type)).filter(e => e.doc.active);
+      for (const m of models) {
+        const provider = await providersCol.get(m.doc.provider_id);
+        if (provider?.doc.active) return { id: m.doc.id, provider: m.doc.provider_id };
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
   async transcribe(audio: AudioInput, modelId: string): Promise<string> {
-    const isGroq = modelId.startsWith("whisper");
-    const isOpenAi = modelId === "whisper-1";
-    
-    if (isGroq) {
-      return this.transcribeWithGroq(audio, modelId);
-    } else if (isOpenAi) {
-      return this.transcribeWithOpenAIWhisper(audio);
+    let provider = await this.getModelProvider(modelId);
+    let resolvedModelId = modelId;
+
+    if (!provider) {
+      const fallback = await this.getFirstActiveVoiceModel("stt");
+      if (!fallback) throw new Error(`STT model "${modelId}" not found and no active STT models in the database`);
+      log.warn(`STT model ${modelId} not found in DB, falling back to ${fallback.provider}/${fallback.id}`);
+      provider = fallback.provider;
+      resolvedModelId = fallback.id;
+    }
+
+    switch (provider) {
+      case "groq":   return this.transcribeWithGroq(audio, resolvedModelId);
+      case "openai": return this.transcribeWithOpenAIWhisper(audio);
+      default:
+        throw new Error(`STT not supported for provider "${provider}" (model ${resolvedModelId})`);
     }
-    
-    log.warn(`Unknown STT provider ${modelId}, defaulting to Groq Whisper`);
-    return this.transcribeWithGroq(audio, "whisper-large-v3-turbo");
   }
 
   private async getProviderApiKey(providerId: string): Promise<string | null> {
@@ -229,26 +257,26 @@ class VoiceService {
   }
 
   async speak(text: string, modelId: string, voiceId?: string): Promise<AudioOutput> {
-    const isElevenLabs = modelId.startsWith("eleven");
-    const isOpenAI = modelId.startsWith("tts-") || modelId.startsWith("gpt-");
-    const isGemini = modelId.startsWith("gemini");
-    const isQwen = modelId.startsWith("qwen");
-    const isPiper = modelId === "piper" || modelId === "piper-local";
-
-    if (isPiper) {
-      return this.speakWithPiper(text, voiceId);
-    } else if (isElevenLabs) {
-      return this.speakWithElevenLabs(text, modelId, voiceId);
-    } else if (isOpenAI) {
-      return this.speakWithOpenAI(text, modelId, voiceId);
-    } else if (isGemini) {
-      return this.speakWithGemini(text, modelId, voiceId);
-    } else if (isQwen) {
-      return this.speakWithQwen(text, modelId, voiceId);
-    }
-
-    log.warn(`Unknown TTS provider ${modelId}, defaulting to ElevenLabs Flash`);
-    return this.speakWithElevenLabs(text, "eleven_flash_v2_5", voiceId);
+    let provider = modelId === "piper-local" ? "piper" : await this.getModelProvider(modelId);
+    let resolvedModelId = modelId;
+
+    if (!provider) {
+      const fallback = await this.getFirstActiveVoiceModel("tts");
+      if (!fallback) throw new Error(`TTS model "${modelId}" not found and no active TTS models in the database`);
+      log.warn(`TTS model ${modelId} not found in DB, falling back to ${fallback.provider}/${fallback.id}`);
+      provider = fallback.provider;
+      resolvedModelId = fallback.id;
+    }
+
+    switch (provider) {
+      case "piper":      return this.speakWithPiper(text, voiceId);
+      case "elevenlabs": return this.speakWithElevenLabs(text, resolvedModelId, voiceId);
+      case "openai":     return this.speakWithOpenAI(text, resolvedModelId, voiceId);
+      case "gemini":     return this.speakWithGemini(text, resolvedModelId, voiceId);
+      case "qwen":       return this.speakWithQwen(text, resolvedModelId, voiceId);
+      default:
+        throw new Error(`TTS not supported for provider "${provider}" (model ${resolvedModelId})`);
+    }
   }
 
   private async speakWithPiper(text: string, voiceId?: string): Promise<AudioOutput> {
@@ -448,21 +476,19 @@ class VoiceService {
     };
   }
 
-  getConfiguredVoiceProviders(): { groq: boolean; elevenlabs: boolean; openai: boolean; gemini: boolean; qwen: boolean } {
-    const db = getDb();
-    const hasDbKey = (providerId: string): boolean => {
-      const row = db.query(
-        `SELECT api_key_encrypted FROM providers WHERE id = ? AND api_key_encrypted IS NOT NULL AND api_key_encrypted != ''`
-      ).get(providerId) as { api_key_encrypted: string } | undefined;
-      return !!row;
-    };
+  async getConfiguredVoiceProviders(): Promise<{ groq: boolean; elevenlabs: boolean; openai: boolean; gemini: boolean; qwen: boolean }> {
+    const hasDbKey = async (providerId: string): Promise<boolean> => !!(await loadProviderApiKey(providerId));
+
+    const [groq, elevenlabs, openai, gemini, qwen] = await Promise.all([
+      hasDbKey("groq"), hasDbKey("elevenlabs"), hasDbKey("openai"), hasDbKey("gemini"), hasDbKey("qwen"),
+    ]);
 
     return {
-      groq:       hasDbKey("groq")       || !!(process.env.GROQ_API_KEY),
-      elevenlabs: hasDbKey("elevenlabs") || !!(process.env.ELEVENLABS_API_KEY),
-      openai:     hasDbKey("openai")     || !!(process.env.OPENAI_API_KEY),
-      gemini:     hasDbKey("gemini")     || !!(process.env.GEMINI_API_KEY),
-      qwen:       hasDbKey("qwen")       || !!(process.env.DASHSCOPE_API_KEY),
+      groq:       groq       || !!(process.env.GROQ_API_KEY),
+      elevenlabs: elevenlabs || !!(process.env.ELEVENLABS_API_KEY),
+      openai:     openai     || !!(process.env.OPENAI_API_KEY),
+      gemini:     gemini     || !!(process.env.GEMINI_API_KEY),
+      qwen:       qwen       || !!(process.env.DASHSCOPE_API_KEY),
     };
   }
 

package/packages/core/src/workers/agent.worker.ts

@@ -5,8 +5,8 @@
  * Sends:    { type: "AGENT_RESULT", taskId, result } | { type: "AGENT_CHUNK", taskId, chunk }
  */
 
-import { runAgent } from "../agent/AgentRunner.ts";
-import type { StreamChunk } from "../agent/AgentRunner.ts";
+import { runAgent } from "../agent/agent-loop.ts";
+import type { StreamChunk } from "../agent/agent-loop.ts";
 
 declare var self: {
   onmessage: ((event: { data: WorkerMessage }) => void) | null;

package/packages/core/src/workers/workers.test.ts

@@ -1,16 +1,9 @@
-import { describe, expect, it, beforeAll, afterAll } from "bun:test";
+process.env.HIVE_DB_PATH = ":memory:";
+
+import { describe, expect, it } from "bun:test";
 import { createWorker, WorkerPool } from "./index.ts";
-import { setupTestDb, teardownTestDb, insertTestAgent, insertTestProvider } from "../../../../test/setup-db.ts";
 
 describe("createWorker", () => {
-  beforeAll(() => {
-    setupTestDb();
-  });
-
-  afterAll(() => {
-    teardownTestDb();
-  });
-
   it("creates a worker instance with config", () => {
     const worker = createWorker({
       name: "test-worker",

package/scripts/bump-version.ts

@@ -0,0 +1,248 @@
+#!/usr/bin/env bun
+
+/**
+ * Bump de versión del SDK.
+ *
+ * Portado de `hive/scripts/bump-version.ts`, adaptado a este repo: acá el
+ * artefacto publicado es **sólo el paquete raíz** (`@johpaz/hive-sdk`);
+ * `packages/core` y `packages/cli` son workspaces internos que se versionan en
+ * paralelo por consistencia, no se publican.
+ *
+ * El push del tag `vX.Y.Z` es lo que dispara `.github/workflows/publish.yml`.
+ */
+
+const args = process.argv.slice(2);
+const dryRun = args.includes("--dry-run");
+const shouldPush = args.includes("--push");
+const npmTagArg = args.find((a) => a.startsWith("--npm-tag="));
+const npmTag = npmTagArg ? npmTagArg.split("=")[1] : "latest";
+const positional = args.filter((a) => !a.startsWith("--"));
+const bumpType = positional[0] as "patch" | "minor" | "major" | string;
+const explicitVersion = positional[0]?.match(/^\d+\.\d+\.\d+(-[\w.]+)?$/) ? positional[0] : null;
+
+if (!bumpType || (!["patch", "minor", "major"].includes(bumpType) && !explicitVersion)) {
+  console.log("Usage:");
+  console.log("  bun scripts/bump-version.ts patch|minor|major [--push] [--dry-run] [--npm-tag=<tag>]");
+  console.log("  bun scripts/bump-version.ts 0.1.5 [--push] [--dry-run] [--npm-tag=<tag>]");
+  console.log("");
+  console.log("  (sin flags)    Solo actualiza archivos locales (package.json, README, CHANGELOG).");
+  console.log("                 No toca git. Revisá el diff vos mismo.");
+  console.log("  --dry-run      Muestra qué cambiaría, sin escribir nada.");
+  console.log("  --push         Además de bumpear: commitea, crea el tag vX.Y.Z y pushea.");
+  console.log("                 El tag dispara publish.yml, que publica en npm.");
+  console.log("  --npm-tag=X    dist-tag de npm (default: latest). Usá `next` o `beta` para");
+  console.log("                 una preview que no se instale con `bun add @johpaz/hive-sdk`.");
+  console.log("");
+  console.log("Ejemplos:");
+  console.log("  bun scripts/bump-version.ts 0.1.5                    # solo archivos");
+  console.log("  bun scripts/bump-version.ts 0.1.5 --push             # release a latest");
+  console.log("  bun scripts/bump-version.ts 0.2.0-rc.1 --push --npm-tag=next");
+  process.exit(1);
+}
+
+function bumpVersion(current: string, type: "patch" | "minor" | "major"): string {
+  const [major, minor, patch] = current.split("-")[0].split(".").map(Number);
+  return type === "major"
+    ? `${major + 1}.0.0`
+    : type === "minor"
+      ? `${major}.${minor + 1}.0`
+      : `${major}.${minor}.${patch + 1}`;
+}
+
+async function confirm(message: string): Promise<boolean> {
+  const readline = await import("node:readline/promises");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await rl.question(`${message} (escribe "si" para confirmar): `);
+  rl.close();
+  return answer.trim().toLowerCase() === "si";
+}
+
+/** El raíz es el que se publica; los workspaces van en paralelo por consistencia. */
+const packageFiles = [
+  "package.json",
+  "packages/core/package.json",
+  "packages/cli/package.json",
+];
+
+/** Menciones de versión en prosa que no salen de ningún package.json. */
+function textReplacements(newVersion: string) {
+  return [
+    {
+      path: "README.md",
+      pattern: /\*Hive SDK v[\d.]+(?:-[\w.]+)? — MIT\*/g,
+      replacement: `*Hive SDK v${newVersion} — MIT*`,
+    },
+  ];
+}
+
+async function main() {
+  const rootPkg = JSON.parse(await Bun.file("package.json").text());
+  const currentVersion: string = rootPkg.version;
+  const newVersion = explicitVersion || bumpVersion(currentVersion, bumpType as "patch" | "minor" | "major");
+
+  console.log(`\n📦 Bumping version: ${currentVersion} → ${newVersion}`);
+  console.log(`   npm dist-tag: ${npmTag}\n`);
+
+  if (newVersion === currentVersion && !explicitVersion) {
+    console.log("⚠️  La versión nueva es igual a la actual. Abortando.");
+    process.exit(1);
+  }
+
+  // npm rechaza republicar una versión existente: mejor enterarse acá que en CI.
+  try {
+    const published = await fetch(`https://registry.npmjs.org/${rootPkg.name}`)
+      .then((r) => (r.ok ? r.json() : null)) as { versions?: Record<string, unknown> } | null;
+    if (published?.versions?.[newVersion]) {
+      console.log(`⚠️  ${rootPkg.name}@${newVersion} YA está publicada en npm.`);
+      console.log(`   Un publish con esta versión falla con 403. Elegí otra.\n`);
+      if (!dryRun) process.exit(1);
+    }
+  } catch {
+    console.log("   (no se pudo consultar npm — sigo igual)\n");
+  }
+
+  if (dryRun) {
+    console.log("🔎 Dry run — nada se escribe.\n");
+    for (const filePath of packageFiles) {
+      try {
+        const json = JSON.parse(await Bun.file(filePath).text());
+        console.log(`  ${filePath}: ${json.version} → ${newVersion}`);
+      } catch (e) {
+        console.log(`  ⚠️  ${filePath}: ${(e as Error).message}`);
+      }
+    }
+    for (const file of textReplacements(newVersion)) {
+      try {
+        const content = await Bun.file(file.path).text();
+        const matches = content.match(file.pattern);
+        console.log(`  ${file.path}: ${matches ? `${matches.length} coincidencia(s)` : "sin coincidencias (revisar patrón)"}`);
+      } catch (e) {
+        console.log(`  ⚠️  ${file.path}: ${(e as Error).message}`);
+      }
+    }
+    if (shouldPush) {
+      console.log(`\n  Luego: git add -A && git commit -m "chore: release v${newVersion}"`);
+      console.log(`         git tag v${newVersion} && git push origin main && git push origin v${newVersion}`);
+      console.log(`         → publish.yml publica con dist-tag "${npmTag}"`);
+    } else {
+      console.log(`\n  Sin --push: no se toca git.`);
+    }
+    return;
+  }
+
+  for (const filePath of packageFiles) {
+    try {
+      const json = JSON.parse(await Bun.file(filePath).text());
+      const oldVersion = json.version;
+      json.version = newVersion;
+      await Bun.write(filePath, JSON.stringify(json, null, 2) + "\n");
+      console.log(`✅ ${filePath}`);
+      console.log(`   ${json.name}: ${oldVersion} → ${newVersion}`);
+    } catch (e) {
+      console.log(`⚠️  ${filePath}: ${(e as Error).message}`);
+    }
+  }
+
+  for (const file of textReplacements(newVersion)) {
+    try {
+      const content = await Bun.file(file.path).text();
+      const matched = file.pattern.test(content);
+      file.pattern.lastIndex = 0; // test() con /g deja estado — resetear
+      const newContent = content.replace(file.pattern, file.replacement);
+
+      if (!matched) {
+        console.log(`⚠️  ${file.path}: el patrón no matcheó nada — revisar manualmente`);
+      } else if (newContent !== content) {
+        await Bun.write(file.path, newContent);
+        console.log(`✅ ${file.path}`);
+      } else {
+        console.log(`✅ ${file.path} (ya estaba en ${newVersion})`);
+      }
+    } catch (e) {
+      console.log(`⚠️  ${file.path}: ${(e as Error).message}`);
+    }
+  }
+
+  // El CHANGELOG lo escribe una persona; acá sólo avisamos si falta la entrada.
+  try {
+    const changelog = await Bun.file("CHANGELOG.md").text();
+    if (!changelog.includes(`## ${newVersion}`)) {
+      console.log(`\n⚠️  CHANGELOG.md no tiene una sección "## ${newVersion}". Agregala antes de publicar.`);
+    }
+  } catch {
+    console.log("\n⚠️  No hay CHANGELOG.md.");
+  }
+
+  const { execSync } = await import("child_process");
+  const run = (cmd: string) => execSync(cmd, { stdio: "inherit" });
+
+  console.log(`\n✨ Archivos actualizados. Versión: ${newVersion}\n`);
+
+  if (!shouldPush) {
+    console.log("Sin --push: no se tocó git. Revisá `git diff`, y cuando estés conforme:");
+    console.log(`  bun scripts/bump-version.ts ${explicitVersion || bumpType} --push${npmTag !== "latest" ? ` --npm-tag=${npmTag}` : ""}\n`);
+    return;
+  }
+
+  // ── Git: commit, tag y push — con confirmación antes de publicar ──────────
+  console.log("Antes de publicar corro typecheck y tests.\n");
+  try {
+    run("bun run typecheck");
+    run("bun test");
+  } catch {
+    console.log("\n❌ typecheck o tests fallaron. No se publica.");
+    process.exit(1);
+  }
+
+  console.log("\nEsto es lo que se va a commitear (git add -A):\n");
+  run("git status --short");
+
+  const tagExists = (() => {
+    try {
+      execSync(`git rev-parse v${newVersion}`, { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+
+  if (tagExists) {
+    console.log(`\n⚠️  El tag v${newVersion} ya existe localmente. Suele indicar que esta`);
+    console.log(`   versión ya se publicó. Abortando — si es intencional, borralo primero`);
+    console.log(`   (git tag -d v${newVersion}) y volvé a correr con --push.`);
+    process.exit(1);
+  }
+
+  const branch = execSync("git branch --show-current").toString().trim();
+
+  console.log(`\nEsto va a: commitear todo lo de arriba como "chore: release v${newVersion}",`);
+  console.log(`crear el tag v${newVersion}, y pushear ${branch} + el tag a origin.`);
+  console.log(`El push del tag dispara publish.yml, que publica en npm con dist-tag "${npmTag}".\n`);
+
+  const ok = await confirm(`¿Publicar v${newVersion} como "${npmTag}"?`);
+  if (!ok) {
+    console.log("Cancelado. No se tocó git.");
+    return;
+  }
+
+  console.log("🔧 Committing changes...");
+  run("git add -A");
+  try {
+    run(`git commit -m "chore: release v${newVersion}"`);
+  } catch {
+    console.log("   (nothing to commit, skipping)");
+  }
+
+  console.log(`🏷️  Creating tag v${newVersion}...`);
+  // El dist-tag viaja en el mensaje del tag: publish.yml lo lee de ahí.
+  run(`git tag -a v${newVersion} -m "release v${newVersion} [npm-tag:${npmTag}]"`);
+
+  console.log("🚀 Pushing commit and tag...");
+  run(`git push origin ${branch}`);
+  run(`git push origin v${newVersion}`);
+
+  console.log(`\n🎉 Released v${newVersion} (dist-tag: ${npmTag})\n`);
+  console.log(`Verificá en unos minutos:  npm view ${rootPkg.name} dist-tags\n`);
+}
+
+main().catch(console.error);