@prepcli/prepcli 0.1.0

package/src/commands/record.js

@@ -0,0 +1,141 @@
+"use strict";
+
+const readline = require("node:readline/promises");
+
+const { generateId, getCurrentCommit, getChangedFiles, recordFilename } = require("../lib/decision");
+const {
+  shadowBranchExists, shadowBranchExistsOnRemote,
+  initShadowBranch, fetchShadowBranch,
+  writeDecisionRecord,
+} = require("../lib/git");
+const { isLoggedIn, requireLoginFresh, readRC } = require("../lib/config");
+const api = require("../lib/api");
+
+async function prompt(rl, question, fallback = "") {
+  const answer = (await rl.question(question)).trim();
+  return answer || fallback;
+}
+
+function buildRecord({ id, what, why, ruledOut, workflow, commitHash, filesChanged }) {
+  const date      = new Date().toISOString();
+  const filesList = (filesChanged || []).join(", ") || "none";
+  const ruledOutSection = ruledOut
+    ? ruledOut.split(",").map(r => `- ${r.trim()}`).join("\n")
+    : "None recorded.";
+
+  return `---
+id: ${id}
+commit: ${commitHash || "none"}
+date: ${date}
+workflow: ${workflow}
+files_changed: [${filesList}]
+ai_turn_count: 0
+---
+
+## Summary
+${what}
+
+## Why This Approach
+${why}
+
+## What Was Tried and Ruled Out
+${ruledOutSection}
+
+## AI Session Turns
+Manual record — not from an AI session.
+`;
+}
+
+async function run(opts = {}) {
+  const cwd = process.cwd();
+
+  // ── Collect fields ──────────────────────────────────────────────────────────
+  let { what, why, ruledOut, workflow } = opts;
+
+  if (!what || !why) {
+    // Interactive mode
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+    try {
+      console.log("\n[prepcli] Recording decision\n");
+
+      if (!what) {
+        what = await prompt(rl, "What did you decide or discover?\n> ");
+        if (!what) { console.log("Cancelled — nothing recorded."); return; }
+      }
+
+      if (!why) {
+        why = await prompt(rl, "\nWhy?\n> ");
+        if (!why) { console.log("Cancelled — nothing recorded."); return; }
+      }
+
+      if (!ruledOut) {
+        ruledOut = await prompt(rl, "\nWhat was ruled out? (Enter to skip)\n> ");
+      }
+
+      if (!workflow) {
+        workflow = await prompt(rl, "\nWorkflow? [manual/debug/plan/discovery] (Enter for manual)\n> ", "manual");
+      }
+
+    } finally {
+      rl.close();
+    }
+  }
+
+  workflow = workflow || "manual";
+
+  // ── Ensure shadow branch exists ─────────────────────────────────────────────
+  if (!shadowBranchExists(cwd)) {
+    process.stdout.write("\nInitialising shadow branch...");
+    if (shadowBranchExistsOnRemote(cwd)) {
+      fetchShadowBranch(cwd);
+      console.log(" fetched from remote.");
+    } else {
+      initShadowBranch(cwd);
+      console.log(" created.");
+    }
+  }
+
+  // ── Build and write record ──────────────────────────────────────────────────
+  const id           = generateId();
+  const commitHash   = getCurrentCommit(cwd);
+  const filesChanged = getChangedFiles(cwd);
+  const content      = buildRecord({ id, what, why, ruledOut, workflow, commitHash, filesChanged });
+  const filename     = recordFilename(id);
+
+  process.stdout.write("\nWriting to shadow branch...");
+  try {
+    writeDecisionRecord(filename, content, cwd);
+  } catch(e) {
+    console.error(` failed: ${e.message}`);
+    process.exit(1);
+  }
+  console.log(" done.");
+
+  // ── Write lean summary to cloud if logged in ────────────────────────────────
+  if (isLoggedIn()) {
+    try {
+      const cfg = await requireLoginFresh();
+      const rc  = readRC();
+      if (rc?.project_id) {
+        const lean = {
+          summary:               what,
+          why,
+          alternatives_rejected: ruledOut ? ruledOut.split(",").map(r => r.trim()) : [],
+          key_files:             filesChanged.slice(0, 10),
+          workflow,
+          ai_turn_count:         0,
+          commit_hash:           commitHash,
+          session_start:         new Date().toISOString(),
+          session_end:           new Date().toISOString(),
+        };
+        await api.post(`/projects/${rc.project_id}/sessions`, lean, cfg.access_token);
+      }
+    } catch { /* cloud write is non-fatal */ }
+  }
+
+  console.log(`\n✓  Decision recorded (${id})`);
+  console.log("   View: prepcli log\n");
+}
+
+module.exports = { run };

