resumecontext 0.1.0

package/dist/session.js

@@ -0,0 +1,36 @@
+import fs from "node:fs";
+import path from "node:path";
+import { credentialsFile } from "./paths.js";
+export function readCredentials() {
+    try {
+        const raw = fs.readFileSync(credentialsFile(), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed?.token === "string" && typeof parsed?.email === "string")
+            return parsed;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeCredentials(creds) {
+    const file = credentialsFile();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(creds, null, 2));
+}
+export function clearCredentials() {
+    try {
+        fs.unlinkSync(credentialsFile());
+    }
+    catch {
+        // already gone -- fine
+    }
+}
+/** Every command that needs a token calls this instead of reading
+ * credentials directly, so "not logged in" is always the same message. */
+export function requireCredentials() {
+    const creds = readCredentials();
+    if (!creds)
+        throw new Error("You're not logged in. Run `resumecontext auth` first.");
+    return creds;
+}

package/dist/syncCore.js

@@ -0,0 +1,108 @@
+/**
+ * The scan -> diff -> push mechanics shared between the interactive `sync`
+ * command (commands/sync.ts) and the background auto-sync daemon
+ * (daemon.ts) -- deliberately with no UI/spinner/console dependency, so
+ * each caller can wrap it however fits (a spinner with live progress text
+ * for one, silent logging for the other).
+ *
+ * Split into two steps rather than one function, specifically so a caller
+ * that only cares about "is there anything new" (the daemon, on every
+ * tick) can stop after scanForNewTurns without ever calling
+ * pushNewTurns -- that's what makes "only queries the backend if there are
+ * new turns" true: pushNewTurns, the only function here that talks to
+ * CloudApi, is simply never invoked when newTurns is empty.
+ */
+import { readSyncState, writeSyncState, sessionKey } from "./syncState.js";
+import { PUSH_BATCH_BYTES, PUSH_BATCH_SIZE, SOURCE_SETTLE_MS } from "./constants.js";
+/** Splits `allTurns` (in scan() order -- chronological within a session)
+ * into what's new since `turnCountBySession`, plus the counts to persist
+ * once a push actually succeeds. Turns are grouped by `agent:sessionId`
+ * first (see syncState.ts for why not bare sessionId), so interleaving
+ * between sessions in `allTurns` doesn't matter -- only each session's own
+ * turn count does. */
+function diffAgainstSyncState(allTurns, turnCountBySession, sessionMtimeMs, nowMs = Date.now()) {
+    const bySession = new Map();
+    for (const turn of allTurns) {
+        const key = sessionKey(turn.agent, turn.sessionId);
+        if (!bySession.has(key))
+            bySession.set(key, []);
+        bySession.get(key).push(turn);
+    }
+    const newTurns = [];
+    const updatedCounts = {};
+    for (const [key, turns] of bySession) {
+        const alreadySynced = turnCountBySession[key] ?? 0;
+        const mtime = sessionMtimeMs[key];
+        // A recently-touched source file may still be mid-write; withhold only
+        // the trailing turn so earlier turns keep syncing on every tick.
+        const hot = mtime !== undefined && nowMs - mtime < SOURCE_SETTLE_MS;
+        const syncable = hot ? Math.max(alreadySynced, turns.length - 1) : turns.length;
+        for (const turn of turns.slice(alreadySynced, syncable))
+            newTurns.push(turn);
+        updatedCounts[key] = syncable;
+    }
+    return { newTurns, updatedCounts };
+}
+/** Scans local history and diffs it against the last successful sync.
+ * Never touches the network -- everything here is local disk + a local
+ * state file, which is what lets this run on every daemon tick (see
+ * daemonService.ts's DAEMON_INTERVAL_MS) without costing a request when
+ * nothing changed. */
+export async function scanForNewTurns(localCapture, root, agentConfig, projectId) {
+    const { turns: allTurns, sessionMtimeMs } = await localCapture.scan(root, agentConfig);
+    const { turnCountBySession } = readSyncState(projectId);
+    const { newTurns, updatedCounts } = diffAgainstSyncState(allTurns, turnCountBySession, sessionMtimeMs);
+    return { allTurns, newTurns, updatedCounts };
+}
+/**
+ * Splits turns into request-sized batches, bounded by BYTES as well as count.
+ *
+ * Count alone was the bound and it is not one: a batch of 500 turns is about
+ * 1MB of ordinary conversation and several hundred MB if it happens to catch
+ * a few large tool outputs. See PUSH_BATCH_BYTES.
+ *
+ * An oversized single turn is emitted alone rather than dropped or split:
+ * splitting it would change its content hash and corrupt the transcript, and
+ * the server rejects what it cannot accept.
+ */
+export function batchTurns(turns) {
+    const batches = [];
+    let batch = [];
+    let bytes = 0;
+    for (const turn of turns) {
+        const size = JSON.stringify(turn).length;
+        if (batch.length > 0 && (batch.length >= PUSH_BATCH_SIZE || bytes + size > PUSH_BATCH_BYTES)) {
+            batches.push(batch);
+            batch = [];
+            bytes = 0;
+        }
+        batch.push(turn);
+        bytes += size;
+    }
+    if (batch.length > 0)
+        batches.push(batch);
+    return batches;
+}
+/** Pushes `newTurns` in batches and advances the local sync-state cursor
+ * after each batch -- so a push that fails partway only retries the
+ * remaining batches, not everything already accepted (see syncState.ts).
+ * Callers should skip calling this entirely when `newTurns` is empty; there
+ * is deliberately no short-circuit inside it, so an empty push is a caller
+ * bug, not a silent no-op that masks one. */
+export async function pushNewTurns(cloudApi, token, projectId, newTurns) {
+    const runningCounts = { ...readSyncState(projectId).turnCountBySession };
+    let accepted = 0;
+    for (const batch of batchTurns(newTurns)) {
+        const result = await cloudApi.pushTurns(token, projectId, batch);
+        accepted += result.accepted;
+        for (const turn of batch) {
+            const key = sessionKey(turn.agent, turn.sessionId);
+            runningCounts[key] = (runningCounts[key] ?? 0) + 1;
+        }
+        // Persist after every batch, not just at the end -- if a later batch in
+        // this same call fails, the turns already accepted by the backend stay
+        // marked as synced instead of being re-uploaded wholesale next time.
+        writeSyncState(projectId, { turnCountBySession: runningCounts });
+    }
+    return { accepted };
+}

package/dist/syncState.js

@@ -0,0 +1,51 @@
+/**
+ * Local, per-project record of how much of each coding-agent session has
+ * already been pushed to the cloud -- one turn count per session, treated
+ * like a consumer offset into that session's turn list. `LocalCapture.scan`
+ * always returns a session's turns in chronological order (ingest/ sorts
+ * the whole project's turns by timestamp before writing them out, and that
+ * sort is stable, so a session's own turns never reorder between runs --
+ * only grow), so "already synced the first N" is a safe, simple cursor:
+ * next time, skip the first N turns of that session and send the rest.
+ *
+ * Sessions are keyed by `agent:sessionId`, not bare sessionId -- each agent
+ * (claude-code, cursor, codex, ...) generates its own session ids
+ * independently, with no coordination between them, so a bare sessionId
+ * isn't guaranteed unique across agents. Namespacing by agent rules that
+ * out structurally instead of relying on it being unlikely in practice.
+ *
+ * This lets `sync` upload only what's new since the last successful sync
+ * instead of re-pushing a project's entire history every time. The server
+ * still dedupes idempotently on top of this (see backend/projects/store.ts's
+ * pushTurns) -- that's the backstop for a push that partially failed, a
+ * wiped `~/.resumecontext`, or syncing the same project from two machines;
+ * this file is what makes the common case cheap.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { syncStateFile } from "./paths.js";
+/** The one place `agent:sessionId` keys get constructed, so sync.ts's
+ * grouping and this file's stored keys can never drift apart in format. */
+export function sessionKey(agent, sessionId) {
+    return `${agent}:${sessionId}`;
+}
+function emptyState() {
+    return { turnCountBySession: {} };
+}
+export function readSyncState(projectId) {
+    try {
+        const raw = fs.readFileSync(syncStateFile(projectId), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed.turnCountBySession === "object")
+            return parsed;
+        return emptyState();
+    }
+    catch {
+        return emptyState();
+    }
+}
+export function writeSyncState(projectId, state) {
+    const file = syncStateFile(projectId);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(state, null, 2));
+}

