@longshot/cli 0.0.1

package/LICENSE

@@ -0,0 +1,8 @@
+Copyright (c) 2026 Rob Sherrill. All Rights Reserved.
+
+This software is proprietary and confidential. No part of this software may be
+reproduced, distributed, or transmitted in any form or by any means, without
+the prior written permission of the copyright holder.
+
+Unauthorized copying, modification, distribution, or use of this software,
+via any medium, is strictly prohibited.

package/dist/agent.js

@@ -0,0 +1,214 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+export function spawnAgent(task, cwd, timeoutMs = 5 * 60 * 1000, mcpConfig) {
+    const args = [
+        "@anthropic-ai/claude-code",
+        "-p",
+        task,
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--dangerously-skip-permissions",
+    ];
+    if (mcpConfig) {
+        args.push("--mcp-config", JSON.stringify(mcpConfig));
+    }
+    const proc = spawn("npx", args, {
+        cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: {
+            ...process.env,
+            CLAUDECODE: undefined, // Clear so it doesn't think it's nested
+        },
+    });
+    let killed = false;
+    const timer = setTimeout(() => {
+        killed = true;
+        proc.kill("SIGTERM");
+    }, timeoutMs);
+    const kill = () => {
+        killed = true;
+        clearTimeout(timer);
+        proc.kill("SIGTERM");
+    };
+    async function* events() {
+        const rl = createInterface({ input: proc.stdout });
+        // Collect stderr as it arrives
+        let stderr = "";
+        proc.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            // stream-json format: each line is a top-level event
+            // type: "system" (init), "assistant" (model output), "user" (tool results), "result" (final)
+            if (parsed.type === "assistant" && parsed.message?.content) {
+                for (const block of parsed.message.content) {
+                    if (block.type === "text" && block.text) {
+                        yield { type: "text", content: block.text };
+                    }
+                    else if (block.type === "tool_use") {
+                        yield {
+                            type: "tool_use",
+                            name: block.name ?? "unknown",
+                            id: block.id ?? "",
+                            input: block.input,
+                        };
+                    }
+                }
+            }
+            else if (parsed.type === "user" && parsed.message?.content) {
+                // Tool results — extract result content (truncated if large)
+                for (const block of parsed.message.content) {
+                    if (block.type === "tool_result") {
+                        let content;
+                        if (typeof block.content === "string") {
+                            content = block.content.slice(0, 2000);
+                        }
+                        else if (Array.isArray(block.content)) {
+                            const textParts = block.content
+                                .filter((p) => p.type === "text")
+                                .map((p) => p.text)
+                                .join("\n");
+                            content = textParts.slice(0, 2000);
+                        }
+                        yield {
+                            type: "tool_result",
+                            name: block.tool_use_id ?? "",
+                            id: block.tool_use_id ?? "",
+                            content,
+                        };
+                    }
+                }
+            }
+        }
+        // Wait for process to exit
+        const exitCode = await new Promise((resolve) => {
+            if (proc.exitCode !== null) {
+                resolve(proc.exitCode);
+            }
+            else {
+                proc.on("close", (code) => resolve(code ?? 1));
+            }
+        });
+        clearTimeout(timer);
+        if (killed) {
+            yield { type: "error", message: "Agent timed out" };
+        }
+        if (exitCode !== 0 && stderr) {
+            yield { type: "error", message: stderr.slice(0, 2000) };
+        }
+        yield { type: "done", exitCode };
+    }
+    return { events: events(), process: proc, kill };
+}
+export async function chatWithClaude(messages, cwd, opts) {
+    const timeoutMs = opts?.timeoutMs ?? 60 * 1000;
+    // Build conversation context for the prompt
+    const contextMessages = messages.slice(-20); // last 20 for context
+    const conversationContext = contextMessages
+        .map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`)
+        .join("\n\n");
+    const prompt = opts?.systemPrompt
+        ? `${opts.systemPrompt}
+
+Previous conversation:
+${conversationContext}
+
+Respond to the latest user message. Be concise — the user is reading on a mobile phone.`
+        : `You are a helpful assistant for a software project. You can read files and search the codebase to answer questions accurately, but do not modify anything. You have access to Read, Glob, Grep, and LS tools for discovery.
+
+Previous conversation:
+${conversationContext}
+
+Respond to the latest user message. Be concise — the user is reading on a mobile phone.`;
+    const readOnlyTools = ["Read", "Glob", "Grep", "LS"];
+    const args = [
+        "@anthropic-ai/claude-code",
+        "-p",
+        prompt,
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--allowedTools",
+        readOnlyTools.join(","),
+    ];
+    const proc = spawn("npx", args, {
+        cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: {
+            ...process.env,
+            CLAUDECODE: undefined,
+        },
+    });
+    let killed = false;
+    const timer = setTimeout(() => {
+        killed = true;
+        proc.kill("SIGTERM");
+    }, timeoutMs);
+    return new Promise((resolve, reject) => {
+        let fullText = "";
+        const rl = createInterface({ input: proc.stdout });
+        let stderr = "";
+        proc.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        rl.on("line", (line) => {
+            if (!line.trim())
+                return;
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed.type === "assistant" && parsed.message?.content) {
+                    for (const block of parsed.message.content) {
+                        if (block.type === "text" && block.text) {
+                            fullText += block.text;
+                        }
+                    }
+                }
+                else if (parsed.type === "result" && parsed.result) {
+                    // Final result text
+                    if (!fullText && typeof parsed.result === "string") {
+                        fullText = parsed.result;
+                    }
+                }
+            }
+            catch (e) {
+                console.error("chatWithClaude: failed to parse JSON line:", e.message, "line:", line.slice(0, 200));
+            }
+        });
+        proc.on("close", (code) => {
+            clearTimeout(timer);
+            if (stderr) {
+                console.error("chatWithClaude stderr:", stderr.slice(0, 2000));
+            }
+            if (killed) {
+                resolve(fullText || "Sorry, the response timed out.");
+            }
+            else if (fullText) {
+                resolve(fullText);
+            }
+            else {
+                console.error(`chatWithClaude: no text output (exit code ${code})`);
+                const stderrSummary = stderr.trim().slice(-500);
+                if (stderrSummary) {
+                    resolve(`Error from Claude CLI (exit code ${code}):\n${stderrSummary}`);
+                }
+                else {
+                    resolve(`Sorry, I couldn't generate a response (exit code ${code}).`);
+                }
+            }
+        });
+        proc.on("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}

package/dist/cli.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { resolve, join, dirname } from "node:path";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function getVersion() {
+    // Walk up from src/ or dist/ to find package.json
+    const candidates = [
+        join(__dirname, "..", "package.json"),
+        join(__dirname, "..", "..", "package.json"),
+    ];
+    for (const p of candidates) {
+        if (existsSync(p)) {
+            return JSON.parse(readFileSync(p, "utf-8")).version || "unknown";
+        }
+    }
+    return "unknown";
+}
+function printHelp() {
+    console.log(`longshot — Mobile-first Claude Code orchestrator
+
+Usage: longshot [options]
+
+Options:
+  -p, --port <number>   Port for the web server (default: 3333)
+  -d, --dir <path>      Project root directory (default: current directory)
+  -h, --help            Show this help message
+  -v, --version         Show version number
+
+Examples:
+  longshot                    Start in current directory on port 3333
+  longshot -p 8080            Start on port 8080
+  longshot -d ~/my-project    Start with a specific project directory
+
+First run:
+  If the target directory isn't a longshot project yet, you'll be guided
+  through setup. Just run \`longshot\` and follow the prompts.`);
+}
+export function parseCliArgs(args) {
+    const { values } = parseArgs({
+        args,
+        options: {
+            port: { type: "string", short: "p" },
+            dir: { type: "string", short: "d" },
+            help: { type: "boolean", short: "h", default: false },
+            version: { type: "boolean", short: "v", default: false },
+        },
+        strict: true,
+        allowPositionals: false,
+    });
+    return {
+        port: values.port ? parseInt(values.port, 10) : 3333,
+        dir: values.dir ? resolve(values.dir) : process.cwd(),
+        help: values.help ?? false,
+        version: values.version ?? false,
+    };
+}
+class InquirerPrompter {
+    async selectMode() {
+        const inquirer = await import("inquirer");
+        try {
+            const { mode } = await inquirer.default.prompt([
+                {
+                    type: "list",
+                    name: "mode",
+                    message: "How would you like to use longshot?",
+                    choices: [
+                        { name: "Single project — initialize this directory", value: "single" },
+                        { name: "Multi-project — manage multiple subdirectories", value: "multi" },
+                    ],
+                },
+            ]);
+            return mode;
+        }
+        catch {
+            return null;
+        }
+    }
+    async selectFolders(folders) {
+        const inquirer = await import("inquirer");
+        try {
+            const { selected } = await inquirer.default.prompt([
+                {
+                    type: "checkbox",
+                    name: "selected",
+                    message: "Select project directories:",
+                    choices: folders.map((f) => ({ name: f, value: f })),
+                },
+            ]);
+            return selected;
+        }
+        catch {
+            return [];
+        }
+    }
+}
+export async function runOnboarding(dir, prompter) {
+    // Check if it already has .longshot/ (single project)
+    if (existsSync(join(dir, ".longshot"))) {
+        return { action: "existing" };
+    }
+    // Check for multi-project mode (parent with projects.json)
+    if (existsSync(join(dir, ".longshot", "projects.json"))) {
+        return { action: "existing" };
+    }
+    // Non-interactive (no prompter injected and stdin is not a TTY) — auto-initialize as single project
+    if (!prompter && !process.stdin.isTTY) {
+        const { initSingleProject } = await import("./projects.js");
+        initSingleProject(dir);
+        return { action: "single" };
+    }
+    const prompt = prompter ?? new InquirerPrompter();
+    const mode = await prompt.selectMode();
+    if (mode === null) {
+        console.log('Run `longshot --help` for usage');
+        return { action: "cancelled" };
+    }
+    if (mode === "single") {
+        const { initSingleProject } = await import("./projects.js");
+        initSingleProject(dir);
+        console.log("Initialized longshot project in", dir);
+        return { action: "single" };
+    }
+    if (mode === "multi") {
+        // List subdirectories
+        const entries = readdirSync(dir, { withFileTypes: true });
+        const folders = entries
+            .filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules")
+            .map((e) => e.name);
+        if (folders.length === 0) {
+            console.log("No subdirectories found. Create some project folders first.");
+            return { action: "cancelled" };
+        }
+        const selected = await prompt.selectFolders(folders);
+        if (selected.length === 0) {
+            console.log('Run `longshot --help` for usage');
+            return { action: "cancelled" };
+        }
+        const { initMultiProject } = await import("./projects.js");
+        initMultiProject(dir, selected);
+        console.log(`Initialized ${selected.length} project(s):`, selected.join(", "));
+        return { action: "multi", selected };
+    }
+    return { action: "cancelled" };
+}
+async function main() {
+    const parsed = parseCliArgs(process.argv.slice(2));
+    if (parsed.help) {
+        printHelp();
+        process.exit(0);
+    }
+    if (parsed.version) {
+        console.log(getVersion());
+        process.exit(0);
+    }
+    // Run onboarding if needed
+    const result = await runOnboarding(parsed.dir);
+    if (result.action === "cancelled") {
+        process.exit(0);
+    }
+    // Set environment for the server
+    process.env.PORT = String(parsed.port);
+    process.env.PROJECT_ROOT = parsed.dir;
+    // Start the server
+    const { startServer } = await import("./index.js");
+    await startServer();
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});