package/src/commands/session.js

@@ -0,0 +1,44 @@
+"use strict";
+
+const { addTurn, readSession, clearSession } = require("../lib/session-file");
+
+function run(action, opts = {}) {
+  if (action === "add") {
+    const { workflow, what, why } = opts;
+
+    if (!workflow || !what) {
+      console.error("prepcli session add requires --workflow and --what");
+      process.exit(1);
+    }
+
+    addTurn({ workflow, what, why: why || "" });
+    // Silent — no output. AI calls this invisibly.
+    return;
+  }
+
+  if (action === "show") {
+    const session = readSession();
+    if (!session?.turns?.length) {
+      console.log("No active session.");
+      return;
+    }
+    console.log(`Session started: ${session.started_at}`);
+    console.log(`Turns: ${session.turns.length}`);
+    for (const t of session.turns) {
+      console.log(`  [${t.workflow}]  ${t.what}`);
+      if (t.why) console.log(`           why: ${t.why}`);
+    }
+    return;
+  }
+
+  if (action === "clear") {
+    clearSession();
+    console.log("Session cleared.");
+    return;
+  }
+
+  console.error(`Unknown session action: ${action}. Use: add | show | clear`);
+  process.exit(1);
+}
+
+module.exports = { run };

package/src/commands/stats.js

@@ -0,0 +1,10 @@
+"use strict";
+// Phase 4 — Delta Tracker
+
+function run(opts) {
+  console.log("[Phase 4] stats — not implemented yet.");
+  console.log("Coming in Phase 4: show prompt quality scores and delta trends");
+  console.log("from Supabase across all sessions in this project.");
+}
+
+module.exports = { run };

package/src/commands/team.js

@@ -0,0 +1,21 @@
+"use strict";
+// Phase 6 — Team Features
+
+function run(action, email) {
+  switch (action) {
+    case "invite":
+      console.log(`[Phase 6] team invite ${email || "<email>"} — not implemented yet.`);
+      break;
+    case "list":
+      console.log("[Phase 6] team list — not implemented yet.");
+      break;
+    case "remove":
+      console.log(`[Phase 6] team remove ${email || "<email>"} — not implemented yet.`);
+      break;
+    default:
+      console.error(`Unknown team action: ${action}. Use invite | list | remove`);
+      process.exit(1);
+  }
+}
+
+module.exports = { run };

package/src/commands/uninstall.js

@@ -0,0 +1,105 @@
+"use strict";
+
+const fs   = require("node:fs");
+const os   = require("node:os");
+const path = require("node:path");
+const readline = require("node:readline/promises");
+
+const getClaudeTargets      = require("../lib/targets/claude");
+const getCursorTargets      = require("../lib/targets/cursor");
+const getWindsurfTargets    = require("../lib/targets/windsurf");
+const getAntigravityTargets = require("../lib/targets/antigravity");
+
+const WORKFLOW_DIR = path.resolve(__dirname, "../../workflows");
+
+function getTargets() {
+  const ctx = { cwd: process.cwd(), home: os.homedir() };
+  return [
+    ...getClaudeTargets(ctx),
+    ...getCursorTargets(ctx),
+    ...getWindsurfTargets(ctx),
+    ...getAntigravityTargets(ctx),
+  ];
+}
+
+function listWorkflows() {
+  return fs.readdirSync(WORKFLOW_DIR).filter((f) => f.endsWith(".md")).sort();
+}
+
+function fmtDest(dest) {
+  const home = os.homedir();
+  if (dest.startsWith(home)) return `~${dest.slice(home.length)}`;
+  return path.relative(process.cwd(), dest) || ".";
+}
+
+function isInstalled(destination, workflows) {
+  return workflows.some((f) => {
+    try { fs.accessSync(path.join(destination, f)); return true; }
+    catch { return false; }
+  });
+}
+
+async function run(opts) {
+  const workflows = listWorkflows();
+  const targets   = getTargets();
+
+  const installed = targets.filter((t) => isInstalled(t.destination, workflows));
+
+  if (installed.length === 0) {
+    console.log("No prepcli workflows found on this machine.");
+    return;
+  }
+
+  if (opts.all || opts.yes) {
+    return removeFrom(installed, workflows);
+  }
+
+  console.log("\nprepcli workflows found in:\n");
+  installed.forEach((t, i) => {
+    console.log(`  ${i + 1}. ${t.label}  (${fmtDest(t.destination)})`);
+  });
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question("\nRemove from which? [all / 1,2 / none]: ")).trim();
+    if (!answer || answer === "none" || answer === "n") {
+      console.log("Nothing removed.");
+      return;
+    }
+
+    const selected = answer === "all" || answer === "a"
+      ? installed
+      : answer.split(/[,\s]+/).map(Number).filter(Boolean).map((n) => installed[n - 1]).filter(Boolean);
+
+    await removeFrom(selected, workflows);
+  } finally {
+    rl.close();
+  }
+}
+
+function removeFrom(targets, workflows) {
+  let failures = 0;
+
+  for (const t of targets) {
+    try {
+      for (const file of workflows) {
+        const filePath = path.join(t.destination, file);
+        try { fs.unlinkSync(filePath); } catch {}
+      }
+      console.log(`  ✓  Removed from ${t.label}  (${fmtDest(t.destination)})`);
+    } catch (err) {
+      failures++;
+      console.error(`  ✗  ${t.label}: ${err.message}`);
+    }
+  }
+
+  if (failures > 0) {
+    process.exitCode = 1;
+    console.error(`\n${failures} error(s). Check folder permissions.`);
+    return;
+  }
+
+  console.log("\nDone. Workflows removed.");
+}
+
+module.exports = { run };