package/dist/ui.js

@@ -0,0 +1,289 @@
+/**
+ * Every command routes its output through here rather than calling
+ * console.log/@clack/prompts directly -- keeps the visual language (colors,
+ * symbols, wording) consistent across commands, and gives tests one place to
+ * silence output (see test/helpers.ts) instead of mocking console per-file.
+ */
+import * as clack from "@clack/prompts";
+import { Prompt, isCancel } from "@clack/core";
+import chalk from "chalk";
+import figlet from "figlet";
+import gradient from "gradient-string";
+const brand = gradient(["#7C3AED", "#06B6D4"]); // violet -> cyan
+/** The big ASCII banner shown at the start of `init`. Falls back to a
+ * simpler styled line on narrow terminals so it never wraps into a mess. */
+export function printBanner() {
+    const columns = process.stdout.columns ?? 80;
+    const text = columns >= 70 ? "ResumeContext" : "RESUMECONTEXT";
+    const font = columns >= 70 ? "Slant" : "Small";
+    try {
+        const art = figlet.textSync(text, { font });
+        console.log(brand.multiline(art));
+    }
+    catch {
+        // figlet font data missing/unsupported terminal -- degrade gracefully,
+        // this is decoration, never something worth crashing a command over.
+        console.log(brand("ResumeContext"));
+    }
+    console.log(chalk.dim("  resumecontext.com — shared context for coding agents\n"));
+}
+export function intro(title) {
+    clack.intro(chalk.bgCyan.black(` ${title} `));
+}
+export function outro(message) {
+    clack.outro(chalk.green(message));
+}
+export const log = {
+    info: (msg) => clack.log.info(msg),
+    success: (msg) => clack.log.success(chalk.green(msg)),
+    warn: (msg) => clack.log.warn(chalk.yellow(msg)),
+    step: (msg) => clack.log.step(msg),
+};
+export function spinner() {
+    return clack.spinner();
+}
+/** Runs `fn` under a spinner, always stopping it -- with `stopMessage` on
+ * success, or a "Failed." message before rethrowing on error. A bare
+ * `spin.start()`/`spin.stop()` pair left the spinner's interval running
+ * forever on a thrown error (the process would hang indefinitely instead of
+ * exiting with the error), so every command routes spinner usage through
+ * here rather than managing start/stop by hand. */
+export async function withSpinner(startMessage, stopMessage, fn) {
+    const spin = spinner();
+    spin.start(startMessage);
+    try {
+        const result = await fn();
+        spin.stop(stopMessage);
+        return result;
+    }
+    catch (err) {
+        spin.stop("Failed.");
+        throw err;
+    }
+}
+export async function confirm(message, initialValue = true) {
+    const result = await clack.confirm({ message, initialValue });
+    if (clack.isCancel(result)) {
+        clack.cancel("Cancelled.");
+        process.exit(1);
+    }
+    return result;
+}
+export async function promptText(message, opts) {
+    const result = await clack.text({
+        message,
+        placeholder: opts?.placeholder,
+        initialValue: opts?.initialValue,
+        validate: opts?.validate,
+    });
+    if (clack.isCancel(result)) {
+        clack.cancel("Cancelled.");
+        process.exit(1);
+    }
+    return result;
+}
+/**
+ * The picker behind `multiselect`. Built on @clack/core's base Prompt
+ * rather than its MultiSelectPrompt because both of that class's key
+ * bindings are wrong for this UI: it toggles on SPACE and submits on
+ * ENTER, whereas Enter is the key people actually reach for to pick the
+ * thing under the cursor. So here Enter toggles, space does nothing, and
+ * submitting is its own explicitly-labelled row at the bottom of the list
+ * -- reachable by the same arrow-keys-then-Enter motion as everything
+ * else, so there's exactly one interaction to learn.
+ *
+ * The extra row lives at index `options.length`, one past the real
+ * options, which is what `onContinueRow` tests for.
+ */
+class TogglePicker extends Prompt {
+    options;
+    cursor = 0;
+    constructor(opts) {
+        // trackValue: false -- this prompt reads keystrokes as commands, not as
+        // text being typed into a value.
+        super(opts, false);
+        this.options = opts.options;
+        this.value = [...opts.initialValues];
+        const rowCount = this.options.length + 1; // + the Continue row
+        this.on("cursor", (key) => {
+            // Deliberately no "space" case: toggling is Enter-only here.
+            if (key === "up" || key === "left")
+                this.cursor = (this.cursor - 1 + rowCount) % rowCount;
+            else if (key === "down" || key === "right")
+                this.cursor = (this.cursor + 1) % rowCount;
+        });
+        this.on("key", (_char, key) => {
+            // Fires before the base class checks _shouldSubmit, so an Enter on an
+            // option row toggles it and then declines to submit.
+            if (key?.name === "return" && !this.onContinueRow)
+                this.toggleCurrent();
+        });
+    }
+    get onContinueRow() {
+        return this.cursor === this.options.length;
+    }
+    get selected() {
+        return this.value ?? [];
+    }
+    toggleCurrent() {
+        const target = this.options[this.cursor].value;
+        this.value = this.selected.includes(target)
+            ? this.selected.filter((v) => v !== target)
+            : [...this.selected, target];
+    }
+    /** Enter only submits from the Continue row; everywhere else it toggles. */
+    _shouldSubmit() {
+        return this.onContinueRow;
+    }
+}
+/**
+ * A multi-select with a deliberately loud rendering and an explicit
+ * Continue row, rather than @clack/prompts' stock `multiselect`. The stock
+ * one distinguishes on/off only by a green vs. plain checkbox glyph, which
+ * is easy to misread -- and tells you nothing when every row happens to be
+ * selected, since there's no unselected row to contrast against. Here each
+ * row spells out its state in words ("will sync" / "skipped"), so the list
+ * is unambiguous at a glance and stays unambiguous when uniform.
+ */
+export async function multiselect(message, options, initialValues = [], 
+/** Defaults to the real stdin/stdout. Overridable so tests can drive the
+ * prompt with scripted keystrokes -- this is a hand-written interaction,
+ * so its toggle/submit behavior needs to be verifiable, not just its
+ * rendering. */
+io = {}) {
+    const BAR = chalk.gray("│");
+    const labelWidth = Math.max(...options.map((o) => o.label.length));
+    const orderedSelection = (chosen) => options.filter((o) => chosen.has(o.value)).map((o) => o.value);
+    const prompt = new TogglePicker({
+        options,
+        initialValues,
+        input: io.input,
+        output: io.output,
+        render() {
+            const chosen = new Set(this.selected);
+            if (this.state === "submit") {
+                const picked = options.filter((o) => chosen.has(o.value)).map((o) => o.label);
+                const summary = picked.length > 0 ? chalk.green(picked.join(", ")) : chalk.yellow("none");
+                return `${chalk.green("◇")}  ${message}\n${BAR}  ${summary}`;
+            }
+            if (this.state === "cancel") {
+                return `${chalk.red("■")}  ${message}\n${BAR}  ${chalk.red("Cancelled.")}`;
+            }
+            const rows = options.map((opt, i) => {
+                const on = chosen.has(opt.value);
+                const active = i === this.cursor;
+                const pointer = active ? chalk.cyan("❯") : " ";
+                const box = on ? chalk.green.bold("[✔]") : chalk.dim("[ ]");
+                const state = on ? chalk.green.bold("will sync") : chalk.dim("skipped  ");
+                const label = on ? chalk.bold(opt.label.padEnd(labelWidth)) : chalk.dim(opt.label.padEnd(labelWidth));
+                const hint = opt.hint ? chalk.dim(` · ${opt.hint}`) : "";
+                return `${BAR}  ${pointer} ${box}  ${label}  ${state}${hint}`;
+            });
+            const count = chosen.size;
+            const continueText = count > 0 ? `Continue with ${count} selected` : "Continue without syncing any agent";
+            const continueRow = this.onContinueRow
+                ? `${BAR}  ${chalk.cyan("❯")} ${chalk.bgCyan.black(` ${continueText} `)}`
+                : `${BAR}    ${chalk.dim(continueText)}`;
+            const help = this.onContinueRow
+                ? "↑/↓ to move · enter to finish"
+                : "↑/↓ to move · enter to select / unselect";
+            return [
+                `${chalk.cyan("◆")}  ${message}`,
+                ...rows,
+                `${BAR}`,
+                continueRow,
+                `${BAR}`,
+                `${BAR}  ${chalk.dim(help)}`,
+            ].join("\n");
+        },
+    });
+    const result = await prompt.prompt();
+    if (isCancel(result)) {
+        clack.cancel("Cancelled.");
+        process.exit(1);
+    }
+    // Return in the order the options were declared, not the order they were
+    // clicked, so callers get a stable result.
+    return orderedSelection(new Set((result ?? [])));
+}
+/** A single-choice menu: arrows move, Enter picks the highlighted row.
+ * Same motion as `multiselect`, so the two read as one interaction model. */
+class MenuPrompt extends Prompt {
+    rows;
+    cursor = 0;
+    constructor(opts) {
+        super(opts, false);
+        this.rows = opts.rows;
+        this.cursor = Math.max(this.rows.findIndex((r) => r.value === opts.cursorAt), 0);
+        this.value = this.rows[this.cursor]?.value;
+        this.on("cursor", (key) => {
+            const n = this.rows.length;
+            if (key === "up" || key === "left")
+                this.cursor = (this.cursor - 1 + n) % n;
+            else if (key === "down" || key === "right")
+                this.cursor = (this.cursor + 1) % n;
+            this.value = this.rows[this.cursor]?.value;
+        });
+    }
+}
+/**
+ * Prompts once and resolves with the chosen row's value. Callers that need
+ * a multi-step screen (add an item, remove one, move on) drive it in a
+ * loop, re-rendering with updated rows each time -- see agentConfig.ts's
+ * directory editor. Intermediate rounds render nothing on submit so the
+ * loop doesn't leave a stack of near-identical frames behind; only the
+ * caller's own final summary remains.
+ */
+export async function menu(message, rows, opts = {}) {
+    const BAR = chalk.gray("│");
+    const prompt = new MenuPrompt({
+        rows,
+        cursorAt: opts.cursorAt,
+        input: opts.io?.input,
+        output: opts.io?.output,
+        render() {
+            if (this.state === "submit") {
+                if (!opts.keepFrame)
+                    return "";
+                const picked = rows.find((r) => r.value === this.value);
+                return `${chalk.green("◇")}  ${message}\n${BAR}  ${chalk.green(picked?.label ?? "")}`;
+            }
+            if (this.state === "cancel") {
+                return `${chalk.red("■")}  ${message}\n${BAR}  ${chalk.red("Cancelled.")}`;
+            }
+            const lines = rows.flatMap((row, i) => {
+                const active = i === this.cursor;
+                const pointer = active ? chalk.cyan("❯") : " ";
+                const base = row.tone === "warn" ? chalk.yellow : row.tone === "action" ? chalk.cyan : (s) => s;
+                const label = active ? chalk.bold(base(row.label)) : row.tone === "item" ? base(row.label) : chalk.dim(base(row.label));
+                const hint = row.hint ? chalk.dim(`  ${row.hint}`) : "";
+                const line = `${BAR}  ${pointer} ${label}${hint}`;
+                return row.separated ? [`${BAR}`, line] : [line];
+            });
+            const help = rows[this.cursor]?.help ?? "↑/↓ to move · enter to choose";
+            return [`${chalk.cyan("◆")}  ${message}`, ...lines, `${BAR}`, `${BAR}  ${chalk.dim(help)}`].join("\n");
+        },
+    });
+    const result = await prompt.prompt();
+    if (isCancel(result)) {
+        clack.cancel("Cancelled.");
+        process.exit(1);
+    }
+    return result;
+}
+/** Renders a small aligned table -- used by `members`. Not a dependency,
+ * just enough padding logic for the one shape this CLI needs. */
+export function table(rows, headers) {
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
+    const line = (cells) => cells.map((c, i) => c.padEnd(widths[i])).join("  ");
+    const sep = widths.map((w) => "─".repeat(w)).join("  ");
+    return [chalk.bold(line(headers)), chalk.dim(sep), ...rows.map((r) => line(r))].join("\n");
+}
+/** Renders any thrown value consistently: just its message, in red. No
+ * custom error class or hint field -- every throw site in this CLI writes
+ * a message meant to be shown to the user as-is, so this is the ONLY place
+ * that presentation is decided. */
+export function printError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    clack.log.error(chalk.red(message));
+}