package/dist/git.js

@@ -0,0 +1,291 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+const exec = promisify(execFile);
+async function git(args, cwd) {
+    return exec("git", args, { cwd, maxBuffer: 10 * 1024 * 1024 });
+}
+export async function ensureRepo(cwd) {
+    if (!existsSync(join(cwd, ".git"))) {
+        await git(["init"], cwd);
+        // Initial commit so we have a HEAD to diff against
+        await git(["commit", "--allow-empty", "-m", "init"], cwd);
+    }
+}
+export async function snapshot(cwd) {
+    const { stdout } = await git(["rev-parse", "HEAD"], cwd);
+    return stdout.trim();
+}
+export async function diff(cwd, fromHash) {
+    // Stage everything so we capture new files too
+    await git(["add", "-A"], cwd);
+    const { stdout } = await git([
+        "diff",
+        "--cached",
+        fromHash,
+        "--",
+        ".",
+        ":!CLAUDE.md",
+        ":!.longshot/",
+    ], cwd);
+    // Unstage so we don't interfere with the working tree
+    await git(["reset", "HEAD"], cwd);
+    return stdout;
+}
+export async function commit(cwd, message) {
+    await git(["add", "-A"], cwd);
+    await git(["commit", "-m", message], cwd);
+    const { stdout } = await git(["rev-parse", "HEAD"], cwd);
+    return stdout.trim();
+}
+export async function reset(cwd, toHash) {
+    await git(["reset", "--hard", toHash], cwd);
+    await git(["clean", "-fd"], cwd);
+}
+export async function hasUncommittedChanges(cwd) {
+    const { stdout } = await git(["status", "--porcelain"], cwd);
+    return stdout.trim().length > 0;
+}
+export async function stashSave(cwd, message) {
+    const { stdout: statusOut } = await git(["status", "--porcelain"], cwd);
+    if (!statusOut.trim())
+        return null;
+    // Parse changed files, filtering out .longshot/ and CLAUDE.md
+    const files = [];
+    for (const line of statusOut.split("\n")) {
+        if (!line.trim())
+            continue;
+        // Porcelain format: XY filename (exactly 2 status chars + 1 space + filename)
+        const filePart = line.slice(3);
+        const file = filePart.includes(" -> ") ? filePart.split(" -> ")[1] : filePart;
+        if (!file.startsWith(".longshot/") && file !== "CLAUDE.md") {
+            files.push(file);
+        }
+    }
+    if (files.length === 0)
+        return null;
+    await git(["stash", "push", "--include-untracked", "-m", message, "--", ...files], cwd);
+    const { stdout: hashOut } = await git(["rev-parse", "stash@{0}"], cwd);
+    return hashOut.trim();
+}
+export async function stashApply(cwd, hash) {
+    await git(["stash", "apply", hash], cwd);
+}
+/** Apply stash allowing conflicts — writes conflict markers to disk instead of aborting */
+export async function stashApplyAllowConflicts(cwd, hash) {
+    try {
+        await git(["stash", "apply", hash], cwd);
+        return { conflicts: [] };
+    }
+    catch (err) {
+        // Check if files were partially applied with conflict markers
+        const { stdout } = await git(["status", "--porcelain"], cwd);
+        const conflicts = [];
+        for (const line of stdout.split("\n")) {
+            if (!line.trim())
+                continue;
+            // "UU" = both modified (conflict), "AA" = both added, "DU"/"UD" = delete/modify conflicts
+            const status = line.slice(0, 2);
+            if (status === "UU" || status === "AA" || status === "DU" || status === "UD") {
+                conflicts.push(line.slice(3));
+            }
+        }
+        if (conflicts.length > 0) {
+            // Conflicts were written to disk — add conflicted files so they're tracked
+            await git(["add", "-A"], cwd);
+            return { conflicts };
+        }
+        // No conflicts detected — the error was something else
+        throw err;
+    }
+}
+export async function stashDrop(cwd, hash) {
+    const { stdout: listOut } = await git(["stash", "list", "--format=%H %gd"], cwd);
+    for (const line of listOut.trim().split("\n")) {
+        if (!line.trim())
+            continue;
+        const parts = line.split(" ");
+        const stashHash = parts[0];
+        const ref = parts[1];
+        if (stashHash === hash) {
+            await git(["stash", "drop", ref], cwd);
+            return;
+        }
+    }
+    // Not found — already dropped, idempotent
+}
+export async function getRemoteStatus(cwd) {
+    const { stdout: branchOut } = await git(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+    const branch = branchOut.trim();
+    // Check if there's a remote tracking branch
+    let remote = null;
+    try {
+        const { stdout: remoteOut } = await git(["config", "--get", `branch.${branch}.remote`], cwd);
+        remote = remoteOut.trim() || null;
+    }
+    catch {
+        return { ahead: 0, behind: 0, remote: null, branch };
+    }
+    // Fetch latest from remote
+    try {
+        await git(["fetch", remote], cwd);
+    }
+    catch {
+        // Fetch failed (no network, etc.) — continue with local state
+    }
+    const upstream = `${remote}/${branch}`;
+    let ahead = 0;
+    let behind = 0;
+    try {
+        const { stdout: aheadOut } = await git(["rev-list", "--count", `${upstream}..HEAD`], cwd);
+        ahead = parseInt(aheadOut.trim(), 10) || 0;
+        const { stdout: behindOut } = await git(["rev-list", "--count", `HEAD..${upstream}`], cwd);
+        behind = parseInt(behindOut.trim(), 10) || 0;
+    }
+    catch {
+        // Upstream branch doesn't exist yet — treat as no remote
+        return { ahead: 0, behind: 0, remote: null, branch };
+    }
+    return { ahead, behind, remote, branch };
+}
+export async function getOutgoingCommits(cwd) {
+    try {
+        const { stdout } = await git(["log", "@{u}..HEAD", "--format=%h %s"], cwd);
+        if (!stdout.trim())
+            return [];
+        return stdout
+            .trim()
+            .split("\n")
+            .map((line) => {
+            const spaceIdx = line.indexOf(" ");
+            return {
+                hash: line.slice(0, spaceIdx),
+                subject: line.slice(spaceIdx + 1),
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+export async function push(cwd) {
+    try {
+        await git(["push"], cwd);
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: err.stderr || err.message };
+    }
+}
+export async function pull(cwd) {
+    try {
+        await git(["pull", "--ff-only"], cwd);
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: err.stderr || err.message };
+    }
+}
+export async function pullRebase(cwd) {
+    try {
+        await git(["pull", "--rebase"], cwd);
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: err.stderr || err.message };
+    }
+}
+// --- Branch operations ---
+export async function getCurrentBranch(cwd) {
+    const { stdout } = await git(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+    return stdout.trim();
+}
+export async function createBranch(cwd, name) {
+    await git(["checkout", "-b", name], cwd);
+}
+export async function switchBranch(cwd, name) {
+    await git(["checkout", name], cwd);
+}
+export async function listBranches(cwd) {
+    const { stdout } = await git(["branch", "--list"], cwd);
+    const branches = [];
+    let current = "";
+    for (const line of stdout.split("\n")) {
+        if (!line.trim())
+            continue;
+        const isCurrent = line.startsWith("* ");
+        const name = line.replace(/^\*?\s+/, "").trim();
+        branches.push(name);
+        if (isCurrent)
+            current = name;
+    }
+    return { local: branches, current };
+}
+export async function mergeBranch(cwd, source, target) {
+    // Check out target branch
+    await git(["checkout", target], cwd);
+    try {
+        await git(["merge", source, "--no-edit"], cwd);
+        const { stdout } = await git(["rev-parse", "HEAD"], cwd);
+        return { success: true, commitHash: stdout.trim() };
+    }
+    catch (err) {
+        // Check for merge conflicts
+        const { stdout: statusOut } = await git(["status", "--porcelain"], cwd);
+        const conflicts = [];
+        for (const line of statusOut.split("\n")) {
+            if (!line.trim())
+                continue;
+            const status = line.slice(0, 2);
+            if (status === "UU" || status === "AA" || status === "DU" || status === "UD") {
+                conflicts.push(line.slice(3));
+            }
+        }
+        if (conflicts.length > 0) {
+            // Abort the merge
+            await git(["merge", "--abort"], cwd);
+            return { success: false, conflicts };
+        }
+        return { success: false, error: err.stderr || err.message };
+    }
+}
+export async function deleteBranch(cwd, name) {
+    try {
+        await git(["branch", "-d", name], cwd);
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: err.stderr || err.message };
+    }
+}
+export async function pushBranch(cwd, name) {
+    try {
+        await git(["push", "-u", "origin", name], cwd);
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: err.stderr || err.message };
+    }
+}
+export async function commitFiles(cwd, message, files) {
+    try {
+        await git(["add", "--", ...files], cwd);
+    }
+    catch {
+        // Files may not exist — nothing to add
+        return null;
+    }
+    try {
+        await git(["commit", "-m", message], cwd);
+    }
+    catch (err) {
+        // "nothing to commit" is fine
+        if (err.stderr?.includes("nothing to commit") || err.stdout?.includes("nothing to commit") || err.message?.includes("nothing to commit")) {
+            return null;
+        }
+        throw err;
+    }
+    const { stdout } = await git(["rev-parse", "HEAD"], cwd);
+    return stdout.trim();
+}