heyhank 0.1.0

package/server/routes/git-routes.ts

@@ -0,0 +1,97 @@
+import { execSync } from "node:child_process";
+import type { Hono } from "hono";
+import * as gitUtils from "../git-utils.js";
+import type { PRPoller } from "../pr-poller.js";
+
+export function registerGitRoutes(api: Hono, prPoller?: PRPoller): void {
+  api.get("/git/repo-info", (c) => {
+    const path = c.req.query("path");
+    if (!path) return c.json({ error: "path required" }, 400);
+    const info = gitUtils.getRepoInfo(path);
+    if (!info) return c.json({ error: "Not a git repository" }, 400);
+    return c.json(info);
+  });
+
+  api.get("/git/branches", (c) => {
+    const repoRoot = c.req.query("repoRoot");
+    if (!repoRoot) return c.json({ error: "repoRoot required" }, 400);
+    try {
+      return c.json(gitUtils.listBranches(repoRoot));
+    } catch (e: unknown) {
+      return c.json({ error: e instanceof Error ? e.message : String(e) }, 500);
+    }
+  });
+
+  api.post("/git/fetch", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const { repoRoot } = body;
+    if (!repoRoot) return c.json({ error: "repoRoot required" }, 400);
+    return c.json(gitUtils.gitFetch(repoRoot));
+  });
+
+  api.get("/git/worktrees", (c) => {
+    const repoRoot = c.req.query("repoRoot");
+    if (!repoRoot) return c.json({ error: "repoRoot required" }, 400);
+    return c.json(gitUtils.listWorktrees(repoRoot));
+  });
+
+  api.post("/git/worktree", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const { repoRoot, branch, baseBranch, createBranch } = body;
+    if (!repoRoot || !branch) return c.json({ error: "repoRoot and branch required" }, 400);
+    const result = gitUtils.ensureWorktree(repoRoot, branch, { baseBranch, createBranch });
+    return c.json(result);
+  });
+
+  api.delete("/git/worktree", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const { repoRoot, worktreePath, force } = body;
+    if (!repoRoot || !worktreePath) return c.json({ error: "repoRoot and worktreePath required" }, 400);
+    const result = gitUtils.removeWorktree(repoRoot, worktreePath, { force });
+    return c.json(result);
+  });
+
+  api.post("/git/pull", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const { cwd } = body;
+    if (!cwd) return c.json({ error: "cwd required" }, 400);
+    const result = gitUtils.gitPull(cwd);
+    let git_ahead = 0;
+    let git_behind = 0;
+    try {
+      const counts = execSync(
+        "git rev-list --left-right --count @{upstream}...HEAD",
+        {
+          cwd,
+          encoding: "utf-8",
+          timeout: 3000,
+        },
+      ).trim();
+      const [behind, ahead] = counts.split(/\s+/).map(Number);
+      git_ahead = ahead || 0;
+      git_behind = behind || 0;
+    } catch {
+      // no upstream
+    }
+    return c.json({ ...result, git_ahead, git_behind });
+  });
+
+  api.get("/git/pr-status", async (c) => {
+    const cwd = c.req.query("cwd");
+    const branch = c.req.query("branch");
+    if (!cwd || !branch) return c.json({ error: "cwd and branch required" }, 400);
+
+    if (prPoller) {
+      const cached = prPoller.getCached(cwd, branch);
+      if (cached) return c.json(cached);
+    }
+
+    const { isGhAvailable, fetchPRInfoAsync } = await import("../github-pr.js");
+    if (!isGhAvailable()) {
+      return c.json({ available: false, pr: null });
+    }
+
+    const pr = await fetchPRInfoAsync(cwd, branch);
+    return c.json({ available: true, pr });
+  });
+}

package/server/routes/llm-routes.ts