package/src/lib/api.js

@@ -0,0 +1,38 @@
+"use strict";
+
+const path = require("node:path");
+require("dotenv").config({ path: path.join(__dirname, "../../.env") });
+
+const WORKER_URL = process.env.PREPCLI_API_URL || "https://api.prepcli.in";
+
+async function request(method, endpoint, body, token) {
+  const headers = { "Content-Type": "application/json" };
+  if (token) headers["Authorization"] = `Bearer ${token}`;
+
+  const options = { method, headers };
+  if (body) options.body = JSON.stringify(body);
+
+  let res;
+  try {
+    res = await fetch(`${WORKER_URL}${endpoint}`, options);
+  } catch {
+    throw new Error("Cannot reach prepcli server. Check your connection.");
+  }
+
+  let data;
+  try { data = await res.json(); } catch { data = {}; }
+
+  if (!res.ok) {
+    if (res.status === 401) throw new Error("session_expired");
+    throw new Error(data.error || "Server error");
+  }
+
+  return data;
+}
+
+module.exports = {
+  get:  (endpoint, token)        => request("GET",    endpoint, null, token),
+  post: (endpoint, body, token)  => request("POST",   endpoint, body, token),
+  put:  (endpoint, body, token)  => request("PUT",    endpoint, body, token),
+  del:  (endpoint, token)        => request("DELETE", endpoint, null, token),
+};

package/src/lib/config.js

