@longshot/cli 0.0.1

package/dist/profile.js

@@ -0,0 +1,79 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import { userInfo, hostname } from "node:os";
+let cachedPrefix = null;
+let dataDir = null;
+/** Set the data directory (for testing) */
+export function setProfileDataDir(dir) {
+    dataDir = dir;
+    cachedPrefix = null;
+}
+/** Generate a 4-char hex prefix from user@hostname */
+export function generatePrefix(identity) {
+    const input = identity || `${userInfo().username}@${hostname()}`;
+    const hash = createHash("sha256").update(input).digest("hex");
+    return hash.slice(0, 4);
+}
+function getProfilePath() {
+    if (dataDir)
+        return join(dataDir, "profile.json");
+    return join(import.meta.dirname, "..", ".longshot", "profile.json");
+}
+/** Get or create the user prefix. Cached after first call. */
+export function getPrefix() {
+    if (cachedPrefix)
+        return cachedPrefix;
+    const path = getProfilePath();
+    if (existsSync(path)) {
+        try {
+            const profile = JSON.parse(readFileSync(path, "utf-8"));
+            cachedPrefix = profile.prefix;
+            return cachedPrefix;
+        }
+        catch {
+            // Corrupt file — regenerate
+        }
+    }
+    const prefix = generatePrefix();
+    writeFileSync(path, JSON.stringify({ prefix }, null, 2), "utf-8");
+    cachedPrefix = prefix;
+    return prefix;
+}
+/** Extract the sequence number from a prefixed task ID (e.g. "a3f2-5" → 5) */
+export function getSeqNumber(id) {
+    const parts = id.split("-");
+    if (parts.length >= 2) {
+        const seq = parseInt(parts[parts.length - 1], 10);
+        if (!isNaN(seq))
+            return seq;
+    }
+    // Legacy numeric ID
+    const num = parseInt(id, 10);
+    return isNaN(num) ? 0 : num;
+}
+/** Check if a task ID is a legacy numeric-only ID */
+export function isLegacyId(id) {
+    return /^\d+$/.test(id);
+}
+/** Get the prefix part from a prefixed task ID (e.g. "a3f2-5" → "a3f2") */
+export function getIdPrefix(id) {
+    if (isLegacyId(id))
+        return null;
+    const lastDash = id.lastIndexOf("-");
+    if (lastDash <= 0)
+        return null;
+    return id.slice(0, lastDash);
+}
+/** Format a task ID for file naming (e.g. "a3f2-5" → "a3f2-005") */
+export function formatIdForFile(id) {
+    if (isLegacyId(id)) {
+        return String(parseInt(id, 10)).padStart(3, "0");
+    }
+    const prefix = getIdPrefix(id);
+    const seq = getSeqNumber(id);
+    if (prefix) {
+        return `${prefix}-${String(seq).padStart(3, "0")}`;
+    }
+    return String(seq).padStart(3, "0");
+}

package/dist/projects.js

