pipit-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maximilian Maksutovic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,118 @@
+# pipit
+
+Pipe any context into Claude Code sessions.
+
+Screenshots, meeting notes, URLs, clipboard text -- capture it in one command, and Claude Code extracts tasks, plans implementation, and gets to work.
+
+```
+pipit go notes.md my-project
+```
+
+That's it. pipit opens a new terminal tab, feeds your context to Claude Code with a carefully crafted prompt, and Claude handles the rest -- extracting action items, planning, and implementing.
+
+## Install
+
+```bash
+npm install -g pipit-cli
+```
+
+Requires **Node.js 20+** and [Claude Code](https://claude.ai/code) installed.
+
+## Usage
+
+### `pipit go` -- send context to Claude Code
+
+```bash
+# File (text, markdown, transcript)
+pipit go meeting-notes.md my-project
+
+# Screenshot or image
+pipit go screenshot.png my-project
+
+# URL
+pipit go https://example.com/spec my-project
+
+# Stdin
+cat notes.txt | pipit go - my-project
+```
+
+pipit infers the input type automatically. Override with `--input-type` if needed.
+
+### Options
+
+```
+pipit go <input> <project-name> [options]
+
+Options:
+  -p, --project-dir <dir>     Project directory (repeatable)
+  --input-type <type>         Override input type: file, image, url, stdin
+  --control-level <level>     auto (default), plan_first, extract_only
+  --mode <mode>               fire_and_forget (default), interactive
+  --terminal <name>           ghostty, iterm2, warp, terminal
+  --context <text>            Additional instructions for Claude
+  --dry-run                   Print the prompt without launching
+  --json                      Machine-readable JSON output
+```
+
+### Control levels
+
+- **auto** -- Claude gets full autonomy (`--dangerously-skip-permissions`). Context goes in, code comes out.
+- **plan_first** -- Claude extracts and plans, then pauses for your approval before implementing.
+- **extract_only** -- Just show the extracted tasks. You decide what to do next.
+
+### Session modes
+
+- **fire_and_forget** -- Claude works autonomously. You watch and intervene if needed.
+- **interactive** -- Claude interviews you first, then plans and implements collaboratively.
+
+## How it works
+
+```
+Your context (file, image, URL, clipboard)
+    |
+    v
+pipit CLI (builds prompt, resolves input)
+    |
+    v
+Terminal tab (Ghostty, iTerm2, Warp, Terminal.app)
+    |
+    v
+Claude Code (extracts tasks, plans, implements, commits)
+    |
+    v
+Results (branches, commits, PRs)
+```
+
+pipit doesn't preprocess your input or run a separate extraction pipeline. It builds a prompt and hands everything to Claude Code in an interactive terminal session. Claude is smart enough to handle raw context directly.
+
+## Terminal support
+
+pipit opens Claude Code sessions in new terminal tabs via AppleScript:
+
+- **Ghostty** (default) -- native API
+- **iTerm2** -- AppleScript integration
+- **Warp** -- AppleScript integration
+- **Terminal.app** -- always available as fallback
+
+Set the default with `--terminal` or the `PIPIT_TERMINAL` environment variable.
+
+## Mac app
+
+pipit also has a native macOS menu bar app that provides:
+
+- Global hotkey to capture clipboard and launch a session
+- File watchers for screenshots and transcripts
+- Project management with multi-directory support
+- One-click CLI installation
+
+The Mac app calls the CLI under the hood -- all the logic lives here.
+
+## Requirements
+
+- **Node.js 20+**
+- **Claude Code** CLI installed and authenticated
+- **macOS** (terminal automation uses AppleScript)
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,729 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command, Option } from "commander";
+import { access as access2 } from "fs/promises";
+import { resolve as resolve3 } from "path";
+
+// src/extractor/extractor.ts
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+import { execa } from "execa";
+
+// src/extractor/types.ts
+import { z } from "zod";
+var ActionItemSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string(),
+  priority: z.enum(["high", "medium", "low"]),
+  estimated_complexity: z.enum(["trivial", "small", "medium", "large"]),
+  relevant_files: z.array(z.string()),
+  transcript_context: z.string()
+});
+var ExtractionResultSchema = z.object({
+  meeting_summary: z.string(),
+  action_items: z.array(ActionItemSchema),
+  decisions: z.array(z.string()),
+  questions_to_clarify: z.array(z.string()),
+  claude_md_updates: z.array(z.string())
+});
+function getExtractionJsonSchema() {
+  return JSON.stringify({
+    type: "object",
+    properties: {
+      meeting_summary: { type: "string" },
+      action_items: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            title: { type: "string" },
+            description: { type: "string" },
+            priority: { type: "string", enum: ["high", "medium", "low"] },
+            estimated_complexity: { type: "string", enum: ["trivial", "small", "medium", "large"] },
+            relevant_files: { type: "array", items: { type: "string" } },
+            transcript_context: { type: "string" }
+          },
+          required: ["id", "title", "description", "priority", "estimated_complexity", "relevant_files", "transcript_context"]
+        }
+      },
+      decisions: { type: "array", items: { type: "string" } },
+      questions_to_clarify: { type: "array", items: { type: "string" } },
+      claude_md_updates: { type: "array", items: { type: "string" } }
+    },
+    required: ["meeting_summary", "action_items", "decisions", "questions_to_clarify", "claude_md_updates"]
+  });
+}
+
+// src/extractor/extractor.ts
+var EXTRACTION_SYSTEM_PROMPT = `You are analyzing a meeting transcript to extract actionable development tasks.
+
+For each task you identify:
+- Give it a unique id (use kebab-case, e.g. "add-user-auth", "fix-api-timeout")
+- Write a clear title and detailed description of what needs to be implemented
+- Assess priority (high/medium/low) based on urgency signals in the conversation
+- Estimate complexity (trivial/small/medium/large) based on scope
+- List any files mentioned or implied as relevant
+- Include the relevant transcript excerpt that prompted this task
+
+Also extract:
+- A brief meeting summary
+- Key decisions made during the meeting
+- Questions that need clarification before implementation
+- Any updates that should be made to the project's CLAUDE.md`;
+async function extractTasks(transcriptPath, projectDir) {
+  const absolutePath = resolve(transcriptPath);
+  const transcript = await readFile(absolutePath, "utf-8");
+  const jsonSchema = getExtractionJsonSchema();
+  const { stdout } = await execa("claude", [
+    "-p",
+    EXTRACTION_SYSTEM_PROMPT,
+    "--allowedTools",
+    "Read,Glob,Grep",
+    "--output-format",
+    "json",
+    "--json-schema",
+    jsonSchema
+  ], {
+    input: transcript,
+    cwd: resolve(projectDir),
+    timeout: 3e5
+  });
+  const envelope = JSON.parse(stdout);
+  if (envelope.is_error) {
+    throw new Error(`claude -p failed: ${envelope.result || "unknown error"}`);
+  }
+  const data = envelope.structured_output ?? envelope.result;
+  if (!data) {
+    throw new Error("claude -p returned no structured output");
+  }
+  const parsed = typeof data === "string" ? JSON.parse(data) : data;
+  const result = ExtractionResultSchema.parse(parsed);
+  return result;
+}
+
+// src/executor/worker.ts
+import { execa as execa2 } from "execa";
+import path from "path";
+function generateSlug(title) {
+  return title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/[\s-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50).replace(/-+$/, "");
+}
+async function createWorktree(projectDir, slug) {
+  const worktreePath = path.join(projectDir, ".worktrees", `pipit-${slug}`);
+  const branchName = `pipit/${slug}`;
+  await execa2("git", ["worktree", "add", worktreePath, "-b", branchName], {
+    cwd: projectDir
+  });
+  return worktreePath;
+}
+async function cleanupWorktree(projectDir, worktreePath) {
+  try {
+    await execa2("git", ["worktree", "remove", worktreePath, "--force"], {
+      cwd: projectDir
+    });
+  } catch {
+  }
+}
+function escapeAppleScript(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function buildAppleScript(terminal, worktreePath, claudeCommand) {
+  switch (terminal) {
+    case "ghostty": {
+      const escapedPath = escapeAppleScript(worktreePath);
+      const escapedCmd = escapeAppleScript(claudeCommand);
+      return `
+tell application "Ghostty"
+  activate
+  set cfg to new surface configuration
+  set initial working directory of cfg to "${escapedPath}"
+  set initial input of cfg to "${escapedCmd}\\n"
+  new tab in front window with configuration cfg
+end tell
+`;
+    }
+    case "iterm2": {
+      const escapedCmd = escapeAppleScript(`cd '${worktreePath}' && ${claudeCommand}`);
+      return `
+tell application "iTerm2"
+  tell current window
+    create tab with default profile
+    tell current session of current tab
+      write text "${escapedCmd}"
+    end tell
+  end tell
+end tell
+`;
+    }
+    case "warp":
+    case "apple-terminal":
+    default: {
+      const escapedCmd = escapeAppleScript(`cd '${worktreePath}' && ${claudeCommand}`);
+      return `
+tell application "Terminal"
+  activate
+  do script "${escapedCmd}"
+end tell
+`;
+    }
+  }
+}
+function resolveTerminal() {
+  const override = process.env.PIPIT_TERMINAL?.toLowerCase();
+  if (override === "iterm2") return "iterm2";
+  if (override === "warp") return "warp";
+  if (override === "terminal") return "apple-terminal";
+  return "ghostty";
+}
+async function launchClaudeTab(workingDir, claudeCommand) {
+  const terminal = resolveTerminal();
+  const script = buildAppleScript(terminal, workingDir, claudeCommand);
+  await execa2("osascript", ["-e", script]);
+}
+async function implementTask(config) {
+  const { task, projectDir, transcriptContext } = config;
+  const slug = generateSlug(task.title);
+  const branchName = `pipit/${slug}`;
+  let worktreePath = "";
+  try {
+    worktreePath = await createWorktree(projectDir, slug);
+    const prompt = [
+      `## Task: ${task.title}`,
+      "",
+      `### Description`,
+      task.description,
+      "",
+      `### Transcript Context`,
+      transcriptContext,
+      "",
+      `### Instructions`,
+      `Implement the task described above. Follow existing code conventions.`,
+      `If relevant files were identified, start there: ${task.relevant_files.join(", ") || "none specified"}.`,
+      `When done, commit your changes with a descriptive message.`
+    ].join("\n");
+    const escapedPrompt = prompt.replace(/'/g, "'\\''");
+    const claudeCommand = `claude --dangerously-skip-permissions '${escapedPrompt}'`;
+    await launchClaudeTab(worktreePath, claudeCommand);
+    return {
+      success: true,
+      branch_name: branchName,
+      files_changed: [],
+      worktree_path: worktreePath
+    };
+  } catch (err) {
+    if (worktreePath) {
+      await cleanupWorktree(projectDir, worktreePath);
+    }
+    const message = err instanceof Error ? err.message : "Unknown error launching implementation session";
+    return {
+      success: false,
+      branch_name: branchName,
+      files_changed: [],
+      worktree_path: worktreePath,
+      error: message
+    };
+  }
+}
+
+// src/input/resolver.ts
+import { access } from "fs/promises";
+import { resolve as resolve2, extname } from "path";
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp"]);
+function inferInputType(raw) {
+  if (raw === "-") return "stdin";
+  if (raw.startsWith("http://") || raw.startsWith("https://")) return "url";
+  if (IMAGE_EXTENSIONS.has(extname(raw).toLowerCase())) return "image";
+  return "file";
+}
+async function resolveInput(raw, typeOverride) {
+  const type = typeOverride ?? inferInputType(raw);
+  switch (type) {
+    case "file":
+    case "image": {
+      const absolutePath = resolve2(raw);
+      await access(absolutePath);
+      return { type, path: absolutePath, raw };
+    }
+    case "url": {
+      return { type, url: raw, raw };
+    }
+    case "stdin": {
+      const content = await readStdin();
+      if (!content.trim()) {
+        throw new InputError("No input received on stdin", 2);
+      }
+      return { type, content, raw };
+    }
+  }
+}
+async function readStdin() {
+  if (process.stdin.isTTY) {
+    throw new InputError("No input on stdin (not piped)", 2);
+  }
+  process.stderr.write("Reading from stdin...\n");
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+var InputError = class extends Error {
+  constructor(message, exitCode) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "InputError";
+  }
+};
+
+// src/input/handlers/text-file.ts
+import { readFile as readFile2 } from "fs/promises";
+async function handleTextFile(input) {
+  const content = await readFile2(input.path, "utf-8");
+  const text = [
+    "<transcript>",
+    content,
+    "</transcript>"
+  ].join("\n");
+  return { text, claudeFlags: [] };
+}
+
+// src/input/handlers/image-file.ts
+async function handleImageFile(input) {
+  const absolutePath = input.path;
+  const text = `[Image attached: ${absolutePath}]`;
+  return {
+    text,
+    claudeFlags: ["--image", absolutePath]
+  };
+}
+
+// src/input/handlers/url.ts
+var MAX_CONTENT_LENGTH = 5e4;
+var FETCH_TIMEOUT_MS = 1e4;
+async function handleUrl(input) {
+  const url = input.url;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  let response;
+  try {
+    response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        Accept: "text/html, text/plain, */*"
+      }
+    });
+  } catch (err) {
+    clearTimeout(timeout);
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new InputError(`URL fetch timed out after 10s: ${url}`, 2);
+    }
+    throw new InputError(`Failed to fetch URL: ${url}`, 2);
+  } finally {
+    clearTimeout(timeout);
+  }
+  if (!response.ok) {
+    throw new InputError(`URL returned ${response.status}: ${url}`, 2);
+  }
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.includes("text/") && !contentType.includes("application/json")) {
+    throw new InputError(`Unsupported content type: ${contentType}`, 2);
+  }
+  const rawContent = await response.text();
+  let content = rawContent.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+  let truncated = false;
+  if (content.length > MAX_CONTENT_LENGTH) {
+    content = content.slice(0, MAX_CONTENT_LENGTH);
+    truncated = true;
+  }
+  const parts = [
+    `<article source="${url}">`,
+    content,
+    ...truncated ? [`[Content truncated at ${MAX_CONTENT_LENGTH.toLocaleString()} characters]`] : [],
+    "</article>"
+  ];
+  return { text: parts.join("\n"), claudeFlags: [] };
+}
+
+// src/input/handlers/stdin.ts
+async function handleStdin(input) {
+  const text = [
+    "<transcript>",
+    input.content,
+    "</transcript>"
+  ].join("\n");
+  return { text, claudeFlags: [] };
+}
+
+// src/input/prompt-builder.ts
+async function buildPromptContent(input, context) {
+  let result;
+  switch (input.type) {
+    case "file":
+      result = await handleTextFile(input);
+      break;
+    case "image":
+      result = await handleImageFile(input);
+      break;
+    case "url":
+      result = await handleUrl(input);
+      break;
+    case "stdin":
+      result = await handleStdin(input);
+      break;
+  }
+  if (context) {
+    result = {
+      text: result.text + "\n\nAdditional instructions from the user:\n" + context,
+      claudeFlags: [...result.claudeFlags]
+    };
+  }
+  return result;
+}
+
+// src/prompts/shared.ts
+function formatProjectContext(name, dirs) {
+  const dirList = dirs.map((d) => `  - ${d}`).join("\n");
+  return [
+    `<project>`,
+    `Name: ${name}`,
+    `Directories:`,
+    dirList,
+    `</project>`
+  ].join("\n");
+}
+function formatInputSection(content, type) {
+  if (!content || content.trim() === "") {
+    return [
+      `<context type="empty">`,
+      `The user wants to start a session for this project. Ask what they'd like to work on.`,
+      `</context>`
+    ].join("\n");
+  }
+  if (type === "image") {
+    return [
+      `<context type="image">`,
+      content,
+      `Analyze the attached image for tasks, bugs, or design changes.`,
+      `</context>`
+    ].join("\n");
+  }
+  return [
+    `<context type="${type}">`,
+    content,
+    `</context>`
+  ].join("\n");
+}
+
+// src/prompts/fire-and-forget.ts
+function buildFireAndForgetPrompt(config) {
+  const { projectName, projectDirs, inputContent, inputType, context, joycraft } = config;
+  const projectBlock = formatProjectContext(projectName, projectDirs);
+  const inputBlock = formatInputSection(inputContent, inputType);
+  const joycraftInstructions = joycraft ? [
+    `Joycraft is available in this project. Use it to:`,
+    `  1. Write atomic specs for each task you identify`,
+    `  2. Implement each spec`,
+    `  3. Open a PR with all changes`
+  ].join("\n") : [
+    `Make a plan for implementation, prioritize the tasks, implement them,`,
+    `and commit your work. Open a PR when done.`
+  ].join("\n");
+  const contextAddition = context ? [
+    ``,
+    `<additional-context>`,
+    `Additional instructions from the user:`,
+    context,
+    `</additional-context>`
+  ].join("\n") : "";
+  return [
+    projectBlock,
+    ``,
+    inputBlock,
+    contextAddition,
+    ``,
+    `<instructions>`,
+    `You are working on the "${projectName}" project. Analyze the context provided above`,
+    `and extract all relevant development tasks and action items.`,
+    ``,
+    joycraftInstructions,
+    ``,
+    `Work fully autonomously -- do not wait for user input. You have full authority`,
+    `to analyze, plan, implement, and open a PR.`,
+    ``,
+    `If critical information is missing, proceed with reasonable assumptions and note`,
+    `them in the PR description. Do not block on unanswered questions.`,
+    ``,
+    `Spin up teammates to execute tasks in parallel where possible.`,
+    `</instructions>`
+  ].join("\n");
+}
+
+// src/prompts/interactive.ts
+function buildInteractivePrompt(config) {
+  const { projectName, projectDirs, inputContent, inputType, context, joycraft } = config;
+  const projectBlock = formatProjectContext(projectName, projectDirs);
+  const inputBlock = formatInputSection(inputContent, inputType);
+  const joycraftInstructions = joycraft ? [
+    `Joycraft is available in this project. Start by running /interview or /new-feature`,
+    `with the context below as starting material. Let the interview process guide`,
+    `the conversation before any implementation begins.`
+  ].join("\n") : [
+    `Start by having a conversation about the context above. Ask clarifying questions`,
+    `to understand the user's goals and priorities before implementing anything.`,
+    `Do not write code until the user confirms the plan.`
+  ].join("\n");
+  const contextAddition = context ? [
+    ``,
+    `<additional-context>`,
+    `Additional instructions from the user:`,
+    context,
+    `</additional-context>`
+  ].join("\n") : "";
+  return [
+    projectBlock,
+    ``,
+    inputBlock,
+    contextAddition,
+    ``,
+    `<instructions>`,
+    `You are working on the "${projectName}" project. The user has pipit'd the context`,
+    `above into this session for discussion and collaboration.`,
+    ``,
+    joycraftInstructions,
+    ``,
+    `Wait for the user to participate before implementing anything. This is a`,
+    `collaborative session -- explore the context together, clarify requirements,`,
+    `and agree on an approach before writing any code.`,
+    `</instructions>`
+  ].join("\n");
+}
+
+// src/joycraft/detector.ts
+import { existsSync } from "fs";
+import { join } from "path";
+function detectJoycraft(projectDir) {
+  return existsSync(join(projectDir, ".claude", "skills"));
+}
+
+// src/input/types.ts
+import { z as z2 } from "zod";
+var InputTypeSchema = z2.enum(["file", "image", "url", "stdin"]);
+var ControlLevelSchema = z2.enum(["auto", "plan_first", "extract_only"]);
+var SessionModeSchema = z2.enum(["fire_and_forget", "interactive"]);
+var JsonOutputSchema = z2.object({
+  success: z2.boolean(),
+  input_type: InputTypeSchema.optional(),
+  input_resolved: z2.string().optional(),
+  project_dir: z2.string().optional(),
+  terminal: z2.string().optional(),
+  prompt_version: z2.number().optional(),
+  error_code: z2.number().optional(),
+  error: z2.string().optional()
+});
+var EXIT = {
+  SUCCESS: 0,
+  GENERAL_ERROR: 1,
+  INPUT_NOT_FOUND: 2,
+  INVALID_ARGS: 3,
+  TERMINAL_LAUNCH_FAILED: 4
+};
+
+// src/cli.ts
+var program = new Command();
+program.name("pipit").description(
+  "Pipe any context into Claude Code sessions"
+).version("0.1.0");
+function collect(value, previous) {
+  return previous.concat([value]);
+}
+program.command("process").description("Process a meeting transcript file").argument("<transcript-file>", "Path to the transcript file to process").option("-p, --project-dir <dir>", "Target project directory").option("-n, --dry-run", "Extract tasks without implementing them").option(
+  "-t, --task-index <index>",
+  "Only implement a specific task by index",
+  parseInt
+).action(
+  async (transcriptFile, options) => {
+    try {
+      const absoluteTranscriptPath = resolve3(transcriptFile);
+      try {
+        await access2(absoluteTranscriptPath);
+      } catch {
+        console.error(`Error: Transcript file not found: ${absoluteTranscriptPath}`);
+        process.exit(1);
+      }
+      const projectDir = resolve3(options.projectDir ?? process.cwd());
+      console.log(`Extracting tasks from ${absoluteTranscriptPath}...`);
+      const result = await extractTasks(absoluteTranscriptPath, projectDir);
+      console.log("");
+      console.log(`Meeting summary: ${result.meeting_summary}`);
+      console.log("");
+      console.log(`Action items found: ${result.action_items.length}`);
+      for (let i = 0; i < result.action_items.length; i++) {
+        const item = result.action_items[i];
+        console.log(
+          `  [${i}] [${item.priority}] [${item.estimated_complexity}] ${item.title}`
+        );
+      }
+      if (result.decisions.length > 0) {
+        console.log("");
+        console.log("Decisions made:");
+        for (const decision of result.decisions) {
+          console.log(`  - ${decision}`);
+        }
+      }
+      if (result.questions_to_clarify.length > 0) {
+        console.log("");
+        console.log("Questions to clarify:");
+        for (const question of result.questions_to_clarify) {
+          console.log(`  - ${question}`);
+        }
+      }
+      if (options.dryRun) {
+        console.log("");
+        console.log("Dry run -- skipping implementation");
+        return;
+      }
+      const taskIndex = options.taskIndex ?? 0;
+      if (taskIndex < 0 || taskIndex >= result.action_items.length) {
+        console.error(
+          `Error: Task index ${taskIndex} is out of range (0-${result.action_items.length - 1})`
+        );
+        process.exit(1);
+      }
+      const task = result.action_items[taskIndex];
+      console.log("");
+      console.log(`Implementing task: ${task.title}...`);
+      const taskResult = await implementTask({
+        task,
+        projectDir,
+        transcriptContext: task.transcript_context
+      });
+      console.log("");
+      if (taskResult.success) {
+        console.log("Claude Code session launched in a new terminal tab.");
+        console.log(`  Branch: ${taskResult.branch_name}`);
+        console.log(`  Worktree: ${taskResult.worktree_path}`);
+        console.log("");
+        console.log("When Claude finishes, you can:");
+        console.log(`  cd ${taskResult.worktree_path}`);
+        console.log(`  git push origin ${taskResult.branch_name} && gh pr create`);
+      } else {
+        console.error(`Failed to launch session: ${taskResult.error}`);
+        process.exit(1);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      console.error(`Error: ${message}`);
+      process.exit(1);
+    }
+  }
+);
+program.command("go").description("Send any context to Claude Code -- let it extract, plan, and implement").argument("<input>", "Input: file path, URL (http/https), or - for stdin").argument("<project-name>", "Name of the project this context is for").option("-p, --project-dir <dir>", "Project directory (repeatable for multi-dir projects)", collect, []).addOption(
+  new Option("--input-type <type>", "Override input type inference").choices(["file", "image", "url", "stdin"])
+).addOption(
+  new Option("--control-level <level>", "Control level for Claude session").choices(["auto", "plan_first", "extract_only"]).default("auto")
+).option("--terminal <name>", "Terminal to use (ghostty, iterm2, warp, terminal)").option("--context <text>", "Additional instructions appended to the prompt").option("--dry-run", "Print the resolved prompt without launching", false).option("--json", "Emit machine-readable JSON to stdout", false).addOption(
+  new Option("--mode <mode>", "Session mode").choices(["fire_and_forget", "interactive"]).default("fire_and_forget")
+).action(
+  async (rawInput, projectName, opts) => {
+    const inputType = opts.inputType ? InputTypeSchema.parse(opts.inputType) : void 0;
+    const controlLevel = ControlLevelSchema.parse(opts.controlLevel);
+    const mode = SessionModeSchema.parse(opts.mode);
+    const projectDirs = opts.projectDir.length > 0 ? opts.projectDir.map((d) => resolve3(d)) : [resolve3(process.cwd())];
+    const options = {
+      projectDir: projectDirs,
+      inputType,
+      controlLevel,
+      terminal: opts.terminal,
+      context: opts.context,
+      dryRun: opts.dryRun,
+      json: opts.json,
+      mode
+    };
+    function outputJson(data) {
+      process.stdout.write(JSON.stringify(data) + "\n");
+    }
+    function fail(message, exitCode) {
+      if (options.json) {
+        outputJson({ success: false, error_code: exitCode, error: message });
+      } else {
+        console.error(`Error: ${message}`);
+      }
+      process.exit(exitCode);
+    }
+    try {
+      const resolved = await resolveInput(rawInput, inputType);
+      const promptContent = await buildPromptContent(resolved, options.context);
+      const joycraft = detectJoycraft(projectDirs[0]);
+      const promptConfig = {
+        projectName,
+        projectDirs,
+        inputContent: promptContent.text,
+        inputType: resolved.type,
+        context: options.context,
+        mode,
+        joycraft
+      };
+      const prompt = mode === "interactive" ? buildInteractivePrompt(promptConfig) : buildFireAndForgetPrompt(promptConfig);
+      if (options.dryRun) {
+        if (options.json) {
+          outputJson({
+            success: true,
+            input_type: resolved.type,
+            input_resolved: resolved.path ?? resolved.url ?? "(stdin)",
+            project_dir: projectDirs[0],
+            terminal: options.terminal ?? process.env.PIPIT_TERMINAL ?? "ghostty",
+            prompt_version: 2
+          });
+        } else {
+          console.log(prompt);
+        }
+        return;
+      }
+      const escapedPrompt = prompt.replace(/'/g, "'\\''");
+      const controlFlag = controlLevel === "auto" ? "--dangerously-skip-permissions" : "";
+      const extraFlags = promptContent.claudeFlags.map((f) => f.includes(" ") ? `'${f.replace(/'/g, "'\\''")}'` : f).join(" ");
+      const claudeCommand = `claude ${controlFlag} ${extraFlags} '${escapedPrompt}'`.replace(/\s+/g, " ").trim();
+      if (options.terminal) {
+        process.env.PIPIT_TERMINAL = options.terminal;
+      }
+      const workingDir = projectDirs[0];
+      if (!options.json) {
+        console.log(`Launching Claude Code session for ${projectName}...`);
+      }
+      try {
+        await launchClaudeTab(workingDir, claudeCommand);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Terminal launch failed";
+        fail(msg, EXIT.TERMINAL_LAUNCH_FAILED);
+      }
+      if (options.json) {
+        outputJson({
+          success: true,
+          input_type: resolved.type,
+          input_resolved: resolved.path ?? resolved.url ?? "(stdin)",
+          project_dir: workingDir,
+          terminal: options.terminal ?? process.env.PIPIT_TERMINAL ?? "ghostty",
+          prompt_version: 2
+        });
+      } else {
+        console.log("");
+        console.log("Claude Code session launched in a new terminal tab.");
+        console.log(`  Project: ${workingDir}`);
+        if (projectDirs.length > 1) {
+          console.log(`  Additional dirs: ${projectDirs.slice(1).join(", ")}`);
+        }
+        console.log("");
+        console.log("Claude will extract tasks, plan, and implement. Watch the tab!");
+      }
+    } catch (err) {
+      if (err instanceof InputError) {
+        fail(err.message, err.exitCode);
+      }
+      const message = err instanceof Error ? err.message : "Unknown error";
+      fail(message, EXIT.GENERAL_ERROR);
+    }
+  }
+);
+program.parse();

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "pipit-cli",
+  "version": "0.1.0",
+  "description": "Pipe any context into Claude Code sessions. Screenshots, meeting notes, URLs, clipboard -- capture it and let Claude handle the rest.",
+  "type": "module",
+  "bin": {
+    "pipit": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "pnpm build && pnpm test --run && pnpm typecheck"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "cli",
+    "transcript",
+    "meeting-notes",
+    "automation"
+  ],
+  "author": "Maximilian Maksutovic",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/maksutovic/pipit.git"
+  },
+  "homepage": "https://github.com/maksutovic/pipit#readme",
+  "dependencies": {
+    "commander": "^13.1.0",
+    "execa": "^9.5.2",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "@typescript-eslint/eslint-plugin": "^8.26.1",
+    "@typescript-eslint/parser": "^8.26.1",
+    "eslint": "^9.22.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.2",
+    "vitest": "^3.0.9"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "packageManager": "pnpm@10.19.0"
+}