rudel 0.1.1 → 0.1.2

package/dist/cli.js

@@ -1,5 +1,22 @@
 #!/usr/bin/env bun
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = import.meta.require;
 
 // ../../node_modules/.bun/@stricli+core@1.2.5/node_modules/@stricli/core/dist/index.js
 function checkEnvironmentVariable(process2, varName) {
@@ -1802,242 +1819,150 @@ async function run(app, inputs, context) {
   context.process.exitCode = exitCode;
 }
 
-// src/commands/login.ts
-import { randomBytes } from "crypto";
+// src/lib/claude-settings.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+var HOOK_COMMAND = "rudel hooks claude session-end";
+function getClaudeSettingsPath() {
+  return join(process.env.HOME ?? "~", ".claude", "settings.json");
+}
+function readClaudeSettings() {
+  const path = getClaudeSettingsPath();
+  if (!existsSync(path))
+    return {};
+  const content = readFileSync(path, "utf-8");
+  return JSON.parse(content);
+}
+function writeClaudeSettings(settings) {
+  const path = getClaudeSettingsPath();
+  writeFileSync(path, `${JSON.stringify(settings, null, 2)}
+`);
+}
+function isHookEnabled() {
+  const settings = readClaudeSettings();
+  const entries = settings.hooks?.SessionEnd;
+  if (!Array.isArray(entries))
+    return false;
+  return entries.some((entry) => entry.hooks?.some((h) => h.command === HOOK_COMMAND));
+}
+function addHook() {
+  const settings = readClaudeSettings();
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  if (!Array.isArray(settings.hooks.SessionEnd)) {
+    settings.hooks.SessionEnd = [];
+  }
+  const alreadyExists = settings.hooks.SessionEnd.some((entry) => entry.hooks?.some((h) => h.command === HOOK_COMMAND));
+  if (alreadyExists)
+    return;
+  settings.hooks.SessionEnd.push({
+    matcher: "",
+    hooks: [{ type: "command", command: HOOK_COMMAND, async: true }]
+  });
+  writeClaudeSettings(settings);
+}
+function removeHook() {
+  const settings = readClaudeSettings();
+  const hooks = settings.hooks;
+  const entries = hooks?.SessionEnd;
+  if (!hooks || !Array.isArray(entries))
+    return;
+  hooks.SessionEnd = entries.filter((entry) => !entry.hooks?.some((h) => h.command === HOOK_COMMAND));
+  if (hooks.SessionEnd.length === 0) {
+    delete hooks.SessionEnd;
+  }
+  if (Object.keys(hooks).length === 0) {
+    delete settings.hooks;
+  }
+  writeClaudeSettings(settings);
+}
+
+// src/commands/disable.ts
+async function runDisable() {
+  const write = (msg) => process.stdout.write(`${msg}
+`);
+  if (!isHookEnabled()) {
+    write("Auto-upload hook is not enabled.");
+    return;
+  }
+  removeHook();
+  write(`Auto-upload hook removed from ${getClaudeSettingsPath()}`);
+}
+var disableCommand = buildCommand({
+  loader: async () => ({ default: runDisable }),
+  parameters: {},
+  docs: {
+    brief: "Disable automatic session upload"
+  }
+});
 
 // src/lib/credentials.ts
 import {
-  existsSync,
+  existsSync as existsSync2,
   mkdirSync,
-  readFileSync,
+  readFileSync as readFileSync2,
   rmSync,
-  writeFileSync
+  writeFileSync as writeFileSync2
 } from "fs";
-import { join } from "path";
+import { join as join2 } from "path";
 function getConfigDir() {
-  return process.env.RUDEL_CONFIG_DIR ?? join(process.env.HOME ?? "~", ".rudel");
+  return process.env.RUDEL_CONFIG_DIR ?? join2(process.env.HOME ?? "~", ".rudel");
 }
 function getCredentialsPath() {
-  return join(getConfigDir(), "credentials.json");
+  return join2(getConfigDir(), "credentials.json");
 }
 function saveCredentials(token, apiBaseUrl) {
   const dir = getConfigDir();
-  if (!existsSync(dir)) {
+  if (!existsSync2(dir)) {
     mkdirSync(dir, { recursive: true, mode: 448 });
   }
   const data = { token, apiBaseUrl };
-  writeFileSync(getCredentialsPath(), JSON.stringify(data, null, 2), {
+  writeFileSync2(getCredentialsPath(), JSON.stringify(data, null, 2), {
     mode: 384
   });
 }
 function loadCredentials() {
   const path = getCredentialsPath();
-  if (!existsSync(path))
+  if (!existsSync2(path))
     return null;
-  const content = readFileSync(path, "utf-8");
+  const content = readFileSync2(path, "utf-8");
   return JSON.parse(content);
 }
 function clearCredentials() {
   const path = getCredentialsPath();
-  if (existsSync(path)) {
+  if (existsSync2(path)) {
     rmSync(path);
   }
 }
 
-// src/commands/login.ts
-var DEFAULT_API_BASE = "https://rudel.numia.workers.dev";
-var DEFAULT_WEB_URL = "https://rudel.numia.workers.dev";
-var CALLBACK_TIMEOUT_MS = 120000;
-async function runLogin(flags) {
+// src/commands/enable.ts
+async function runEnable() {
   const write = (msg) => process.stdout.write(`${msg}
 `);
   const writeError = (msg) => process.stderr.write(`${msg}
 `);
-  const existing = loadCredentials();
-  if (existing) {
-    write("Already logged in. Run `rudel logout` first to switch accounts.");
-    return;
-  }
-  const state = randomBytes(16).toString("hex");
-  let resolveCallback;
-  let rejectCallback;
-  const tokenPromise = new Promise((resolve, reject) => {
-    resolveCallback = resolve;
-    rejectCallback = reject;
-  });
-  const server = Bun.serve({
-    port: 0,
-    hostname: "127.0.0.1",
-    fetch(request) {
-      const url = new URL(request.url);
-      if (url.pathname !== "/callback") {
-        return new Response("Not found", { status: 404 });
-      }
-      const receivedToken = url.searchParams.get("token");
-      const receivedState = url.searchParams.get("state");
-      if (receivedState !== state) {
-        rejectCallback(new Error("State mismatch \u2014 possible CSRF attack"));
-        return new Response("<html><body><h1>Login failed</h1><p>State mismatch. Please try again.</p></body></html>", { headers: { "Content-Type": "text/html" } });
-      }
-      if (!receivedToken) {
-        rejectCallback(new Error("No token received"));
-        return new Response("<html><body><h1>Login failed</h1><p>No token received.</p></body></html>", { headers: { "Content-Type": "text/html" } });
-      }
-      resolveCallback(receivedToken);
-      return new Response("<html><body><h1>Login successful!</h1><p>You can close this tab and return to the terminal.</p></body></html>", { headers: { "Content-Type": "text/html" } });
-    }
-  });
-  const callbackUrl = `http://127.0.0.1:${server.port}/callback`;
-  const loginUrl = `${flags.webUrl}?cli_callback=${encodeURIComponent(callbackUrl)}&state=${state}`;
-  write("Opening browser for authentication...");
-  write(`If the browser doesn't open, visit: ${loginUrl}`);
-  const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-  Bun.spawn([opener, loginUrl], { stdout: "ignore", stderr: "ignore" });
-  const timeout = setTimeout(() => {
-    rejectCallback(new Error("Login timed out after 120 seconds"));
-  }, CALLBACK_TIMEOUT_MS);
-  let token;
-  try {
-    token = await tokenPromise;
-  } catch (error) {
-    clearTimeout(timeout);
-    server.stop();
-    writeError(`Login failed: ${error instanceof Error ? error.message : String(error)}`);
-    process.exitCode = 1;
-    return;
-  }
-  clearTimeout(timeout);
-  server.stop();
-  write("Validating token...");
-  const meResponse = await fetch(`${flags.apiBase}/rpc/me`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify({})
-  });
-  if (!meResponse.ok) {
-    writeError("Login failed: token validation failed");
+  const credentials = loadCredentials();
+  if (!credentials) {
+    writeError("Error: Not authenticated. Run `rudel login` first.");
     process.exitCode = 1;
     return;
   }
-  const body = await meResponse.json();
-  saveCredentials(token, flags.apiBase);
-  write(`Logged in as ${body.json.name} (${body.json.email})`);
-}
-var loginCommand = buildCommand({
-  loader: async () => ({ default: runLogin }),
-  parameters: {
-    flags: {
-      apiBase: {
-        kind: "parsed",
-        parse: String,
-        brief: "API server base URL",
-        default: DEFAULT_API_BASE
-      },
-      webUrl: {
-        kind: "parsed",
-        parse: String,
-        brief: "Web app URL for authentication",
-        default: DEFAULT_WEB_URL
-      }
-    }
-  },
-  docs: {
-    brief: "Authenticate with the Rudel API via browser login"
-  }
-});
-
-// src/commands/logout.ts
-async function runLogout() {
-  const write = (msg) => process.stdout.write(`${msg}
-`);
-  const credentials = loadCredentials();
-  if (!credentials) {
-    write("Not logged in.");
+  if (isHookEnabled()) {
+    write("Auto-upload hook is already enabled.");
     return;
   }
-  clearCredentials();
-  write("Logged out successfully.");
+  addHook();
+  write(`Auto-upload hook enabled in ${getClaudeSettingsPath()}`);
 }
-var logoutCommand = buildCommand({
-  loader: async () => ({ default: runLogout }),
+var enableCommand = buildCommand({
+  loader: async () => ({ default: runEnable }),
   parameters: {},
   docs: {
-    brief: "Log out and remove stored credentials"
+    brief: "Enable automatic session upload via Claude Code hook"
   }
 });
 
-// src/lib/classifier.ts
-import { mkdir, unlink } from "fs/promises";
-import { homedir } from "os";
-import { join as join2 } from "path";
-
-// src/lib/types.ts
-var SESSION_TAGS = [
-  "research",
-  "new_feature",
-  "bug_fix",
-  "refactoring",
-  "documentation",
-  "tests",
-  "other"
-];
-var DEFAULT_ENDPOINT = "https://rudel.numia.workers.dev/rpc";
-
-// src/lib/classifier.ts
-var SYSTEM_PROMPT = `You are a session classifier. Analyze the Claude Code session transcript and classify it into exactly ONE of these categories:
-
-- research: Exploring codebase, understanding code, answering questions about how things work
-- new_feature: Implementing new functionality or features
-- bug_fix: Fixing bugs, errors, or unexpected behavior
-- refactoring: Restructuring existing code without changing functionality
-- documentation: Writing or updating documentation, comments, READMEs
-- tests: Writing, updating, or fixing tests
-
-CRITICAL: Respond with ONLY the tag name. Nothing else. No explanation, no punctuation, no formatting. Just ONE of: research, new_feature, bug_fix, refactoring, documentation, tests`;
-async function classifySession(content) {
-  const truncatedContent = content.slice(0, 50000);
-  const tempDir = join2(homedir(), ".claude", "temp");
-  const tempFile = join2(tempDir, `classify-${Date.now()}.txt`);
-  try {
-    await mkdir(tempDir, { recursive: true });
-    await Bun.write(tempFile, `Classify this session transcript:
-
-${truncatedContent}`);
-    const prompt = `Read and classify the session transcript in this file: ${tempFile}`;
-    const escapedPrompt = prompt.replace(/'/g, "'\\''");
-    const escapedSystemPrompt = SYSTEM_PROMPT.replace(/'/g, "'\\''");
-    const proc = Bun.spawn([
-      "sh",
-      "-c",
-      `echo '${escapedPrompt}' | claude --output-format text --print --model haiku --no-session-persistence --dangerously-skip-permissions --system-prompt '${escapedSystemPrompt}'`
-    ], { stdout: "pipe", stderr: "pipe" });
-    const exitCode = await proc.exited;
-    const stdout = await new Response(proc.stdout).text();
-    if (exitCode !== 0) {
-      return "other";
-    }
-    const output = stdout.trim().toLowerCase();
-    if (SESSION_TAGS.includes(output)) {
-      return output;
-    }
-    for (const tag of SESSION_TAGS) {
-      if (new RegExp(`\\b${tag}\\b`).test(output)) {
-        return tag;
-      }
-    }
-    return "other";
-  } catch {
-    return;
-  } finally {
-    try {
-      await unlink(tempFile);
-    } catch {}
-  }
-}
-
 // src/lib/git-info.ts
 import { join as join3 } from "path";
 var {$ } = globalThis.Bun;
@@ -2102,118 +2027,27 @@ async function getGitSha(cwd) {
   }
 }
 
-// src/lib/session-resolver.ts
-import { readdir, stat } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { basename, dirname, join as join4 } from "path";
-var SESSIONS_BASE_DIR = join4(homedir2(), ".claude", "projects");
-async function resolveSession(input) {
-  const isPath = input.includes("/") || input.endsWith(".jsonl");
-  if (isPath) {
-    return resolveFromPath(input);
-  }
-  return resolveFromId(input);
-}
-async function resolveFromPath(filePath) {
-  const filename = basename(filePath);
-  validateNotSubagent(filename);
-  const file = Bun.file(filePath);
-  if (!await file.exists()) {
-    throw new Error(`Session file not found: ${filePath}`);
+// src/lib/subagent-reader.ts
+import { join as join4 } from "path";
+async function readSubagentFiles(sessionDir, agentIds, sessionId) {
+  const subagents = [];
+  for (const agentId of agentIds) {
+    const possiblePaths = [
+      join4(sessionDir, `agent-${agentId}.jsonl`),
+      ...sessionId ? [join4(sessionDir, sessionId, "subagents", `agent-${agentId}.jsonl`)] : []
+    ];
+    for (const agentPath of possiblePaths) {
+      try {
+        const file = Bun.file(agentPath);
+        if (await file.exists()) {
+          const content = await file.text();
+          subagents.push({ agentId, content });
+          break;
+        }
+      } catch {}
+    }
   }
-  const sessionId = filename.replace(/\.jsonl$/, "");
-  const sessionDir = dirname(filePath);
-  const parentDir = basename(sessionDir);
-  const projectPath = await decodeProjectPath(parentDir);
-  return { transcriptPath: filePath, projectPath, sessionDir, sessionId };
-}
-async function resolveFromId(sessionId) {
-  validateNotSubagent(`${sessionId}.jsonl`);
-  const sessionFileName = `${sessionId}.jsonl`;
-  let projectDirs;
-  try {
-    projectDirs = await readdir(SESSIONS_BASE_DIR);
-  } catch {
-    throw new Error(`Session not found: ${sessionId}`);
-  }
-  for (const projectDir of projectDirs) {
-    const sessionDir = join4(SESSIONS_BASE_DIR, projectDir);
-    try {
-      const files = await readdir(sessionDir);
-      if (files.includes(sessionFileName)) {
-        const transcriptPath = join4(sessionDir, sessionFileName);
-        const projectPath = await decodeProjectPath(projectDir);
-        return {
-          transcriptPath,
-          projectPath,
-          sessionDir,
-          sessionId
-        };
-      }
-    } catch {}
-  }
-  throw new Error(`Session not found: ${sessionId}`);
-}
-function validateNotSubagent(filename) {
-  if (filename.startsWith("agent-") && filename.endsWith(".jsonl")) {
-    throw new Error("This is a subagent file, not a main session. Please provide the main session ID or path.");
-  }
-}
-async function decodeProjectPath(encodedDir) {
-  const parts = encodedDir.replace(/^-/, "").split("-");
-  async function findPath(partIndex, currentPath) {
-    if (partIndex >= parts.length) {
-      try {
-        await stat(currentPath);
-        return currentPath;
-      } catch {
-        return null;
-      }
-    }
-    for (let endIndex = parts.length;endIndex > partIndex; endIndex--) {
-      const segment = parts.slice(partIndex, endIndex).join("-");
-      const testPath = currentPath ? `${currentPath}/${segment}` : `/${segment}`;
-      try {
-        await stat(testPath);
-        if (endIndex === parts.length) {
-          return testPath;
-        }
-        const result2 = await findPath(endIndex, testPath);
-        if (result2) {
-          return result2;
-        }
-      } catch {}
-    }
-    return null;
-  }
-  const result = await findPath(0, "");
-  if (result) {
-    return result;
-  }
-  return `/${parts.join("/")}`;
-}
-
-// src/lib/subagent-reader.ts
-import { join as join5 } from "path";
-async function readSubagentFiles(sessionDir, agentIds, sessionId) {
-  const subagents = [];
-  for (const agentId of agentIds) {
-    const possiblePaths = [
-      join5(sessionDir, `agent-${agentId}.jsonl`),
-      ...sessionId ? [join5(sessionDir, sessionId, "subagents", `agent-${agentId}.jsonl`)] : []
-    ];
-    for (const agentPath of possiblePaths) {
-      try {
-        const file = Bun.file(agentPath);
-        if (await file.exists()) {
-          const content = await file.text();
-          subagents.push({ agentId, content });
-          break;
-        }
-      } catch {}
-    }
-  }
-  return subagents;
+  return subagents;
 }
 
 // src/lib/transcript-reader.ts
@@ -3734,6 +3568,358 @@ async function uploadSession(request, config) {
   }
 }
 
+// src/commands/hooks/claude/session-end.ts
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === "string" ? chunk : chunk.toString());
+  }
+  return chunks.join("");
+}
+async function runSessionEnd() {
+  try {
+    const raw = await readStdin();
+    if (!raw.trim())
+      return;
+    const input = JSON.parse(raw);
+    if (!input.session_id || !input.transcript_path)
+      return;
+    const credentials = loadCredentials();
+    if (!credentials)
+      return;
+    const content = await readTranscript(input.transcript_path);
+    const agentIds = extractAgentIds(content);
+    const { dirname } = await import("path");
+    const sessionDir = dirname(input.transcript_path);
+    const subagents = agentIds.length > 0 ? await readSubagentFiles(sessionDir, agentIds, input.session_id) : [];
+    const gitInfo = await getGitInfo(input.cwd);
+    const request = {
+      sessionId: input.session_id,
+      projectPath: input.cwd,
+      repository: gitInfo.repository,
+      gitBranch: gitInfo.branch,
+      gitSha: gitInfo.sha,
+      content,
+      subagents: subagents.length > 0 ? subagents : undefined
+    };
+    const endpoint = `${credentials.apiBaseUrl}/rpc`;
+    await uploadSession(request, { endpoint, token: credentials.token });
+  } catch {}
+}
+var sessionEndCommand = buildCommand({
+  loader: async () => ({ default: runSessionEnd }),
+  parameters: {},
+  docs: {
+    brief: "Handle Claude Code SessionEnd hook"
+  }
+});
+
+// src/commands/hooks/claude/index.ts
+var claudeRouteMap = buildRouteMap({
+  routes: {
+    "session-end": sessionEndCommand
+  },
+  docs: {
+    brief: "Claude Code hook handlers"
+  }
+});
+
+// src/commands/hooks/index.ts
+var hooksRouteMap = buildRouteMap({
+  routes: {
+    claude: claudeRouteMap
+  },
+  docs: {
+    brief: "Hook handlers"
+  }
+});
+
+// src/commands/login.ts
+import { randomBytes } from "crypto";
+var DEFAULT_API_BASE = "https://app.rudel.ai";
+var DEFAULT_WEB_URL = "https://app.rudel.ai";
+var CALLBACK_TIMEOUT_MS = 120000;
+async function runLogin(flags) {
+  const write = (msg) => process.stdout.write(`${msg}
+`);
+  const writeError = (msg) => process.stderr.write(`${msg}
+`);
+  const existing = loadCredentials();
+  if (existing) {
+    write("Already logged in. Run `rudel logout` first to switch accounts.");
+    return;
+  }
+  const state = randomBytes(16).toString("hex");
+  let resolveCallback;
+  let rejectCallback;
+  const tokenPromise = new Promise((resolve, reject) => {
+    resolveCallback = resolve;
+    rejectCallback = reject;
+  });
+  const server = Bun.serve({
+    port: 0,
+    hostname: "127.0.0.1",
+    fetch(request) {
+      const url = new URL(request.url);
+      if (url.pathname !== "/callback") {
+        return new Response("Not found", { status: 404 });
+      }
+      const receivedToken = url.searchParams.get("token");
+      const receivedState = url.searchParams.get("state");
+      if (receivedState !== state) {
+        rejectCallback(new Error("State mismatch \u2014 possible CSRF attack"));
+        return new Response("<html><body><h1>Login failed</h1><p>State mismatch. Please try again.</p></body></html>", { headers: { "Content-Type": "text/html" } });
+      }
+      if (!receivedToken) {
+        rejectCallback(new Error("No token received"));
+        return new Response("<html><body><h1>Login failed</h1><p>No token received.</p></body></html>", { headers: { "Content-Type": "text/html" } });
+      }
+      resolveCallback(receivedToken);
+      return new Response("<html><body><h1>Login successful!</h1><p>You can close this tab and return to the terminal.</p></body></html>", { headers: { "Content-Type": "text/html" } });
+    }
+  });
+  const callbackUrl = `http://127.0.0.1:${server.port}/callback`;
+  const loginUrl = `${flags.webUrl}?cli_callback=${encodeURIComponent(callbackUrl)}&state=${state}`;
+  write("Opening browser for authentication...");
+  write(`If the browser doesn't open, visit: ${loginUrl}`);
+  const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  Bun.spawn([opener, loginUrl], { stdout: "ignore", stderr: "ignore" });
+  const timeout = setTimeout(() => {
+    rejectCallback(new Error("Login timed out after 120 seconds"));
+  }, CALLBACK_TIMEOUT_MS);
+  let token;
+  try {
+    token = await tokenPromise;
+  } catch (error) {
+    clearTimeout(timeout);
+    server.stop();
+    writeError(`Login failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+    return;
+  }
+  clearTimeout(timeout);
+  server.stop();
+  write("Validating token...");
+  const meResponse = await fetch(`${flags.apiBase}/rpc/me`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({})
+  });
+  if (!meResponse.ok) {
+    writeError("Login failed: token validation failed");
+    process.exitCode = 1;
+    return;
+  }
+  const body = await meResponse.json();
+  saveCredentials(token, flags.apiBase);
+  write(`Logged in as ${body.json.name} (${body.json.email})`);
+}
+var loginCommand = buildCommand({
+  loader: async () => ({ default: runLogin }),
+  parameters: {
+    flags: {
+      apiBase: {
+        kind: "parsed",
+        parse: String,
+        brief: "API server base URL",
+        default: DEFAULT_API_BASE
+      },
+      webUrl: {
+        kind: "parsed",
+        parse: String,
+        brief: "Web app URL for authentication",
+        default: DEFAULT_WEB_URL
+      }
+    }
+  },
+  docs: {
+    brief: "Authenticate with the Rudel API via browser login"
+  }
+});
+
+// src/commands/logout.ts
+async function runLogout() {
+  const write = (msg) => process.stdout.write(`${msg}
+`);
+  const credentials = loadCredentials();
+  if (!credentials) {
+    write("Not logged in.");
+    return;
+  }
+  clearCredentials();
+  write("Logged out successfully.");
+}
+var logoutCommand = buildCommand({
+  loader: async () => ({ default: runLogout }),
+  parameters: {},
+  docs: {
+    brief: "Log out and remove stored credentials"
+  }
+});
+
+// src/lib/classifier.ts
+import { mkdir, unlink } from "fs/promises";
+import { homedir } from "os";
+import { join as join5 } from "path";
+
+// src/lib/types.ts
+var SESSION_TAGS = [
+  "research",
+  "new_feature",
+  "bug_fix",
+  "refactoring",
+  "documentation",
+  "tests",
+  "other"
+];
+var DEFAULT_ENDPOINT = "https://app.rudel.ai/rpc";
+
+// src/lib/classifier.ts
+var SYSTEM_PROMPT = `You are a session classifier. Analyze the Claude Code session transcript and classify it into exactly ONE of these categories:
+
+- research: Exploring codebase, understanding code, answering questions about how things work
+- new_feature: Implementing new functionality or features
+- bug_fix: Fixing bugs, errors, or unexpected behavior
+- refactoring: Restructuring existing code without changing functionality
+- documentation: Writing or updating documentation, comments, READMEs
+- tests: Writing, updating, or fixing tests
+
+CRITICAL: Respond with ONLY the tag name. Nothing else. No explanation, no punctuation, no formatting. Just ONE of: research, new_feature, bug_fix, refactoring, documentation, tests`;
+async function classifySession(content) {
+  const truncatedContent = content.slice(0, 50000);
+  const tempDir = join5(homedir(), ".claude", "temp");
+  const tempFile = join5(tempDir, `classify-${Date.now()}.txt`);
+  try {
+    await mkdir(tempDir, { recursive: true });
+    await Bun.write(tempFile, `Classify this session transcript:
+
+${truncatedContent}`);
+    const prompt = `Read and classify the session transcript in this file: ${tempFile}`;
+    const escapedPrompt = prompt.replace(/'/g, "'\\''");
+    const escapedSystemPrompt = SYSTEM_PROMPT.replace(/'/g, "'\\''");
+    const proc = Bun.spawn([
+      "sh",
+      "-c",
+      `echo '${escapedPrompt}' | claude --output-format text --print --model haiku --no-session-persistence --dangerously-skip-permissions --system-prompt '${escapedSystemPrompt}'`
+    ], { stdout: "pipe", stderr: "pipe" });
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    if (exitCode !== 0) {
+      return "other";
+    }
+    const output = stdout.trim().toLowerCase();
+    if (SESSION_TAGS.includes(output)) {
+      return output;
+    }
+    for (const tag of SESSION_TAGS) {
+      if (new RegExp(`\\b${tag}\\b`).test(output)) {
+        return tag;
+      }
+    }
+    return "other";
+  } catch {
+    return;
+  } finally {
+    try {
+      await unlink(tempFile);
+    } catch {}
+  }
+}
+
+// src/lib/session-resolver.ts
+import { readdir, stat } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { basename, dirname, join as join6 } from "path";
+var SESSIONS_BASE_DIR = join6(homedir2(), ".claude", "projects");
+async function resolveSession(input) {
+  const isPath = input.includes("/") || input.endsWith(".jsonl");
+  if (isPath) {
+    return resolveFromPath(input);
+  }
+  return resolveFromId(input);
+}
+async function resolveFromPath(filePath) {
+  const filename = basename(filePath);
+  validateNotSubagent(filename);
+  const file = Bun.file(filePath);
+  if (!await file.exists()) {
+    throw new Error(`Session file not found: ${filePath}`);
+  }
+  const sessionId = filename.replace(/\.jsonl$/, "");
+  const sessionDir = dirname(filePath);
+  const parentDir = basename(sessionDir);
+  const projectPath = await decodeProjectPath(parentDir);
+  return { transcriptPath: filePath, projectPath, sessionDir, sessionId };
+}
+async function resolveFromId(sessionId) {
+  validateNotSubagent(`${sessionId}.jsonl`);
+  const sessionFileName = `${sessionId}.jsonl`;
+  let projectDirs;
+  try {
+    projectDirs = await readdir(SESSIONS_BASE_DIR);
+  } catch {
+    throw new Error(`Session not found: ${sessionId}`);
+  }
+  for (const projectDir of projectDirs) {
+    const sessionDir = join6(SESSIONS_BASE_DIR, projectDir);
+    try {
+      const files = await readdir(sessionDir);
+      if (files.includes(sessionFileName)) {
+        const transcriptPath = join6(sessionDir, sessionFileName);
+        const projectPath = await decodeProjectPath(projectDir);
+        return {
+          transcriptPath,
+          projectPath,
+          sessionDir,
+          sessionId
+        };
+      }
+    } catch {}
+  }
+  throw new Error(`Session not found: ${sessionId}`);
+}
+function validateNotSubagent(filename) {
+  if (filename.startsWith("agent-") && filename.endsWith(".jsonl")) {
+    throw new Error("This is a subagent file, not a main session. Please provide the main session ID or path.");
+  }
+}
+async function decodeProjectPath(encodedDir) {
+  const parts = encodedDir.replace(/^-/, "").split("-");
+  async function findPath(partIndex, currentPath) {
+    if (partIndex >= parts.length) {
+      try {
+        await stat(currentPath);
+        return currentPath;
+      } catch {
+        return null;
+      }
+    }
+    for (let endIndex = parts.length;endIndex > partIndex; endIndex--) {
+      const segment = parts.slice(partIndex, endIndex).join("-");
+      const testPath = currentPath ? `${currentPath}/${segment}` : `/${segment}`;
+      try {
+        await stat(testPath);
+        if (endIndex === parts.length) {
+          return testPath;
+        }
+        const result2 = await findPath(endIndex, testPath);
+        if (result2) {
+          return result2;
+        }
+      } catch {}
+    }
+    return null;
+  }
+  const result = await findPath(0, "");
+  if (result) {
+    return result;
+  }
+  return `/${parts.join("/")}`;
+}
+
 // src/commands/upload.ts
 async function runUpload(flags, session) {
   const write = (msg) => {
@@ -3913,16 +4099,20 @@ var routes = buildRouteMap({
     login: loginCommand,
     logout: logoutCommand,
     whoami: whoamiCommand,
-    upload: uploadCommand
+    upload: uploadCommand,
+    enable: enableCommand,
+    disable: disableCommand,
+    hooks: hooksRouteMap
   },
   docs: {
-    brief: "CLI tools for managing Claude Code sessions"
+    brief: "CLI tools for managing Claude Code sessions",
+    hideRoute: { hooks: true }
   }
 });
 var app = buildApplication(routes, {
   name: "rudel",
   versionInfo: {
-    currentVersion: "0.1.1"
+    currentVersion: "0.1.2"
   },
   scanner: {
     caseStyle: "allow-kebab-for-camel"

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "rudel",
-	"version": "0.1.1",
+	"version": "0.1.2",
 	"type": "module",
 	"bin": {
 		"rudel": "./dist/cli.js"