@@ -0,0 +1,337 @@
+import { existsSync, readdirSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, renameSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { execFileSync } from "node:child_process";
+import * as store from "./store.js";
+// --- Root directory (where longshot was launched) ---
+const ROOT_DIR = process.env.PROJECT_ROOT || process.cwd();
+// --- Multi-project state ---
+let multiProject = false;
+let currentProjectName = null;
+let currentProjectRoot = ROOT_DIR;
+// --- Exports ---
+export function isMultiProject() {
+    return multiProject;
+}
+export function getProjectRoot() {
+    return currentProjectRoot;
+}
+export function getRootDir() {
+    return ROOT_DIR;
+}
+export function getCurrentProjectName() {
+    return currentProjectName;
+}
+// --- Project registry (parent data/projects.json) ---
+function parentDataDir() {
+    return join(ROOT_DIR, ".longshot");
+}
+function projectsJsonPath() {
+    return join(parentDataDir(), "projects.json");
+}
+function ensureParentDataDir() {
+    const dir = parentDataDir();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+export function readProjects() {
+    const path = projectsJsonPath();
+    if (!existsSync(path))
+        return [];
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+function saveProjects(projects) {
+    ensureParentDataDir();
+    writeFileSync(projectsJsonPath(), JSON.stringify(projects, null, 2), "utf-8");
+}
+// --- Detection on startup ---
+export function detectMode() {
+    // Auto-migrate legacy data/ → .longshot/
+    const legacyDir = join(ROOT_DIR, "data");
+    const newDir = join(ROOT_DIR, ".longshot");
+    if (!existsSync(newDir) && existsSync(legacyDir) && (existsSync(join(legacyDir, "tasks.json")) || existsSync(join(legacyDir, "spec.md")))) {
+        renameSync(legacyDir, newDir);
+        console.log("Migrated data/ → .longshot/");
+    }
+    // Auto-migrate .rem-c/ → .longshot/
+    const remcDir = join(ROOT_DIR, ".rem-c");
+    if (!existsSync(newDir) && existsSync(remcDir)) {
+        renameSync(remcDir, newDir);
+        console.log("Migrated .rem-c/ → .longshot/");
+    }
+    const hasLocalData = existsSync(join(ROOT_DIR, ".longshot"));
+    if (hasLocalData) {
+        // Project mode — single project, current behavior
+        multiProject = false;
+        currentProjectRoot = ROOT_DIR;
+        currentProjectName = null;
+        return;
+    }
+    // Parent mode — look for child projects
+    multiProject = true;
+    autoDiscover();
+    // Switch to the first project if any exist
+    const projects = readProjects();
+    if (projects.length > 0) {
+        switchProject(projects[0].name);
+    }
+}
+// --- Auto-discovery ---
+function autoDiscover() {
+    const projects = readProjects();
+    const knownNames = new Set(projects.map((p) => p.name));
+    try {
+        const entries = readdirSync(ROOT_DIR, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name === ".longshot" || entry.name.startsWith("."))
+                continue;
+            if (knownNames.has(entry.name))
+                continue;
+            const childDataDir = join(ROOT_DIR, entry.name, ".longshot");
+            if (existsSync(childDataDir)) {
+                projects.push({ name: entry.name, path: `./${entry.name}` });
+            }
+        }
+    }
+    catch { }
+    saveProjects(projects);
+}
+// --- Switch project ---
+export function switchProject(name) {
+    if (!multiProject)
+        return false;
+    const projects = readProjects();
+    const project = projects.find((p) => p.name === name);
+    if (!project)
+        return false;
+    const projectPath = resolve(ROOT_DIR, project.path);
+    if (!existsSync(join(projectPath, ".longshot")))
+        return false;
+    currentProjectName = name;
+    currentProjectRoot = projectPath;
+    store.setDataDir(join(projectPath, ".longshot"));
+    return true;
+}
+// --- List available (unregistered) subdirectories ---
+export function listAvailableSubdirs() {
+    const projects = readProjects();
+    const knownNames = new Set(projects.map((p) => p.name));
+    const available = [];
+    try {
+        const entries = readdirSync(ROOT_DIR, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules")
+                continue;
+            if (knownNames.has(entry.name))
+                continue;
+            available.push(entry.name);
+        }
+    }
+    catch { }
+    return available;
+}
+// --- Gitignore entries for transient state ---
+const GITIGNORE_ENTRIES = [
+    "# longshot transient state",
+    ".longshot/status.json",
+    ".longshot/pending-diffs.json",
+    ".longshot/queue.json",
+    "CLAUDE.md",
+];
+function setupGitignore(projectPath, isNew) {
+    const gitignorePath = join(projectPath, ".gitignore");
+    if (isNew) {
+        const lines = [
+            "node_modules/",
+            "dist/",
+            "",
+            ...GITIGNORE_ENTRIES,
+            "",
+        ];
+        writeFileSync(gitignorePath, lines.join("\n"), "utf-8");
+        return;
+    }
+    // Adopt flow — append to existing .gitignore
+    const existing = existsSync(gitignorePath) ? readFileSync(gitignorePath, "utf-8") : "";
+    const existingLines = existing.split("\n");
+    const toAdd = [];
+    for (const entry of GITIGNORE_ENTRIES) {
+        if (entry.startsWith("#")) {
+            // Always add the header if we're adding anything
+            continue;
+        }
+        if (!existingLines.includes(entry)) {
+            toAdd.push(entry);
+        }
+    }
+    if (toAdd.length > 0) {
+        const block = "\n\n# longshot transient state\n" + toAdd.join("\n") + "\n";
+        appendFileSync(gitignorePath, block, "utf-8");
+    }
+}
+// --- Scaffold data dir ---
+function scaffoldDataDir(projectPath, projectName) {
+    const dataDir = join(projectPath, ".longshot");
+    mkdirSync(dataDir, { recursive: true });
+    writeFileSync(join(dataDir, "spec.md"), `# ${projectName}\n\n`, "utf-8");
+    writeFileSync(join(dataDir, "tasks.json"), "[]", "utf-8");
+    writeFileSync(join(dataDir, "conversation.json"), "[]", "utf-8");
+    writeFileSync(join(dataDir, "history.jsonl"), "", "utf-8");
+    writeFileSync(join(dataDir, "queue.json"), "[]", "utf-8");
+}
+// --- Create new project ---
+export function createProject(name) {
+    if (!multiProject)
+        return { ok: false, error: "Not in multi-project mode" };
+    if (!name || /[^a-zA-Z0-9_-]/.test(name)) {
+        return { ok: false, error: "Invalid project name (use letters, numbers, hyphens, underscores)" };
+    }
+    const projects = readProjects();
+    if (projects.find((p) => p.name === name)) {
+        return { ok: false, error: "Project already exists" };
+    }
+    const projectPath = join(ROOT_DIR, name);
+    if (existsSync(projectPath)) {
+        return { ok: false, error: "Directory already exists" };
+    }
+    // Create directory and git init
+    mkdirSync(projectPath, { recursive: true });
+    execFileSync("git", ["init"], { cwd: projectPath, stdio: "ignore" });
+    // Scaffold data dir
+    scaffoldDataDir(projectPath, name);
+    // Set up .gitignore
+    setupGitignore(projectPath, true);
+    // Initial commit
+    execFileSync("git", ["add", "."], { cwd: projectPath, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "Initial longshot scaffold"], { cwd: projectPath, stdio: "ignore" });
+    // Register
+    projects.push({ name, path: `./${name}` });
+    saveProjects(projects);
+    return { ok: true };
+}
+// --- Adopt existing subfolder ---
+export function adoptProject(name) {
+    if (!multiProject)
+        return { ok: false, error: "Not in multi-project mode" };
+    const projectPath = join(ROOT_DIR, name);
+    if (!existsSync(projectPath)) {
+        return { ok: false, error: "Directory not found" };
+    }
+    // Check it's a git repo
+    if (!existsSync(join(projectPath, ".git"))) {
+        return { ok: false, error: "Not a git repo — run `git init` first" };
+    }
+    const projects = readProjects();
+    // Already has .longshot/ — just register, don't re-scaffold
+    if (existsSync(join(projectPath, ".longshot"))) {
+        if (projects.find((p) => p.name === name)) {
+            return { ok: false, error: "Already registered as a project" };
+        }
+        projects.push({ name, path: `./${name}` });
+        saveProjects(projects);
+        switchProject(name);
+        return { ok: true };
+    }
+    if (projects.find((p) => p.name === name)) {
+        return { ok: false, error: "Already registered as a project" };
+    }
+    // Scaffold data dir
+    scaffoldDataDir(projectPath, name);
+    // Update .gitignore
+    setupGitignore(projectPath, false);
+    // Commit the scaffold
+    try {
+        execFileSync("git", ["add", ".longshot/", ".gitignore"], { cwd: projectPath, stdio: "ignore" });
+        execFileSync("git", ["commit", "-m", "Add longshot data scaffold"], { cwd: projectPath, stdio: "ignore" });
+    }
+    catch {
+        // May fail if nothing to commit
+    }
+    // Register
+    projects.push({ name, path: `./${name}` });
+    saveProjects(projects);
+    // Switch to it
+    switchProject(name);
+    return { ok: true };
+}
+// --- CLI onboarding helpers ---
+/**
+ * Initialize a directory as a single longshot project.
+ * Scaffolds .longshot/ and sets up .gitignore.
+ * Commits if the directory is a git repo.
+ */
+export function initSingleProject(dir) {
+    const name = dir.split("/").pop() || "project";
+    scaffoldDataDir(dir, name);
+    setupGitignore(dir, !existsSync(join(dir, ".gitignore")));
+    // Commit if it's a git repo
+    if (existsSync(join(dir, ".git"))) {
+        try {
+            execFileSync("git", ["add", ".longshot/", ".gitignore"], { cwd: dir, stdio: "ignore" });
+            execFileSync("git", ["commit", "-m", "Initialize longshot project"], { cwd: dir, stdio: "ignore" });
+        }
+        catch {
+            // May fail if nothing to commit
+        }
+    }
+}
+/**
+ * Initialize multi-project mode in a parent directory.
+ * Adopts selected subdirectories as projects.
+ * Self-contained — reads/writes projects.json directly in parentDir/.longshot/
+ * so it works regardless of the module-level ROOT_DIR.
+ */
+export function initMultiProject(parentDir, selectedDirs) {
+    const parentDataPath = join(parentDir, ".longshot");
+    const projectsPath = join(parentDataPath, "projects.json");
+    // Ensure parent .longshot dir exists
+    if (!existsSync(parentDataPath)) {
+        mkdirSync(parentDataPath, { recursive: true });
+    }
+    // Read existing projects.json or start fresh
+    let projects = [];
+    if (existsSync(projectsPath)) {
+        try {
+            projects = JSON.parse(readFileSync(projectsPath, "utf-8"));
+        }
+        catch {
+            projects = [];
+        }
+    }
+    for (const dirName of selectedDirs) {
+        const projectPath = join(parentDir, dirName);
+        if (!existsSync(projectPath))
+            continue;
+        // Already has .longshot/ — just register
+        if (existsSync(join(projectPath, ".longshot"))) {
+            if (!projects.find((p) => p.name === dirName)) {
+                projects.push({ name: dirName, path: `./${dirName}` });
+            }
+            continue;
+        }
+        // Scaffold the subdirectory
+        scaffoldDataDir(projectPath, dirName);
+        setupGitignore(projectPath, !existsSync(join(projectPath, ".gitignore")));
+        // Commit if it's a git repo
+        if (existsSync(join(projectPath, ".git"))) {
+            try {
+                execFileSync("git", ["add", ".longshot/", ".gitignore"], { cwd: projectPath, stdio: "ignore" });
+                execFileSync("git", ["commit", "-m", "Add longshot data scaffold"], { cwd: projectPath, stdio: "ignore" });
+            }
+            catch {
+                // May fail if nothing to commit
+            }
+        }
+        // Register
+        if (!projects.find((p) => p.name === dirName)) {
+            projects.push({ name: dirName, path: `./${dirName}` });
+        }
+    }
+    // Save projects.json
+    writeFileSync(projectsPath, JSON.stringify(projects, null, 2), "utf-8");
+}