@@ -0,0 +1,166 @@
+// ─── LLM Provider Routes ─────────────────────────────────────────────────────
+// REST API for calling non-CLI LLM providers (Ollama, OpenRouter, Gemini)
+
+import type { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import {
+  callLLM,
+  streamOllama,
+  listOllamaModels,
+  pullOllamaModel,
+} from "../llm-providers.js";
+import type { LLMProviderConfig, LLMMessage } from "../llm-providers.js";
+
+export function registerLLMRoutes(api: Hono): void {
+  /** Call an LLM provider (non-streaming) */
+  api.post("/llm/chat", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+
+    if (!body.messages || !body.provider || !body.model) {
+      return c.json(
+        { error: "messages, provider, and model are required" },
+        400,
+      );
+    }
+
+    const config: LLMProviderConfig = {
+      provider: body.provider,
+      model: body.model,
+      apiKey: body.apiKey,
+      baseUrl: body.baseUrl,
+      temperature: body.temperature,
+      maxTokens: body.maxTokens,
+    };
+
+    try {
+      const response = await callLLM(body.messages as LLMMessage[], config);
+      return c.json(response);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ error: message }, 500);
+    }
+  });
+
+  /** Stream from Ollama via SSE */
+  api.post("/llm/stream", (c) => {
+    return streamSSE(c, async (stream) => {
+      let body: Record<string, unknown>;
+      try {
+        body = await c.req.json();
+      } catch {
+        await stream.writeSSE({ data: JSON.stringify({ error: "Invalid JSON" }) });
+        return;
+      }
+
+      if (!body.messages || !body.model) {
+        await stream.writeSSE({
+          data: JSON.stringify({ error: "messages and model required" }),
+        });
+        return;
+      }
+
+      const config: LLMProviderConfig = {
+        provider: (body.provider as LLMProviderConfig["provider"]) || "ollama",
+        model: body.model as string,
+        baseUrl: body.baseUrl as string | undefined,
+        temperature: body.temperature as number | undefined,
+        maxTokens: body.maxTokens as number | undefined,
+      };
+
+      try {
+        if (config.provider === "ollama") {
+          for await (const chunk of streamOllama(
+            body.messages as LLMMessage[],
+            config,
+          )) {
+            await stream.writeSSE({
+              data: JSON.stringify(chunk),
+            });
+            if (chunk.done) break;
+          }
+        } else {
+          // Non-streaming fallback for other providers
+          const response = await callLLM(
+            body.messages as LLMMessage[],
+            config,
+          );
+          await stream.writeSSE({
+            data: JSON.stringify({ content: response.content, done: true }),
+          });
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        await stream.writeSSE({ data: JSON.stringify({ error: message }) });
+      }
+    });
+  });
+
+  /** List available Ollama models */
+  api.get("/llm/ollama/models", async (c) => {
+    const models = await listOllamaModels();
+    return c.json({ models });
+  });
+
+  /** Pull an Ollama model */
+  api.post("/llm/ollama/pull", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    if (!body.model) {
+      return c.json({ error: "model is required" }, 400);
+    }
+    try {
+      await pullOllamaModel(body.model);
+      return c.json({ ok: true, model: body.model });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ error: message }, 500);
+    }
+  });
+
+  /** Get available providers and their status */
+  api.get("/llm/providers", async (c) => {
+    const providers = [];
+
+    // Check Ollama
+    try {
+      const models = await listOllamaModels();
+      providers.push({
+        name: "ollama",
+        status: "available",
+        models: models.map((m) => m.name),
+        endpoint: "http://localhost:11434",
+      });
+    } catch {
+      providers.push({ name: "ollama", status: "unavailable", models: [] });
+    }
+
+    // Check OpenRouter
+    providers.push({
+      name: "openrouter",
+      status: process.env.OPENROUTER_API_KEY ? "configured" : "needs_api_key",
+      endpoint: "https://openrouter.ai/api/v1",
+    });
+
+    // Check Gemini
+    providers.push({
+      name: "gemini",
+      status: process.env.GEMINI_API_KEY ? "configured" : "needs_api_key",
+      endpoint: "https://generativelanguage.googleapis.com/v1beta",
+    });
+
+    // Claude (always via CLI)
+    providers.push({
+      name: "claude",
+      status: "available",
+      note: "Uses Claude CLI (Max subscription)",
+    });
+
+    // Codex (always via CLI)
+    providers.push({
+      name: "codex",
+      status: "available",
+      note: "Uses Codex CLI",
+    });
+
+    return c.json({ providers });
+  });
+}

package/server/routes/media-routes.ts

