@k-leumas/queque-cli 0.1.0

package/dist/cli/main.js

@@ -0,0 +1,1265 @@
+// src/cli/main.ts
+import * as fs2 from "fs";
+import { cac } from "cac";
+
+// src/context/providers/filesystem-context.ts
+var FILENAME_RE = /\b[\w.-]+\.\w{2,6}\b/g;
+var filesystemContextProvider = {
+  id: "filesystem-context",
+  intents: ["filesystem"],
+  async gather(input) {
+    const match = input.base.queryText.match(FILENAME_RE);
+    return {
+      kind: "filesystem",
+      payload: {
+        cwd: input.base.cwd,
+        apparentFilename: match?.[0] ?? null
+      }
+    };
+  }
+};
+
+// src/context/providers/git-context.ts
+import { execFile as execFile2 } from "child_process";
+import { statSync } from "fs";
+import { promisify as promisify2 } from "util";
+
+// src/shared/debug-log.ts
+import * as fsp from "fs/promises";
+var debugLogPath = process.env.QQ_DEBUG_LOG_FILE ?? `/tmp/qq-${process.getuid?.() ?? "unknown"}-debug.log`;
+function formatDetails(details) {
+  if (details === void 0) return "";
+  try {
+    return ` ${JSON.stringify(details)}`;
+  } catch {
+    return " [unserializable-details]";
+  }
+}
+async function appendDebugLog(scope, message, details) {
+  const line = `${(/* @__PURE__ */ new Date()).toISOString()} [${scope}] ${message}${formatDetails(details)}
+`;
+  try {
+    await fsp.appendFile(debugLogPath, line, { encoding: "utf-8", mode: 384 });
+  } catch {
+  }
+}
+
+// src/shared/vcs-context.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function runGit(cwd, args) {
+  try {
+    const { stdout } = await execFileAsync("git", ["-C", cwd, ...args], { encoding: "utf8" });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+async function detectVcsContext(cwd) {
+  const insideWorkTree = await runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  if (insideWorkTree !== "true") {
+    return { kind: "none", cwd };
+  }
+  const root = await runGit(cwd, ["rev-parse", "--show-toplevel"]) ?? cwd;
+  const branch = await runGit(cwd, ["branch", "--show-current"]) || null;
+  const dirty = Boolean((await runGit(cwd, ["status", "--porcelain=v1"]))?.length);
+  return {
+    kind: "git",
+    cwd,
+    root,
+    branch,
+    dirty
+  };
+}
+
+// src/context/providers/git-context.ts
+var execFileAsync2 = promisify2(execFile2);
+var GIT_TIMEOUT_MS = 5e3;
+function assertSafeCwd(cwd) {
+  let st;
+  try {
+    st = statSync(cwd);
+  } catch {
+    throw new Error(`cwd not accessible: ${cwd}`);
+  }
+  if (!st.isDirectory()) throw new Error(`cwd is not a directory: ${cwd}`);
+}
+function unescapeGitPath(s) {
+  return s.replace(/\\([0-7]{3})/g, (_, oct) => String.fromCodePoint(parseInt(oct, 8))).replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\\\/g, "\\");
+}
+function stripQuotes(value) {
+  if (value.startsWith('"') && value.endsWith('"')) {
+    return unescapeGitPath(value.slice(1, -1));
+  }
+  return value;
+}
+function parsePorcelainLine(line) {
+  if (line.length < 4) {
+    return null;
+  }
+  const rest = line.slice(3);
+  const renameSeparator = " -> ";
+  const renameIndex = rest.indexOf(renameSeparator);
+  if (renameIndex !== -1) {
+    return stripQuotes(rest.slice(renameIndex + renameSeparator.length));
+  }
+  return stripQuotes(rest);
+}
+async function getChangedFiles(cwd) {
+  try {
+    assertSafeCwd(cwd);
+    const { stdout } = await execFileAsync2("git", ["-C", cwd, "status", "--porcelain"], {
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS
+    });
+    return stdout.split("\n").filter(Boolean).map(parsePorcelainLine).filter((path2) => path2 !== null);
+  } catch {
+    return [];
+  }
+}
+var gitContextProvider = {
+  id: "git-context",
+  intents: ["codebase", "shell-command"],
+  async gather(input) {
+    if (input.decision.intent === "shell-command" && !input.decision.signals.includes("git-prefix")) {
+      return null;
+    }
+    try {
+      const vcs = await detectVcsContext(input.base.cwd);
+      if (vcs.kind === "none") {
+        return null;
+      }
+      const changedFiles = await getChangedFiles(input.base.cwd);
+      void appendDebugLog("context", "git provider gathered", {
+        cwd: input.base.cwd,
+        branch: vcs.branch,
+        dirty: vcs.dirty,
+        changedFiles: changedFiles.length
+      });
+      return {
+        kind: "git",
+        payload: {
+          cwd: vcs.cwd,
+          root: vcs.root,
+          branch: vcs.branch,
+          dirty: vcs.dirty,
+          changedFiles
+        }
+      };
+    } catch (error) {
+      void appendDebugLog("context", "git provider failed", {
+        cwd: input.base.cwd,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+};
+
+// src/registry/context-providers.ts
+var registry = /* @__PURE__ */ new Map();
+function registerContextProvider(descriptor) {
+  if (registry.has(descriptor.id)) {
+    throw new Error(`Context provider already registered: "${descriptor.id}"`);
+  }
+  registry.set(descriptor.id, descriptor);
+}
+function listContextProviders() {
+  return Array.from(registry.values());
+}
+
+// src/registry/provider-backends.ts
+var registry2 = /* @__PURE__ */ new Map();
+function registerProviderBackend(descriptor) {
+  if (registry2.has(descriptor.id)) {
+    throw new Error(`Provider backend already registered: "${descriptor.id}"`);
+  }
+  registry2.set(descriptor.id, descriptor);
+}
+
+// src/registry/shell-adapters.ts
+var registry3 = /* @__PURE__ */ new Map();
+function registerShellAdapter(descriptor) {
+  if (registry3.has(descriptor.id)) {
+    throw new Error(`Shell adapter already registered: "${descriptor.id}"`);
+  }
+  registry3.set(descriptor.id, descriptor);
+}
+
+// src/registry/storage-hooks.ts
+var registry4 = /* @__PURE__ */ new Map();
+function registerStorageHook(descriptor) {
+  if (registry4.has(descriptor.id)) {
+    throw new Error(`Storage hook already registered: "${descriptor.id}"`);
+  }
+  registry4.set(descriptor.id, descriptor);
+}
+
+// src/registry/bootstrap.ts
+var bootstrapped = false;
+function bootstrapBuiltins() {
+  if (bootstrapped) {
+    return;
+  }
+  bootstrapped = true;
+  registerContextProvider(gitContextProvider);
+  registerContextProvider(filesystemContextProvider);
+  registerShellAdapter({
+    id: "zsh",
+    shell: "zsh",
+    description: "zsh ZLE widget adapter (Phase 2 built-in)"
+  });
+  registerStorageHook({
+    id: "noop",
+    description: "No-op storage hook (default \u2014 no persistence)"
+  });
+  registerStorageHook({
+    id: "memory",
+    description: "In-memory storage hook (test and ephemeral use)"
+  });
+  registerProviderBackend({
+    id: "claude",
+    name: "Claude (Anthropic)",
+    description: "Anthropic Claude adapter \u2014 default LLM backend"
+  });
+}
+
+// src/client/run-foreground.ts
+import * as fsp4 from "fs/promises";
+import * as tty from "tty";
+import { render } from "ink";
+import React from "react";
+
+// src/contracts/request.ts
+import { z as z2 } from "zod";
+
+// src/contracts/shell.ts
+import { z } from "zod";
+var shellRequestSchema = z.object({
+  version: z.literal(1),
+  ttyPath: z.string(),
+  cwd: z.string().regex(/^\/[^\0]*$/, "cwd must be an absolute POSIX path"),
+  shellPid: z.number().int().positive(),
+  lbuffer: z.string(),
+  rbuffer: z.string()
+});
+var shellResultSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("cancel")
+  }).strict(),
+  z.object({
+    kind: z.literal("replace-buffer"),
+    lbuffer: z.string(),
+    rbuffer: z.string(),
+    query: z.string().optional()
+  }),
+  z.object({
+    kind: z.literal("error"),
+    message: z.string()
+  })
+]);
+
+// src/contracts/request.ts
+var requestIntentSchema = z2.enum([
+  "shell-command",
+  "codebase",
+  "filesystem",
+  "general",
+  "unknown"
+]);
+var normalizedRequestSchema = shellRequestSchema.extend({
+  intent: requestIntentSchema,
+  confidence: z2.number().min(0).max(1)
+});
+var baseContextSchema = z2.object({
+  queryText: z2.string(),
+  cwd: z2.string(),
+  ttyPath: z2.string(),
+  shellPid: z2.number().int().positive(),
+  /** Hardcoded 'zsh' for Phase 2 — cross-shell support is v2 scope. */
+  shellName: z2.literal("zsh"),
+  platform: z2.string(),
+  timestamp: z2.string()
+});
+var intentDecisionSchema = z2.object({
+  intent: requestIntentSchema,
+  confidence: z2.number().min(0).max(1),
+  signals: z2.array(z2.string())
+});
+var contextChunkSchema = z2.discriminatedUnion("kind", [
+  z2.object({
+    kind: z2.literal("git"),
+    payload: z2.object({
+      cwd: z2.string(),
+      root: z2.string(),
+      branch: z2.string().nullable(),
+      dirty: z2.boolean(),
+      /** File paths only (from git status --porcelain). No diff content, no file bytes. */
+      changedFiles: z2.array(z2.string())
+    })
+  }),
+  z2.object({
+    kind: z2.literal("filesystem"),
+    payload: z2.object({
+      cwd: z2.string(),
+      /** Apparent filename extracted from query text. No file bytes read. */
+      apparentFilename: z2.string().nullable()
+    })
+  })
+]);
+var contextEnvelopeSchema = z2.object({
+  base: baseContextSchema,
+  extras: z2.array(contextChunkSchema)
+});
+
+// src/intent/router.ts
+var GIT_PREFIX_RE = /^git\s/;
+var PKG_MANAGER_RE = /^(npm|pnpm|yarn)\s+(test|build|lint|run|start|dev|check|format|typecheck)\b/i;
+var FILESYSTEM_KEYWORDS_RE = /\b(?:rename|move(?:\s+file)?|find\s+files?|copy|delete|list\s+files?|image|folder|directory)\b/i;
+var SHELL_COMMAND_RE = /^(ls|echo|grep|awk|sed|curl|wget|ssh|cat|head|tail|cd|pwd|mkdir|touch|chmod|cp|mv|rm|which|man|ps|kill|sudo|command)\s|\|/;
+var FILE_PATH_RE = /(?:\/|\.\/|~\/|\.[a-zA-Z][\w-]*(?:\.\w+)?(?=\s|$)|\b[\w-]+\.(?:ts|tsx|js|jsx|mjs|cjs|py|go|rs|rb|java|sh|md|json|yaml|yml|toml|env|html|css|scss|txt|xml|svg|png|jpg|jpeg|gif|pdf|zip|tar|gz|lock|config)(?:\b|$))/;
+function classifyIntent(request) {
+  const query = request.lbuffer.trim();
+  if (query.length === 0) {
+    return {
+      intent: requestIntentSchema.enum.unknown,
+      confidence: 1,
+      signals: ["empty-query"]
+    };
+  }
+  if (GIT_PREFIX_RE.test(query)) {
+    return {
+      intent: requestIntentSchema.enum["shell-command"],
+      confidence: 1,
+      signals: ["git-prefix"]
+    };
+  }
+  if (PKG_MANAGER_RE.test(query)) {
+    return {
+      intent: requestIntentSchema.enum.codebase,
+      confidence: 1,
+      signals: ["pkg-manager-script"]
+    };
+  }
+  if (FILESYSTEM_KEYWORDS_RE.test(query)) {
+    return {
+      intent: requestIntentSchema.enum.filesystem,
+      confidence: 0.85,
+      signals: ["filesystem-keyword"]
+    };
+  }
+  if (SHELL_COMMAND_RE.test(query)) {
+    return {
+      intent: requestIntentSchema.enum["shell-command"],
+      confidence: 0.8,
+      signals: ["shell-command-signal"]
+    };
+  }
+  if (FILE_PATH_RE.test(query)) {
+    return {
+      intent: requestIntentSchema.enum.codebase,
+      confidence: 0.9,
+      signals: ["file-path-signal"]
+    };
+  }
+  return {
+    intent: requestIntentSchema.enum.general,
+    confidence: 0.5,
+    signals: ["no-strong-signal"]
+  };
+}
+
+// src/context/base-context.ts
+function buildBaseContext(request) {
+  return {
+    queryText: request.lbuffer.trim(),
+    cwd: request.cwd,
+    ttyPath: request.ttyPath,
+    shellPid: request.shellPid,
+    shellName: "zsh",
+    platform: process.platform,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/context/pipeline.ts
+async function gatherContext(request) {
+  void appendDebugLog("context", "pipeline start", {
+    lbuffer: request.lbuffer,
+    intent: request.intent
+  });
+  const base = buildBaseContext(request);
+  const decision = classifyIntent(request);
+  void appendDebugLog("context", "intent decision", {
+    intent: decision.intent,
+    signals: decision.signals
+  });
+  const extras = [];
+  const providers = listContextProviders();
+  for (const provider of providers) {
+    const supportsAllIntents = provider.intents.includes("*");
+    const supportsIntent = provider.intents.includes(decision.intent);
+    if (!supportsAllIntents && !supportsIntent) {
+      continue;
+    }
+    try {
+      const chunk = await provider.gather({ base, decision });
+      if (chunk !== null) {
+        extras.push(chunk);
+        void appendDebugLog("context", "provider chunk gathered", {
+          providerId: provider.id,
+          kind: chunk.kind
+        });
+      }
+    } catch (error) {
+      void appendDebugLog("context", "provider error", {
+        providerId: provider.id,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const envelope = { base, extras };
+  void appendDebugLog("context", "envelope assembled", { extraCount: extras.length });
+  return envelope;
+}
+
+// src/daemon/bootstrap.ts
+import { spawn } from "child_process";
+import * as fs from "fs";
+import * as net from "net";
+import * as path from "path";
+import { fileURLToPath } from "url";
+var CONNECT_TIMEOUT_MS = 500;
+var POLL_INTERVAL_MS = 50;
+var POLL_MAX_ATTEMPTS = 40;
+function tryConnect(socketPath2) {
+  return new Promise((resolve2) => {
+    const timer = setTimeout(() => {
+      client.destroy();
+      resolve2(false);
+    }, CONNECT_TIMEOUT_MS);
+    const client = net.createConnection(socketPath2, () => {
+      clearTimeout(timer);
+      client.destroy();
+      resolve2(true);
+    });
+    client.on("error", () => {
+      clearTimeout(timer);
+      resolve2(false);
+    });
+  });
+}
+async function waitForSocket(socketPath2, maxAttempts = POLL_MAX_ATTEMPTS) {
+  for (let i = 0; i < maxAttempts; i++) {
+    if (await tryConnect(socketPath2)) return true;
+    await new Promise((res) => setTimeout(res, POLL_INTERVAL_MS));
+  }
+  return false;
+}
+function assertSafeSocketPath(socketPath2) {
+  const resolved = path.resolve(socketPath2);
+  const base = path.basename(resolved);
+  const dir = path.dirname(resolved);
+  const tmpRoots = ["/tmp", "/private/tmp"];
+  if (!tmpRoots.includes(dir) || !base.startsWith("qq-") || !base.endsWith(".sock")) {
+    throw new Error(`unsafe socket path rejected: ${socketPath2}`);
+  }
+}
+async function ensureDaemon(socketPath2) {
+  assertSafeSocketPath(socketPath2);
+  void appendDebugLog("daemon", "ensure start", { socketPath: socketPath2 });
+  if (await tryConnect(socketPath2)) {
+    void appendDebugLog("daemon", "already running", { socketPath: socketPath2 });
+    return;
+  }
+  try {
+    fs.unlinkSync(socketPath2);
+  } catch {
+  }
+  const qqBin = process.execPath;
+  const qqScript = fileURLToPath(import.meta.url);
+  if (!fs.existsSync(qqScript)) {
+    void appendDebugLog("daemon", "script missing", { qqScript });
+    throw new Error(`qq daemon script not found at: ${qqScript}. Run 'pnpm build' first.`);
+  }
+  void appendDebugLog("daemon", "spawning daemon", { qqScript, socketPath: socketPath2 });
+  const child = spawn(qqBin, [qqScript, "daemon", "--socket", socketPath2], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  const started = await waitForSocket(socketPath2);
+  if (!started) {
+    void appendDebugLog("daemon", "startup timeout", { socketPath: socketPath2 });
+    throw new Error(`qq daemon did not start within the expected window (${socketPath2})`);
+  }
+  void appendDebugLog("daemon", "daemon ready", { socketPath: socketPath2 });
+}
+
+// src/providers/claude.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/contracts/candidates.ts
+import { z as z3 } from "zod";
+var commandCandidateSchema = z3.object({
+  command: z3.string().min(1),
+  explanation: z3.string()
+});
+var candidateListSchema = z3.array(commandCandidateSchema).min(1).max(5);
+
+// src/shared/env-file.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { dirname as dirname2, join } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function findUp(startDir, filename) {
+  let current = startDir;
+  while (true) {
+    const candidate = join(current, filename);
+    if (existsSync2(candidate)) {
+      return candidate;
+    }
+    const parent = dirname2(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function parseEnvFile(content) {
+  const values = /* @__PURE__ */ new Map();
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    const match = line.match(/^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+    if (!match) {
+      continue;
+    }
+    const [, key, rawValue] = match;
+    let value = rawValue.trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    values.set(key, value);
+  }
+  return values;
+}
+var envCache = /* @__PURE__ */ new Map();
+function readEnvValueFromDotEnvLocal(key, startDir = dirname2(fileURLToPath2(import.meta.url))) {
+  const cacheKey = `${key}\0${startDir}`;
+  if (envCache.has(cacheKey)) {
+    return envCache.get(cacheKey) ?? null;
+  }
+  const envPath = findUp(startDir, ".env.local");
+  if (!envPath) {
+    envCache.set(cacheKey, null);
+    return null;
+  }
+  const values = parseEnvFile(readFileSync(envPath, "utf8"));
+  const result = values.get(key) ?? null;
+  envCache.set(cacheKey, result);
+  return result;
+}
+
+// src/providers/claude.ts
+var DEFAULT_MODEL = "claude-haiku-4-5-20251001";
+function resolveModel() {
+  return process.env.QQ_MODEL ?? readEnvValueFromDotEnvLocal("QQ_MODEL") ?? DEFAULT_MODEL;
+}
+function extractText(content) {
+  return content.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text ?? "").join("").trim();
+}
+function stripCodeFence(raw) {
+  const m = raw.trim().match(/^```(?:json)?\s*\n?([\s\S]*?)\n?```\s*$/);
+  return m ? m[1].trim() : raw.trim();
+}
+function parseCandidates(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stripCodeFence(text));
+  } catch {
+    const trimmed = text.trim();
+    return [{ command: trimmed || 'echo ""', explanation: "" }];
+  }
+  try {
+    return candidateListSchema.parse(parsed);
+  } catch {
+    return [{ command: 'echo ""', explanation: "QueQue: unexpected response format" }];
+  }
+}
+function shouldForceSelector() {
+  const configured = process.env.QQ_FORCE_SELECTOR ?? readEnvValueFromDotEnvLocal("QQ_FORCE_SELECTOR");
+  return configured === "1" || configured === "true";
+}
+function ensureSelectableCandidates(candidates) {
+  if (!shouldForceSelector() || candidates.length >= 2) {
+    return candidates;
+  }
+  const [first] = candidates;
+  return [
+    first,
+    {
+      command: first.command,
+      explanation: first.explanation.length > 0 ? `${first.explanation} (forced duplicate for selector testing)` : "Forced duplicate for selector testing."
+    }
+  ];
+}
+function buildPrompt(envelope) {
+  const gitChunk = envelope.extras.find((chunk) => chunk.kind === "git");
+  return [
+    "Return ONLY a JSON array of 1-3 shell command candidates, most likely first.",
+    'Each item must have exactly these keys: "command" and "explanation".',
+    "No markdown, no prose, no code fences. Raw JSON array only.",
+    "",
+    "The command should be safe to place back into a shell buffer.",
+    "",
+    "Shell context:",
+    JSON.stringify(
+      {
+        cwd: envelope.base.cwd,
+        queryText: envelope.base.queryText,
+        platform: envelope.base.platform,
+        shellName: envelope.base.shellName,
+        ...gitChunk ? { versionControl: gitChunk.payload } : {}
+      },
+      null,
+      2
+    )
+  ].join("\n");
+}
+async function fetchCandidates(envelope, rbuffer = "") {
+  const apiKey = process.env.ANTHROPIC_API_KEY ?? readEnvValueFromDotEnvLocal("ANTHROPIC_API_KEY");
+  if (!apiKey) {
+    throw new Error("ANTHROPIC_API_KEY is required in the environment or .env.local");
+  }
+  const client = new Anthropic({ apiKey });
+  const prompt = buildPrompt(envelope);
+  const model = resolveModel();
+  void appendDebugLog("provider", "request start", {
+    model,
+    cwd: envelope.base.cwd,
+    rbufferLength: rbuffer.length,
+    extras: envelope.extras.map((chunk) => chunk.kind)
+  });
+  try {
+    const response = await client.messages.create(
+      {
+        model,
+        max_tokens: 1024,
+        temperature: 0,
+        system: "You are QueQue, a terminal shell assistant. Return ONLY a JSON array of command candidates, ranked with the most correct/direct command first. No prose, no markdown, no code fences. When a command requires a value the user must supply (hostname, filename, branch name, etc.), wrap it in angle brackets: <placeholder>. Use descriptive names like <user@host>, <filename>, <branch-name>. Do not use angle brackets for optional flags or known values.",
+        messages: [{ role: "user", content: prompt }]
+      },
+      {
+        timeout: 25e3
+        // 25s — slightly under the zsh 30s FIFO timeout
+      }
+    );
+    const text = extractText(response.content);
+    const candidates = ensureSelectableCandidates(parseCandidates(text));
+    void appendDebugLog("provider", "response parsed", {
+      model,
+      candidateCount: candidates.length,
+      forceSelector: shouldForceSelector()
+    });
+    return candidates;
+  } catch (error) {
+    void appendDebugLog("provider", "request failed", {
+      model,
+      message: error instanceof Error ? error.message : String(error)
+    });
+    throw error;
+  }
+}
+
+// src/providers/detect.ts
+import { execSync } from "child_process";
+import * as fsp2 from "fs/promises";
+import * as os from "os";
+function claudeOnPath() {
+  try {
+    execSync("which claude", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function claudeAuthFileExists() {
+  const home = os.homedir();
+  const candidates = [`${home}/.claude/.credentials.json`, `${home}/.claude/credentials.json`];
+  for (const p of candidates) {
+    try {
+      await fsp2.stat(p);
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function ollamaHealthy() {
+  try {
+    const res = await fetch("http://localhost:11434/api/tags", {
+      signal: AbortSignal.timeout(300)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function detectProvider() {
+  if (process.env.ANTHROPIC_API_KEY) {
+    return { kind: "anthropic-key" };
+  }
+  if (claudeOnPath() && await claudeAuthFileExists()) {
+    return { kind: "claude-cli" };
+  }
+  if (await ollamaHealthy()) {
+    return { kind: "ollama", baseUrl: "http://localhost:11434" };
+  }
+  if (process.env.OPENAI_API_KEY) {
+    return { kind: "openai-key" };
+  }
+  return { kind: "none" };
+}
+
+// src/shared/socket-path.ts
+function socketPathForUid(uid) {
+  return `/tmp/qq-${uid}.sock`;
+}
+function socketPath() {
+  return socketPathForUid(process.getuid?.() ?? 0);
+}
+
+// src/ui/CandidateSelect.tsx
+import { Box as Box4, Text as Text4, useInput } from "ink";
+import { useEffect as useEffect2, useState as useState2 } from "react";
+
+// src/ui/ControlsLine.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function ControlsLine() {
+  return /* @__PURE__ */ jsxs(Box, { marginTop: 1, children: [
+    /* @__PURE__ */ jsx(Text, { backgroundColor: "ansi256(238)", color: "white", bold: true, children: " \u2191\u2193 " }),
+    /* @__PURE__ */ jsx(Text, { backgroundColor: "ansi256(245)", color: "black", children: " select " }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \xB7 " }),
+    /* @__PURE__ */ jsx(Text, { backgroundColor: "ansi256(238)", color: "white", bold: true, children: " enter " }),
+    /* @__PURE__ */ jsx(Text, { backgroundColor: "ansi256(245)", color: "black", children: " accept " }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \xB7 " }),
+    /* @__PURE__ */ jsx(Text, { backgroundColor: "ansi256(238)", color: "white", bold: true, children: " esc " }),
+    /* @__PURE__ */ jsx(Text, { backgroundColor: "ansi256(245)", color: "black", children: " cancel " })
+  ] });
+}
+
+// src/ui/LoadingSpinner.tsx
+import { Text as Text2 } from "ink";
+import { useEffect, useState } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var FRAMES = ["thinking\u2026", "thinking.", "thinking..", "thinking\u2026"];
+function LoadingSpinner() {
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    const id = setInterval(() => {
+      setFrame((f) => (f + 1) % FRAMES.length);
+    }, 200);
+    return () => clearInterval(id);
+  }, []);
+  return /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: FRAMES[frame] });
+}
+
+// src/ui/Modal.tsx
+import { Box as Box2 } from "ink";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function Modal({ children, width = 80 }) {
+  return /* @__PURE__ */ jsx3(Box2, { flexDirection: "column", paddingX: 1, width, children });
+}
+
+// src/ui/SearchInput.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+function SearchInput({ query }) {
+  return /* @__PURE__ */ jsxs2(Box3, { children: [
+    /* @__PURE__ */ jsx4(Text3, { color: "cyan", bold: true, children: "FILTER: " }),
+    query ? /* @__PURE__ */ jsx4(Text3, { children: query }) : /* @__PURE__ */ jsx4(Text3, { dimColor: true, children: "type to filter\u2026" })
+  ] });
+}
+
+// src/ui/CandidateSelect.tsx
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+function filterCandidates(candidates, query) {
+  if (!query) return candidates;
+  const lower = query.toLowerCase();
+  return candidates.filter((c) => c.command.toLowerCase().includes(lower));
+}
+function CandidateSelect({
+  candidates,
+  initialQuery,
+  onSelect,
+  onCancel,
+  error
+}) {
+  const [selectedIndex, setSelectedIndex] = useState2(0);
+  const [query, setQuery] = useState2(initialQuery ?? "");
+  useEffect2(() => {
+    setSelectedIndex(0);
+    if (candidates && candidates.length > 0 && filterCandidates(candidates, query).length === 0) {
+      setQuery("");
+    }
+  }, [candidates]);
+  useEffect2(() => {
+    setSelectedIndex(0);
+  }, [query]);
+  useInput((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.backspace) {
+      setQuery((q) => q.slice(0, -1));
+      return;
+    }
+    if (key.return && candidates) {
+      const visible = filterCandidates(candidates, query);
+      if (visible.length === 0) return;
+      const selected = visible[selectedIndex] ?? visible[0];
+      const explanation = selected.explanation || `see man ${selected.command.split(" ")[0]}`;
+      onSelect(selected.command, explanation);
+      return;
+    }
+    if (input && !key.ctrl && !key.meta) {
+      setQuery((q) => q + input);
+      return;
+    }
+    if (key.upArrow && candidates) {
+      const visible = filterCandidates(candidates, query);
+      setSelectedIndex((i) => i === 0 ? visible.length - 1 : i - 1);
+      return;
+    }
+    if (key.downArrow && candidates) {
+      const visible = filterCandidates(candidates, query);
+      setSelectedIndex((i) => (i + 1) % visible.length);
+      return;
+    }
+  });
+  let content;
+  if (error === true) {
+    content = /* @__PURE__ */ jsx5(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text4, { dimColor: true, children: "provider error \u2014 press esc to return" }) });
+  } else if (candidates === null) {
+    content = /* @__PURE__ */ jsx5(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx5(LoadingSpinner, {}) });
+  } else {
+    const visible = filterCandidates(candidates, query);
+    if (visible.length === 0) {
+      content = /* @__PURE__ */ jsx5(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text4, { dimColor: true, children: "no matches \u2014 try a different query" }) });
+    } else {
+      content = /* @__PURE__ */ jsx5(Box4, { flexDirection: "column", marginTop: 1, children: visible.map((candidate, index) => {
+        const active = index === selectedIndex;
+        return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", marginBottom: 1, children: [
+          /* @__PURE__ */ jsxs3(Box4, { children: [
+            active ? /* @__PURE__ */ jsx5(Text4, { color: "ansi256(166)", children: "\u250C> " }) : /* @__PURE__ */ jsx5(Text4, { children: "   " }),
+            /* @__PURE__ */ jsx5(Text4, { bold: active, color: active ? "white" : void 0, dimColor: !active, children: candidate.command })
+          ] }),
+          candidate.explanation.length > 0 && /* @__PURE__ */ jsxs3(Box4, { children: [
+            /* @__PURE__ */ jsx5(Text4, { children: "   " }),
+            /* @__PURE__ */ jsx5(Text4, { dimColor: true, children: candidate.explanation })
+          ] })
+        ] }, candidate.command);
+      }) });
+    }
+  }
+  return /* @__PURE__ */ jsxs3(Modal, { children: [
+    initialQuery && initialQuery.length > 0 && /* @__PURE__ */ jsx5(Box4, { children: /* @__PURE__ */ jsx5(Text4, { dimColor: true, children: `queque \u203A ${initialQuery}` }) }),
+    /* @__PURE__ */ jsx5(SearchInput, { query }),
+    content,
+    /* @__PURE__ */ jsx5(ControlsLine, {})
+  ] });
+}
+
+// src/client/result-writer.ts
+import * as fsp3 from "fs/promises";
+async function writeShellResult(resultFile, result) {
+  const parsed = shellResultSchema.parse(result);
+  const line = `${JSON.stringify(parsed)}
+`;
+  let isFifo = false;
+  try {
+    const st = await fsp3.stat(resultFile);
+    isFifo = st.isFIFO();
+  } catch {
+  }
+  if (isFifo) {
+    await fsp3.writeFile(resultFile, line, { encoding: "utf-8" });
+  } else {
+    const tmpFile = `${resultFile}.tmp`;
+    await fsp3.writeFile(tmpFile, line, { encoding: "utf-8" });
+    await fsp3.rename(tmpFile, resultFile);
+  }
+}
+
+// src/client/run-foreground.ts
+function buildShellBuffers(command, explanation) {
+  const comment = `  # ${explanation}`;
+  const stripped = command.replace(/<([^>]+)>/g, "$1");
+  const firstAngle = command.indexOf("<");
+  if (firstAngle >= 0) {
+    return {
+      lbuffer: stripped.slice(0, firstAngle),
+      rbuffer: stripped.slice(firstAngle) + comment
+    };
+  }
+  return { lbuffer: command, rbuffer: comment };
+}
+async function runForegroundClient(args) {
+  const { requestFile, resultFile, resultMode } = args;
+  const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+  const socketPath2 = socketPathForUid(uid);
+  const inZellij = process.env.ZELLIJ !== void 0;
+  void appendDebugLog("client", "foreground start", {
+    requestFile,
+    resultFile,
+    resultMode,
+    socketPath: socketPath2,
+    inZellij
+  });
+  const ttyHandle = await fsp4.open("/dev/tty", "r+").catch(() => null);
+  try {
+    const raw = await fsp4.readFile(requestFile, "utf-8");
+    const request = shellRequestSchema.parse(JSON.parse(raw.trim()));
+    void appendDebugLog("client", "request parsed", request);
+    const detectedProvider = await detectProvider();
+    void appendDebugLog("client", "provider detected", { kind: detectedProvider.kind });
+    await ensureDaemon(socketPath2);
+    void appendDebugLog("client", "daemon ensured", { socketPath: socketPath2 });
+    if (resultMode === "replace-buffer-fixture") {
+      const fixtureLbuffer = request.lbuffer || "echo hello";
+      await writeShellResult(resultFile, {
+        kind: "replace-buffer",
+        lbuffer: fixtureLbuffer,
+        rbuffer: request.rbuffer
+      });
+      void appendDebugLog("client", "wrote replace-buffer result", {
+        resultFile,
+        lbuffer: fixtureLbuffer,
+        rbuffer: request.rbuffer
+      });
+    } else if (resultMode === "llm") {
+      try {
+        const decision = classifyIntent({ ...request, intent: "unknown", confidence: 0 });
+        void appendDebugLog("client", "intent classified", {
+          intent: decision.intent,
+          signals: decision.signals
+        });
+        const normalized = {
+          ...request,
+          intent: decision.intent,
+          confidence: decision.confidence
+        };
+        const envelope = await gatherContext(normalized);
+        void appendDebugLog("client", "context gathered", {
+          extraCount: envelope.extras.length
+        });
+        let ttyReadStream;
+        let ttyWriteStream;
+        if (ttyHandle) {
+          try {
+            ttyReadStream = new tty.ReadStream(ttyHandle.fd);
+            ttyWriteStream = new tty.WriteStream(ttyHandle.fd);
+          } catch {
+          }
+        }
+        const MODAL_VIEWPORT_LINES = 16;
+        if (ttyWriteStream && !inZellij) {
+          ttyWriteStream.write("\n".repeat(MODAL_VIEWPORT_LINES));
+          ttyWriteStream.write(`\x1B[${MODAL_VIEWPORT_LINES}A`);
+          ttyWriteStream.write("\x1B7");
+        }
+        await new Promise((resolve2) => {
+          let unmount;
+          let resolved = false;
+          const buildCandidateElement = (candidates, errorState) => React.createElement(CandidateSelect, {
+            candidates,
+            initialQuery: request.lbuffer,
+            error: errorState,
+            onSelect: async (command, explanation) => {
+              if (resolved) return;
+              resolved = true;
+              const { lbuffer, rbuffer } = buildShellBuffers(command, explanation);
+              await writeShellResult(resultFile, {
+                kind: "replace-buffer",
+                lbuffer,
+                rbuffer,
+                query: request.lbuffer
+              });
+              unmount?.();
+            },
+            onCancel: async () => {
+              if (resolved) return;
+              resolved = true;
+              await writeShellResult(resultFile, { kind: "cancel" });
+              unmount?.();
+            }
+          });
+          const renderOptions = ttyReadStream && ttyWriteStream ? { stdin: ttyReadStream, stdout: ttyWriteStream, interactive: true } : { interactive: true };
+          const app = render(buildCandidateElement(null), renderOptions);
+          const clearScrollReserve = () => {
+            if (ttyWriteStream && !inZellij) {
+              try {
+                ttyWriteStream.write("\x1B8\x1B[J");
+              } catch {
+              }
+            }
+          };
+          const cleanupOnSignal = () => {
+            app.unmount();
+            clearScrollReserve();
+            process.exit(0);
+          };
+          process.once("SIGHUP", cleanupOnSignal);
+          process.once("SIGTERM", cleanupOnSignal);
+          unmount = () => {
+            process.off("SIGHUP", cleanupOnSignal);
+            process.off("SIGTERM", cleanupOnSignal);
+            app.unmount();
+            clearScrollReserve();
+            resolve2();
+          };
+          fetchCandidates(envelope, request.rbuffer).then((candidates) => {
+            void appendDebugLog("client", "candidates received", { count: candidates.length });
+            app.rerender(buildCandidateElement(candidates));
+          }).catch(async (err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            void appendDebugLog("client", "llm request failed", { message });
+            if (resolved) return;
+            resolved = true;
+            try {
+              await writeShellResult(resultFile, {
+                kind: "error",
+                message: `QueQue: ${message} \u2014 press any key`
+              });
+            } finally {
+              unmount?.();
+            }
+          });
+        });
+        void appendDebugLog("client", "wrote llm result", { resultFile });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        void appendDebugLog("client", "llm request failed", {
+          message
+        });
+        await writeShellResult(resultFile, {
+          kind: "error",
+          message: `QueQue: ${message} \u2014 press any key`
+        });
+      }
+    } else {
+      await writeShellResult(resultFile, { kind: "cancel" });
+      void appendDebugLog("client", "wrote cancel result", { resultFile });
+    }
+  } finally {
+    await ttyHandle?.close();
+  }
+}
+
+// src/cli/commands/client.ts
+function parseResultMode(mode) {
+  if (mode === void 0 || mode === "llm") return "llm";
+  if (mode === "cancel") return "cancel";
+  if (mode === "replace-buffer-fixture") return "replace-buffer-fixture";
+  void appendDebugLog("client", `unknown --result-mode "${mode}", defaulting to cancel`);
+  return "cancel";
+}
+async function clientCommand(options) {
+  const resultMode = parseResultMode(options.resultMode);
+  void appendDebugLog("client", "command start", {
+    requestFile: options.requestFile,
+    resultFile: options.resultFile,
+    resultMode
+  });
+  await runForegroundClient({
+    requestFile: options.requestFile,
+    resultFile: options.resultFile,
+    resultMode
+  });
+}
+
+// src/daemon/server.ts
+import * as net2 from "net";
+
+// src/contracts/ipc.ts
+import { z as z4 } from "zod";
+var ipcRequestSchema = z4.discriminatedUnion("kind", [
+  z4.object({
+    kind: z4.literal("ping")
+  }),
+  z4.object({
+    kind: z4.literal("ensure-session"),
+    shellPid: z4.number().int().positive(),
+    ttyPath: z4.string()
+  }),
+  z4.object({
+    kind: z4.literal("run-query"),
+    request: shellRequestSchema
+  })
+]);
+var ipcResponseSchema = z4.discriminatedUnion("kind", [
+  z4.object({
+    kind: z4.literal("pong")
+  }),
+  z4.object({
+    kind: z4.literal("session-ready"),
+    socketPath: z4.string()
+  }),
+  z4.object({
+    kind: z4.literal("query-accepted"),
+    requestId: z4.string()
+  })
+]);
+
+// src/daemon/server.ts
+function startDaemonServer(socketPath2) {
+  return new Promise((resolve2, reject) => {
+    const MAX_BUF_BYTES = 64 * 1024;
+    const server = net2.createServer((socket) => {
+      let buf = "";
+      void appendDebugLog("daemon", "socket connected", { socketPath: socketPath2 });
+      socket.on("data", (chunk) => {
+        if (buf.length + chunk.length > MAX_BUF_BYTES) {
+          socket.destroy(new Error("IPC message too large"));
+          return;
+        }
+        buf += chunk.toString();
+        let nl = buf.indexOf("\n");
+        while (nl !== -1) {
+          const line = buf.slice(0, nl).trim();
+          buf = buf.slice(nl + 1);
+          nl = buf.indexOf("\n");
+          if (!line) continue;
+          let parsed;
+          try {
+            parsed = JSON.parse(line);
+          } catch {
+            continue;
+          }
+          const result = ipcRequestSchema.safeParse(parsed);
+          if (!result.success) {
+            void appendDebugLog("daemon", "ignored unknown request", { line });
+            continue;
+          }
+          const req = result.data;
+          void appendDebugLog("daemon", "request received", req);
+          switch (req.kind) {
+            case "ping": {
+              socket.write(`${JSON.stringify({ kind: "pong" })}
+`);
+              void appendDebugLog("daemon", "replied pong");
+              break;
+            }
+            case "ensure-session": {
+              socket.write(`${JSON.stringify({ kind: "session-ready", socketPath: socketPath2 })}
+`);
+              void appendDebugLog("daemon", "replied session-ready", { socketPath: socketPath2 });
+              break;
+            }
+            case "run-query": {
+              const requestId = Math.random().toString(36).slice(2);
+              socket.write(`${JSON.stringify({ kind: "query-accepted", requestId })}
+`);
+              void appendDebugLog("daemon", "replied query-accepted", { requestId });
+              break;
+            }
+          }
+        }
+      });
+      socket.on("error", () => {
+      });
+    });
+    server.on("error", reject);
+    server.listen(socketPath2, () => {
+      void appendDebugLog("daemon", "listening", { socketPath: socketPath2 });
+      resolve2(server);
+    });
+  });
+}
+
+// src/cli/commands/daemon.ts
+async function daemonCommand(options) {
+  const sock = options.socket ?? socketPath();
+  void appendDebugLog("daemon", "command start", { socket: sock, ensure: options.ensure });
+  if (options.ensure) {
+    await ensureDaemon(sock);
+    void appendDebugLog("daemon", "ensure command complete", { socket: sock });
+    return;
+  }
+  const server = await startDaemonServer(sock);
+  void appendDebugLog("daemon", "server started", { socket: sock });
+  const shutdown = () => {
+    void appendDebugLog("daemon", "shutdown", { socket: sock });
+    server.close(() => {
+      process.exit(0);
+    });
+  };
+  process.once("SIGTERM", shutdown);
+  process.once("SIGINT", shutdown);
+  await new Promise(() => {
+  });
+}
+
+// src/cli/main.ts
+function requiredOption(name, value) {
+  if (!value) {
+    throw new Error(`Missing required option: ${name}`);
+  }
+  return value;
+}
+var QQ_RESULT_FILE_PATTERN = /^\/tmp\/qq-sess\.[A-Za-z0-9]+\//;
+process.on("uncaughtException", (err) => {
+  console.error("QueQue: uncaught exception:", err.message);
+  const resultFile = process.env.QQ_RESULT_FILE;
+  if (resultFile && QQ_RESULT_FILE_PATTERN.test(resultFile)) {
+    try {
+      fs2.writeFileSync(resultFile, '{"kind":"cancel"}\n');
+    } catch {
+    }
+  }
+  process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+  const message = reason instanceof Error ? reason.message : String(reason);
+  console.error("QueQue: unhandled rejection:", message);
+  const resultFile = process.env.QQ_RESULT_FILE;
+  if (resultFile && QQ_RESULT_FILE_PATTERN.test(resultFile)) {
+    try {
+      fs2.writeFileSync(resultFile, '{"kind":"cancel"}\n');
+    } catch {
+    }
+  }
+  process.exit(1);
+});
+async function main(argv = process.argv.slice(2)) {
+  bootstrapBuiltins();
+  const cli = cac("qq");
+  cli.command("client").option("--request-file <path>", "Path to the serialized shell request").option("--result-file <path>", "Path to write the serialized shell result").option("--result-mode <mode>", "Result mode: llm | cancel | replace-buffer-fixture").action(async (options) => {
+    const requestFile = requiredOption("--request-file", options.requestFile);
+    const resultFile = requiredOption("--result-file", options.resultFile);
+    await clientCommand({ requestFile, resultFile, resultMode: options.resultMode });
+  });
+  cli.command("daemon").option("--socket <path>", "Unix socket path for the daemon").option("--ensure", "Ensure the daemon is running before returning").action(async (options) => {
+    await daemonCommand(options);
+  });
+  cli.help();
+  cli.parse(["node", "qq", ...argv], { run: false });
+  await cli.runMatchedCommand();
+}
+var isDirectRun = process.argv[1] ? import.meta.url === new URL(`file://${process.argv[1]}`).href : false;
+if (isDirectRun) {
+  void main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exitCode = 1;
+  });
+}
+export {
+  main
+};
+//# sourceMappingURL=main.js.map