@@ -0,0 +1,145 @@
+"use strict";
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const CONFIG_DIR  = path.join(os.homedir(), ".prepcli");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+const RC_FILE            = ".prepclirc";
+const KNOWN_EMAILS_FILE   = path.join(CONFIG_DIR, "known_emails.json");
+
+function readConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeConfig(data) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+
+function deleteConfig() {
+  try { fs.unlinkSync(CONFIG_FILE); } catch {}
+}
+
+function isLoggedIn() {
+  const cfg = readConfig();
+  return !!(cfg && cfg.access_token);
+}
+
+// Silently refresh the access token if it expires within 5 minutes.
+// Uses the stored refresh_token — user never needs to re-login unless
+// the refresh token itself expires (30 days, configurable in Supabase).
+async function refreshIfNeeded() {
+  const cfg = readConfig();
+  if (!cfg) return null;
+
+  const now = Math.floor(Date.now() / 1000);
+  const expiresIn = (cfg.expires_at || 0) - now;
+
+  // Still valid for more than 5 minutes — nothing to do
+  if (expiresIn > 300) return cfg;
+
+  if (!cfg.refresh_token) {
+    // No refresh token stored — force re-login
+    deleteConfig();
+    return null;
+  }
+
+  try {
+    const api = require("./api");
+    const data = await api.post("/auth/refresh", { refresh_token: cfg.refresh_token });
+
+    const updated = {
+      ...cfg,
+      access_token:  data.access_token,
+      refresh_token: data.refresh_token,
+      expires_at:    data.expires_at,
+    };
+    writeConfig(updated);
+    return updated;
+
+  } catch (err) {
+    if (err.message === "session_expired") {
+      deleteConfig();
+      return null;
+    }
+    // Network error — return existing config and let the next API call fail naturally
+    return cfg;
+  }
+}
+
+function requireLogin() {
+  if (!isLoggedIn()) {
+    console.error("Not logged in. Run: prepcli auth login");
+    process.exit(1);
+  }
+  return readConfig();
+}
+
+// Async version — use this in all commands that call Supabase.
+// Silently refreshes the token if needed before returning.
+async function requireLoginFresh() {
+  if (!isLoggedIn()) {
+    console.error("Not logged in. Run: prepcli auth login");
+    process.exit(1);
+  }
+  const cfg = await refreshIfNeeded();
+  if (!cfg) {
+    console.error("Session expired. Run: prepcli auth login");
+    process.exit(1);
+  }
+  return cfg;
+}
+
+function readRC() {
+  try {
+    return JSON.parse(fs.readFileSync(RC_FILE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeRC(data) {
+  fs.writeFileSync(RC_FILE, JSON.stringify(data, null, 2));
+}
+
+function requireRC() {
+  const rc = readRC();
+  if (!rc || !rc.project_id) {
+    console.error("No .prepclirc found. Run: npx prepcli init");
+    process.exit(1);
+  }
+  return rc;
+}
+
+
+function readKnownEmails() {
+  try {
+    return JSON.parse(fs.readFileSync(KNOWN_EMAILS_FILE, "utf8"));
+  } catch {
+    return [];
+  }
+}
+
+function addKnownEmail(email) {
+  const emails = readKnownEmails();
+  const normalized = email.toLowerCase();
+  if (!emails.includes(normalized)) {
+    emails.push(normalized);
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(KNOWN_EMAILS_FILE, JSON.stringify(emails, null, 2));
+  }
+}
+
+module.exports = {
+  readConfig, writeConfig, deleteConfig,
+  isLoggedIn, requireLogin, requireLoginFresh, refreshIfNeeded,
+  readRC, writeRC, requireRC,
+  readKnownEmails, addKnownEmail,
+  CONFIG_FILE, RC_FILE, KNOWN_EMAILS_FILE
+};

package/src/lib/decision.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const crypto   = require("node:crypto");
+const { execSync } = require("node:child_process");
+
+function generateId() {
+  return "dec-" + crypto.randomBytes(4).toString("hex");
+}
+
+function getCurrentCommit(cwd = process.cwd()) {
+  try {
+    return execSync("git rev-parse HEAD", { cwd, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+  } catch { return null; }
+}
+
+function getChangedFiles(cwd = process.cwd()) {
+  try {
+    const out = execSync("git diff --name-only HEAD~1 HEAD", { cwd, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+    return out.split("\n").filter(Boolean);
+  } catch { return []; }
+}
+
+function buildRecord({ id, session, commitHash, filesChanged, summary }) {
+  const date  = new Date().toISOString();
+  const turns = session.turns || [];
+
+  const workflows   = [...new Set(turns.map(t => t.workflow))].join(", ") || "unknown";
+  const turnLines   = turns.map((t, i) => `${i + 1}. [${t.workflow}]  ${t.what}`).join("\n") || "None recorded.";
+  const altLines    = turns.filter(t => t.why).map(t => `- ${t.why}`).join("\n") || "None recorded.";
+  const lastWhy     = turns.filter(t => t.why).pop()?.why || "Not recorded.";
+  const filesList   = (filesChanged || []).join(", ") || "unknown";
+
+  return `---
+id: ${id}
+commit: ${commitHash || "none"}
+date: ${date}
+workflow: ${workflows}
+files_changed: [${filesList}]
+ai_turn_count: ${turns.length}
+---
+
+## Summary
+${summary || turns.map(t => t.what).join("; ")}
+
+## Why This Approach
+${lastWhy}
+
+## What Was Tried and Ruled Out
+${altLines}
+
+## AI Session Turns
+${turnLines}
+`;
+}
+
+function recordFilename(id, date = new Date()) {
+  const d = date.toISOString().slice(0, 10).replace(/-/g, "");
+  return `${d}-${id}.md`;
+}
+
+module.exports = { generateId, getCurrentCommit, getChangedFiles, buildRecord, recordFilename };