@@ -0,0 +1,135 @@
+// ─── Media Routes ─────────────────────────────────────────────────────────────
+// Image generation (Imagen) and Video generation (Veo) via Google AI APIs
+
+import type { Hono } from "hono";
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join, basename } from "node:path";
+import { HEYHANK_HOME } from "../paths.js";
+import { generateImage, generateVideo, pollVideoOperation, listMedia } from "../google-media.js";
+
+const MEDIA_DIR = join(HEYHANK_HOME, "media");
+
+const MIME_TYPES: Record<string, string> = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  gif: "image/gif",
+  mp4: "video/mp4",
+  webm: "video/webm",
+};
+
+export function registerMediaRoutes(api: Hono): void {
+  /** Generate an image using Imagen/Gemini */
+  api.post("/media/generate-image", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    if (!body.prompt) {
+      return c.json({ error: "prompt is required" }, 400);
+    }
+    try {
+      const results = await generateImage(body.prompt, {
+        model: body.model,
+        aspectRatio: body.aspectRatio,
+        numberOfImages: body.numberOfImages,
+      });
+      return c.json({ ok: true, images: results });
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ error: message }, 500);
+    }
+  });
+
+  /** Start video generation using Veo */
+  api.post("/media/generate-video", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    if (!body.prompt) {
+      return c.json({ error: "prompt is required" }, 400);
+    }
+    try {
+      const result = await generateVideo(body.prompt, {
+        model: body.model,
+        durationSeconds: body.durationSeconds,
+        aspectRatio: body.aspectRatio,
+        imageUri: body.imageUri,
+      });
+      return c.json({ ok: true, ...result });
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ error: message }, 500);
+    }
+  });
+
+  /** Poll a video generation operation */
+  api.get("/media/video-status/:operationName{.+}", async (c) => {
+    const operationName = c.req.param("operationName");
+    try {
+      const result = await pollVideoOperation(operationName);
+      return c.json(result);
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ error: message }, 500);
+    }
+  });
+
+  /** Upload a media file (image/video) */
+  api.post("/media/upload", async (c) => {
+    try {
+      const contentType = c.req.header("content-type") || "";
+      let filename: string;
+      let data: Buffer;
+
+      if (contentType.includes("multipart/form-data")) {
+        const formData = await c.req.formData();
+        const file = formData.get("file");
+        if (!file || !(file instanceof File)) {
+          return c.json({ error: "Missing 'file' field" }, 400);
+        }
+        const ext = file.name.split(".").pop()?.toLowerCase() || "png";
+        filename = `upload_${Date.now()}_${Math.random().toString(36).slice(2, 8)}.${ext}`;
+        data = Buffer.from(await file.arrayBuffer());
+      } else {
+        // Base64 JSON body: { base64, mimeType, filename? }
+        const body = await c.req.json().catch(() => ({}));
+        if (!body.base64) {
+          return c.json({ error: "base64 data is required" }, 400);
+        }
+        const mime = body.mimeType || "image/png";
+        const ext = mime.includes("png") ? "png" : mime.includes("jpeg") || mime.includes("jpg") ? "jpg" : mime.includes("webp") ? "webp" : mime.includes("mp4") ? "mp4" : "bin";
+        filename = body.filename || `upload_${Date.now()}_${Math.random().toString(36).slice(2, 8)}.${ext}`;
+        data = Buffer.from(body.base64, "base64");
+      }
+
+      mkdirSync(MEDIA_DIR, { recursive: true });
+      const filepath = join(MEDIA_DIR, filename);
+      writeFileSync(filepath, data);
+
+      return c.json({ ok: true, filename, url: `/api/media/file/${filename}` });
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ error: message }, 500);
+    }
+  });
+
+  /** List all generated media files */
+  api.get("/media", (c) => {
+    return c.json({ files: listMedia() });
+  });
+
+  /** Serve a media file by filename */
+  api.get("/media/file/:filename", (c) => {
+    const filename = basename(c.req.param("filename"));
+    const filepath = join(MEDIA_DIR, filename);
+    if (!existsSync(filepath)) {
+      return c.json({ error: "Not found" }, 404);
+    }
+    const ext = filename.split(".").pop()?.toLowerCase() || "";
+    const mime = MIME_TYPES[ext] || "application/octet-stream";
+    const data = readFileSync(filepath);
+    return new Response(data, {
+      headers: {
+        "Content-Type": mime,
+        "Cache-Control": "public, max-age=86400",
+      },
+    });
+  });
+}

package/server/routes/metrics-routes.ts

@@ -0,0 +1,13 @@
+import type { Hono } from "hono";
+import type { GaugeDataProvider } from "../metrics-collector.js";
+import { metricsCollector } from "../metrics-collector.js";
+
+export function registerMetricsRoutes(
+  api: Hono,
+  deps: { gaugeProvider: GaugeDataProvider },
+): void {
+  api.get("/metrics", (c) => {
+    const snapshot = metricsCollector.getSnapshot(deps.gaugeProvider);
+    return c.json(snapshot);
+  });
+}