package/dist/utils.js

@@ -0,0 +1,41 @@
+/**
+ * Small, generic, domain-independent helpers shared across otherwise
+ * unrelated files -- nothing here knows about projects, the cloud API, or
+ * CLI output. If a function needs to know about any of those, it belongs
+ * in the file that owns that concept, not here.
+ */
+import os from "node:os";
+import path from "node:path";
+/** Expands a leading `~` and resolves to an absolute path. Paths typed into
+ * an interactive prompt never go through the shell, so `~/.claude/projects`
+ * would otherwise be taken literally as a directory named "~". */
+export function resolveUserPath(input) {
+    const trimmed = input.trim();
+    const expanded = trimmed === "~" || trimmed.startsWith("~/") ? path.join(os.homedir(), trimmed.slice(1)) : trimmed;
+    return path.resolve(expanded);
+}
+/** Order-preserving de-duplication. */
+export function unique(values) {
+    return [...new Set(values)];
+}
+export function slugify(dirPath) {
+    return dirPath
+        .replace(/\/+$/, "")
+        .replace(/[^A-Za-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// The WHATWG HTML Living Standard's regex for <input type="email"> --
+// what browsers themselves use to validate the "email" input type. Chosen
+// over a hand-rolled pattern because it's the actual, well-documented
+// standard rather than something arbitrary: permissive enough not to
+// reject real addresses (dots, plus-addressing, hyphenated domains), while
+// still rejecting obviously-malformed input. This is a format check only --
+// it can't confirm the address is real, so it stays paired with real
+// server-side validation (see fakeBackendServer.ts), not a replacement for it.
+const EMAIL_RE = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+export function isValidEmail(email) {
+    return EMAIL_RE.test(email);
+}

package/dist/version.js

@@ -0,0 +1,43 @@
+/**
+ * Single source of truth for "what version of this CLI is this". Reads
+ * package.json's version field rather than hardcoding it a second time --
+ * used both for `resumecontext --version` and to detect a stale registered
+ * daemon service (see daemonService.ts): embedding this in the generated
+ * plist/unit text means an in-place version upgrade (same install path, new
+ * file contents) is enough to force the service to be reinstalled, even
+ * when nothing about the launch command itself changed.
+ *
+ * Walks upward from this file's own location to find the nearest
+ * package.json, rather than assuming a fixed relative depth -- that depth
+ * differs between `tsx src/index.ts` (dev) and the compiled `dist/src/*.js`
+ * (prod, one directory deeper because tsc nests `src` under `dist`), and
+ * walking up is correct under both without needing to know which one this
+ * is.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function findPackageJson(startDir) {
+    let dir = startDir;
+    while (true) {
+        const candidate = path.join(dir, "package.json");
+        if (fs.existsSync(candidate))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            throw new Error("Could not find package.json above " + startDir);
+        dir = parent;
+    }
+}
+let cached = null;
+/** Cached after the first call -- the version can't change during a single
+ * process's lifetime, and this may be read on every daemon tick's install
+ * check. */
+export function cliVersion() {
+    if (cached !== null)
+        return cached;
+    const packageJsonPath = findPackageJson(path.dirname(fileURLToPath(import.meta.url)));
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    cached = pkg.version;
+    return cached;
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "resumecontext",
+  "version": "0.1.0",
+  "description": "Sync your coding-agent sessions to a shared archive your agents can search over MCP.",
+  "keywords": [
+    "mcp",
+    "coding-agent",
+    "claude-code",
+    "cursor",
+    "codex",
+    "opencode",
+    "context",
+    "memory",
+    "cli"
+  ],
+  "homepage": "https://resumecontext.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rishabhpoddar/resumecontext.git",
+    "directory": "cli"
+  },
+  "bugs": {
+    "url": "https://github.com/rishabhpoddar/resumecontext/issues"
+  },
+  "license": "UNLICENSED",
+  "type": "module",
+  "bin": {
+    "resumecontext": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "tsx src/dev.ts",
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "release": "./scripts/release.sh",
+    "release:dry": "./scripts/release.sh --dry-run"
+  },
+  "dependencies": {
+    "@clack/core": "^1.4.3",
+    "@clack/prompts": "^1.7.0",
+    "axios": "^1.19.0",
+    "chalk": "^6.0.0",
+    "commander": "^15.0.0",
+    "figlet": "^1.11.4",
+    "gradient-string": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/figlet": "^1.7.0",
+    "@types/gradient-string": "^1.1.6",
+    "@types/node": "^26.3.0",
+    "tsx": "^4.23.12",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.11"
+  }
+}