threadit-cli 0.2.0

package/dist/git/log.js

@@ -0,0 +1,143 @@
+import { runGit } from './run.js';
+const US = '\x1f'; // unit separator — safe field delimiter inside one log line
+/**
+ * True when git ran and exited non-zero (it set a numeric exit status). A spawn
+ * failure — e.g. git not on PATH (ENOENT) — has no numeric status, so it is NOT
+ * swallowed; it rethrows. NOTE: an invalid repoDir also exits non-zero and yields
+ * the empty/absent result; callers needing a guaranteed repo should validate first.
+ */
+function gitProcessExited(err) {
+    return typeof err.status === 'number';
+}
+/** main's first-parent chain, newest-first. `sinceSha` (exclusive) bounds the bottom. */
+export function firstParentChain(repoDir, sinceSha) {
+    const range = sinceSha ? `${sinceSha}..HEAD` : 'HEAD';
+    let out;
+    try {
+        out = runGit(repoDir, ['log', '--first-parent', `--format=%H${US}%aI${US}%P`, range]);
+    }
+    catch (err) {
+        if (gitProcessExited(err))
+            return []; // no commits yet
+        throw err;
+    }
+    return out.split('\n').filter(Boolean).flatMap((line) => {
+        const [sha, authorDate, parents] = line.split(US);
+        if (sha === undefined || authorDate === undefined)
+            return []; // defensive: malformed line
+        const first = (parents ?? '').trim().split(/\s+/).filter(Boolean)[0];
+        return [{ sha, authorDate, parent: first ?? null }];
+    });
+}
+/** File content at a revision, or null if the file did not exist there. */
+export function fileBlobAt(repoDir, sha, relPath) {
+    try {
+        return runGit(repoDir, ['show', `${sha}:${relPath}`]);
+    }
+    catch (err) {
+        if (gitProcessExited(err))
+            return null;
+        throw err;
+    }
+}
+/**
+ * All commits on main's first-parent chain that carry ≥1 `Threadit: <id>` trailer.
+ * Uses git's trailer formatting (exact values, no regex fragility).
+ */
+export function trailerCommits(repoDir, sinceSha) {
+    const range = sinceSha ? `${sinceSha}..HEAD` : 'HEAD';
+    let out;
+    try {
+        out = runGit(repoDir, [
+            'log', '--first-parent',
+            `--format=%H${US}%aI${US}%(trailers:key=Threadit,valueonly,separator=%x1f)`,
+            range,
+        ]);
+    }
+    catch (err) {
+        if (gitProcessExited(err))
+            return [];
+        throw err;
+    }
+    const result = [];
+    for (const line of out.split('\n').filter(Boolean)) {
+        const [sha, authorDate, ...rest] = line.split(US);
+        if (sha === undefined || authorDate === undefined)
+            continue; // defensive: malformed line
+        const trailers = rest.filter(Boolean);
+        if (trailers.length)
+            result.push({ sha, authorDate, trailers });
+    }
+    return result;
+}
+/**
+ * The `Threadit: <id>` trailer values on ONE commit (by sha). Mirrors trailerCommits' git-trailer
+ * formatter (no regex). Returns [] when the commit carries none.
+ */
+export function trailersFor(repoDir, sha) {
+    let out;
+    try {
+        out = runGit(repoDir, [
+            'log', '-1',
+            `--format=%(trailers:key=Threadit,valueonly,separator=%x1f)`,
+            sha,
+        ]);
+    }
+    catch (err) {
+        if (gitProcessExited(err))
+            return [];
+        throw err;
+    }
+    return out.split('\n').join(US).split(US).map((s) => s.trim()).filter(Boolean);
+}
+/**
+ * True iff `maybeAncestor` is an ancestor of `descendant` on the current history. Uses
+ * `git merge-base --is-ancestor` (exit 0 = ancestor, exit 1 = NOT ancestor). `descendant` is always
+ * a valid ref here ('HEAD'), so a 128 means `maybeAncestor` itself is unresolvable — the stored sha
+ * was rewritten away AND pruned/gc'd (or this is a fresh clone). That is itself a divergence signal,
+ * so we treat 1 AND 128 as "not an ancestor" rather than crashing sync (the resulting full re-sync is
+ * idempotent — safe to over-trigger). A spawn failure (no numeric status) or any other code rethrows,
+ * mirroring the gitProcessExited discipline (distinguish a clean answer from a real error).
+ *
+ * Used by `sync` to detect a history REWRITE: if the server's last-synced sha is NO LONGER an
+ * ancestor of HEAD, the chain was rebased/amended/force-pushed and the server must purge + re-ingest.
+ */
+export function isAncestor(repoDir, maybeAncestor, descendant) {
+    try {
+        runGit(repoDir, ['merge-base', '--is-ancestor', maybeAncestor, descendant]);
+        return true; // exit 0 = ancestor
+    }
+    catch (err) {
+        const status = err.status;
+        // exit 1 = clean "not an ancestor"; exit 128 = `maybeAncestor` is no longer a valid commit
+        // (rewritten away + pruned, or a fresh clone) — also a rewrite/divergence signal. Both → false.
+        if (status === 1 || status === 128)
+            return false;
+        throw err; // spawn failure / unexpected code → real error
+    }
+}
+/** sha → subject line for main's first-parent chain. `sinceSha` (exclusive) bounds the bottom. */
+export function firstParentSubjects(repoDir, sinceSha) {
+    const range = sinceSha ? `${sinceSha}..HEAD` : 'HEAD';
+    let out;
+    try {
+        out = runGit(repoDir, ['log', '--first-parent', `--format=%H${US}%s`, range]);
+    }
+    catch (err) {
+        if (gitProcessExited(err))
+            return new Map();
+        throw err;
+    }
+    const m = new Map();
+    for (const line of out.split('\n').filter(Boolean)) {
+        const [sha, subject] = line.split(US);
+        if (sha !== undefined)
+            m.set(sha, subject ?? '');
+    }
+    return m;
+}
+/** Paths a single commit touched (root commit handled via --root; -z = NUL-terminated, quoting-safe). */
+export function touchedPaths(repoDir, sha) {
+    const out = runGit(repoDir, ['diff-tree', '--no-commit-id', '--name-only', '-r', '--root', '-z', sha]);
+    return out.split('\0').filter(Boolean);
+}

package/dist/git/reconcileCommits.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedThreaditFile, ReconcileCommit } from '@threadit/core';
+/** One ReconcileCommit per first-parent commit since `sinceSha` (exclusive). */
+export declare function gatherReconcileCommits(repoDir: string, file: ParsedThreaditFile, sinceSha?: string): ReconcileCommit[];

package/dist/git/reconcileCommits.js

@@ -0,0 +1,18 @@
+import { firstParentChain, firstParentSubjects, trailerCommits, touchedPaths } from './log.js';
+import { isOwnedPath } from '../paths.js';
+/** One ReconcileCommit per first-parent commit since `sinceSha` (exclusive). */
+export function gatherReconcileCommits(repoDir, file, sinceSha) {
+    const chain = firstParentChain(repoDir, sinceSha);
+    const subjects = firstParentSubjects(repoDir, sinceSha);
+    const trailered = new Set(trailerCommits(repoDir, sinceSha).map((tc) => tc.sha));
+    return chain.map((c) => {
+        const paths = touchedPaths(repoDir, c.sha);
+        return {
+            sha: c.sha,
+            authorDate: c.authorDate,
+            subject: subjects.get(c.sha) ?? '',
+            touchesCodePath: paths.some((p) => !isOwnedPath(p, file)),
+            hasNodeTrailer: trailered.has(c.sha),
+        };
+    });
+}

package/dist/git/run.d.ts

@@ -0,0 +1,2 @@
+/** Run git in `repoDir` with the given args (no shell). Throws on non-zero exit. */
+export declare function runGit(repoDir: string, args: string[]): string;

package/dist/git/run.js

@@ -0,0 +1,8 @@
+import { execFileSync } from 'node:child_process';
+/** Run git in `repoDir` with the given args (no shell). Throws on non-zero exit. */
+export function runGit(repoDir, args) {
+    return execFileSync('git', ['-C', repoDir, ...args], {
+        encoding: 'utf8',
+        maxBuffer: 64 * 1024 * 1024,
+    });
+}

package/dist/ids.d.ts

@@ -0,0 +1,4 @@
+import type { ParsedThreaditFile, ParsedInboxFile } from '@threadit/core';
+export declare function slugify(text: string): string;
+export declare function uniqueNodeId(file: ParsedThreaditFile, base: string): string;
+export declare function uniqueInboxId(inbox: ParsedInboxFile): string;

package/dist/ids.js

@@ -0,0 +1,25 @@
+export function slugify(text) {
+    return text.toLowerCase().trim()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 40) || 'node';
+}
+export function uniqueNodeId(file, base) {
+    const taken = new Set(file.nodes.map((n) => n.id));
+    if (!taken.has(base))
+        return base;
+    for (let i = 2;; i++) {
+        const candidate = `${base}-${i}`;
+        if (!taken.has(candidate))
+            return candidate;
+    }
+}
+export function uniqueInboxId(inbox) {
+    let max = 0;
+    for (const item of inbox.items) {
+        const m = /^i-(\d+)$/.exec(item.id);
+        if (m)
+            max = Math.max(max, Number(m[1]));
+    }
+    return `i-${max + 1}`;
+}

package/dist/inbox/recurrence.d.ts

@@ -0,0 +1,7 @@
+import type { InboxItem } from '@threadit/core';
+export declare function normalize(text: string): string;
+/** Dice coefficient over character bigrams of the normalized strings. */
+export declare function diceSimilarity(a: string, b: string): number;
+export declare const RECURRENCE_THRESHOLD = 0.5;
+/** Best open-item match for `text` above the threshold, else undefined. */
+export declare function matchOpenItem(items: InboxItem[], text: string): InboxItem | undefined;

package/dist/inbox/recurrence.js

@@ -0,0 +1,51 @@
+const STOPWORDS = new Set([
+    'the', 'and', 'a', 'an', 'when', 'it', 'to', 'or', 'of', 'on', 'in', 'we', 'should', 'also',
+    'need', 'needs', 'todo', 'note', 'that', 'this', 'for', 'is', 'be', 'add',
+]);
+// keep meaningful verbs; 'add' carries meaning, so it is NOT a stopword
+STOPWORDS.delete('add');
+export function normalize(text) {
+    return text.toLowerCase()
+        .replace(/[^a-z0-9\s]/g, ' ')
+        .split(/\s+/)
+        .filter((w) => w && !STOPWORDS.has(w))
+        .join(' ');
+}
+/** Dice coefficient over character bigrams of the normalized strings. */
+export function diceSimilarity(a, b) {
+    const bigrams = (s) => {
+        const m = new Map();
+        for (let i = 0; i < s.length - 1; i++) {
+            const bg = s.slice(i, i + 2);
+            m.set(bg, (m.get(bg) ?? 0) + 1);
+        }
+        return m;
+    };
+    const na = normalize(a).replace(/\s/g, ''), nb = normalize(b).replace(/\s/g, '');
+    if (na === nb)
+        return 1;
+    if (na.length < 2 || nb.length < 2)
+        return 0;
+    const ba = bigrams(na), bb = bigrams(nb);
+    let overlap = 0;
+    for (const [bg, count] of ba)
+        overlap += Math.min(count, bb.get(bg) ?? 0);
+    const total = [...ba.values()].reduce((s, n) => s + n, 0) + [...bb.values()].reduce((s, n) => s + n, 0);
+    return (2 * overlap) / total;
+}
+export const RECURRENCE_THRESHOLD = 0.5;
+/** Best open-item match for `text` above the threshold, else undefined. */
+export function matchOpenItem(items, text) {
+    let best;
+    let bestScore = 0;
+    for (const item of items) {
+        if (item.status !== 'open')
+            continue;
+        const score = diceSimilarity(item.text, text);
+        if (score >= RECURRENCE_THRESHOLD && score > bestScore) {
+            best = item;
+            bestScore = score;
+        }
+    }
+    return best;
+}

package/dist/install/atomicWrite.d.ts

@@ -0,0 +1,2 @@
+/** Write `content` to `path` atomically (temp + rename), creating parent dirs. */
+export declare function atomicWrite(path: string, content: string, mode?: number): void;

package/dist/install/atomicWrite.js

@@ -0,0 +1,9 @@
+import { writeFileSync, renameSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+/** Write `content` to `path` atomically (temp + rename), creating parent dirs. */
+export function atomicWrite(path, content, mode) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.threadit-tmp-${process.pid}`;
+    writeFileSync(tmp, content, mode !== undefined ? { encoding: 'utf8', mode } : 'utf8');
+    renameSync(tmp, path);
+}

package/dist/install/gitHooks.d.ts

@@ -0,0 +1,6 @@
+/** Resolve the repo's hooks dir (worktree/submodule/core.hooksPath-safe) to an absolute path. */
+export declare function resolveHooksDir(repoRoot: string): string;
+/** Install/refresh the threadit sync shims. Returns hooks that were warn-skipped (non-shell). */
+export declare function installGitHooks(repoRoot: string): {
+    skipped: string[];
+};

package/dist/install/gitHooks.js

@@ -0,0 +1,53 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync, existsSync } from 'node:fs';
+import { join, isAbsolute } from 'node:path';
+import { atomicWrite } from './atomicWrite.js';
+const BEGIN = '# >>> threadit >>>';
+const END = '# <<< threadit <<<';
+const EVENTS = {
+    'post-commit': 'threadit sync',
+    'post-merge': 'threadit sync',
+    'post-rewrite': 'threadit sync',
+    'post-checkout': 'threadit sync',
+};
+/** Resolve the repo's hooks dir (worktree/submodule/core.hooksPath-safe) to an absolute path. */
+export function resolveHooksDir(repoRoot) {
+    const out = execFileSync('git', ['-C', repoRoot, 'rev-parse', '--git-path', 'hooks'], { encoding: 'utf8' }).trim();
+    return isAbsolute(out) ? out : join(repoRoot, out);
+}
+function block(cmd) {
+    // background + detach; NO `exec` (exec replaces the shell, which contradicts the trailing `&`)
+    return `${BEGIN}\n${cmd} >/dev/null 2>&1 &\n${END}\n`;
+}
+function isShell(body) {
+    const first = body.split('\n', 1)[0] ?? '';
+    // No shebang → git runs it via sh. Otherwise chain only onto POSIX-compatible shells
+    // (they all understand `cmd >/dev/null 2>&1 &`). NOT fish/csh/tcsh — different syntax;
+    // those get warn-skipped rather than corrupted.
+    return !first.startsWith('#!') || /\b(sh|bash|dash|zsh|ksh|ash)\b/.test(first);
+}
+/** Install/refresh the threadit sync shims. Returns hooks that were warn-skipped (non-shell). */
+export function installGitHooks(repoRoot) {
+    const dir = resolveHooksDir(repoRoot);
+    const skipped = [];
+    for (const [event, cmd] of Object.entries(EVENTS)) {
+        const hookPath = join(dir, event);
+        if (!existsSync(hookPath)) {
+            atomicWrite(hookPath, `#!/bin/sh\n${block(cmd)}`, 0o755);
+            continue;
+        }
+        const body = readFileSync(hookPath, 'utf8');
+        if (body.includes(BEGIN)) {
+            // replace ALL marked blocks with one (collapse dups)
+            const stripped = body.replace(new RegExp(`${BEGIN}[\\s\\S]*?${END}\\n?`, 'g'), '');
+            atomicWrite(hookPath, stripped.replace(/\n*$/, '\n') + block(cmd), 0o755);
+        }
+        else if (isShell(body)) {
+            atomicWrite(hookPath, body.replace(/\n*$/, '\n') + block(cmd), 0o755);
+        }
+        else {
+            skipped.push(event);
+        }
+    }
+    return { skipped };
+}

package/dist/install/gitignore.d.ts

@@ -0,0 +1,4 @@
+/** Ensure `.threadit/` is git-ignored (idempotent; matches an existing equivalent line). */
+export declare function ensureGitignore(repoRoot: string): void;
+/** True iff git considers `relPath` ignored (post-condition check; never throws). */
+export declare function verifyIgnored(repoRoot: string, relPath: string): boolean;

package/dist/install/gitignore.js

@@ -0,0 +1,29 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { atomicWrite } from './atomicWrite.js';
+const ENTRY = '.threadit/';
+/** Ensure `.threadit/` is git-ignored (idempotent; matches an existing equivalent line). */
+export function ensureGitignore(repoRoot) {
+    const path = join(repoRoot, '.gitignore');
+    const existing = existsSync(path) ? readFileSync(path, 'utf8') : '';
+    const has = existing.split('\n').some((l) => {
+        const t = l.trim().replace(/^\//, '');
+        return t === ENTRY || t === '.threadit';
+    });
+    if (has)
+        return;
+    atomicWrite(path, existing.replace(/\n*$/, existing ? '\n' : '') + ENTRY + '\n');
+}
+/** True iff git considers `relPath` ignored (post-condition check; never throws). */
+export function verifyIgnored(repoRoot, relPath) {
+    // git check-ignore: exit 0 = ignored. Exit 1 (not ignored) AND 128 (git error) both throw →
+    // we return false, so a misconfig surfaces as a caller warning rather than a silent pass.
+    try {
+        execFileSync('git', ['-C', repoRoot, 'check-ignore', '-q', relPath]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/install/settings.d.ts

@@ -0,0 +1,7 @@
+/** The threadit-owned SessionStart commands (inline; call the installed binary). */
+export declare const THREADIT_COMMANDS: {
+    sessionStart: string[];
+    postToolUse: string[];
+};
+/** Merge threadit's hook groups into .claude/settings.json: own sentinel-tagged groups, foreign untouched. */
+export declare function mergeSettings(repoRoot: string): void;

package/dist/install/settings.js

@@ -0,0 +1,40 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { atomicWrite } from './atomicWrite.js';
+const BIN = 'threadit';
+/** The threadit-owned SessionStart commands (inline; call the installed binary). */
+export const THREADIT_COMMANDS = {
+    sessionStart: [
+        `${BIN} session --bump`,
+        `( ${BIN} sync >/dev/null 2>&1 & ) || true`,
+        `${BIN} hook capture-directive`,
+    ],
+    postToolUse: [`${BIN} hook validate`, `( ${BIN} sync --draft >/dev/null 2>&1 & ) || true`],
+};
+function cmd(command) { return { type: 'command', command }; }
+function threaditGroup(commands, matcher) {
+    return { ...(matcher ? { matcher } : {}), hooks: commands.map(cmd), _threadit: true };
+}
+/** Merge threadit's hook groups into .claude/settings.json: own sentinel-tagged groups, foreign untouched. */
+export function mergeSettings(repoRoot) {
+    const path = join(repoRoot, '.claude', 'settings.json');
+    let settings = {};
+    if (existsSync(path)) {
+        try {
+            settings = JSON.parse(readFileSync(path, 'utf8'));
+        }
+        catch {
+            throw new Error(`malformed JSON in ${path} — refusing to overwrite; fix it and re-run`);
+        }
+    }
+    settings.hooks ??= {};
+    for (const event of ['SessionStart', 'PostToolUse']) {
+        const groups = (settings.hooks[event] ?? []).filter((g) => !g._threadit); // drop our prior groups
+        if (event === 'SessionStart')
+            groups.push(threaditGroup(THREADIT_COMMANDS.sessionStart));
+        else
+            groups.push(threaditGroup(THREADIT_COMMANDS.postToolUse, 'Edit|Write|MultiEdit'));
+        settings.hooks[event] = groups;
+    }
+    atomicWrite(path, JSON.stringify(settings, null, 2) + '\n');
+}

package/dist/install/skills.d.ts

@@ -0,0 +1,11 @@
+export declare function globalSkillsDir(): string;
+/** Copy both bundled skills to the chosen location and stamp the version marker. */
+export declare function installSkills(repoRoot: string, location: 'global' | 'repo', version: string, globalOverride?: string): void;
+/**
+ * The installed pack version this repo is governed by:
+ *   - skillsDirOverride marker present → return it (for tests / explicit override)
+ *   - repo skills dir marker present → return it
+ *   - global skills dir marker present → return it
+ *   - else the repo config's packVersion (set at init) → undefined if none
+ */
+export declare function readInstalledPackVersion(repoRoot: string, skillsDirOverride?: string): string | undefined;

package/dist/install/skills.js

@@ -0,0 +1,38 @@
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { skillSourceDir } from '../assets.js';
+import { atomicWrite } from './atomicWrite.js';
+import { readConfig } from '../config.js';
+const MARKER = '.threadit-pack-version';
+export function globalSkillsDir() { return join(homedir(), '.claude', 'skills'); }
+function repoSkillsDir(repoRoot) { return join(repoRoot, '.claude', 'skills'); }
+/** Copy both bundled skills to the chosen location and stamp the version marker. */
+export function installSkills(repoRoot, location, version, globalOverride) {
+    const dest = location === 'global' ? (globalOverride ?? globalSkillsDir()) : repoSkillsDir(repoRoot);
+    const src = skillSourceDir();
+    const skillDirs = readdirSync(src, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    for (const name of skillDirs) {
+        const body = readFileSync(join(src, name, 'SKILL.md'), 'utf8');
+        atomicWrite(join(dest, name, 'SKILL.md'), body);
+    }
+    // Stamp the version marker beside the installed skills. `dest` already differentiates global
+    // (~/.claude/skills) from repo (.claude/skills), so one unconditional write covers both.
+    atomicWrite(join(dest, MARKER), version + '\n');
+}
+/**
+ * The installed pack version this repo is governed by:
+ *   - skillsDirOverride marker present → return it (for tests / explicit override)
+ *   - repo skills dir marker present → return it
+ *   - global skills dir marker present → return it
+ *   - else the repo config's packVersion (set at init) → undefined if none
+ */
+export function readInstalledPackVersion(repoRoot, skillsDirOverride) {
+    const candidates = [skillsDirOverride, repoSkillsDir(repoRoot), globalSkillsDir()].filter(Boolean);
+    for (const d of candidates) {
+        const m = join(d, MARKER);
+        if (existsSync(m))
+            return readFileSync(m, 'utf8').trim();
+    }
+    return readConfig(repoRoot).packVersion;
+}

package/dist/install/tty.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Prompt for a single choice, reading the answer from /dev/tty (works under `curl … | sh`,
+ * where stdin is the piped script). Returns `fallback` when /dev/tty can't be opened
+ * (CI / no controlling terminal) after printing a notice.
+ */
+export declare function promptChoice(question: string, choices: string[], fallback: string): string;

package/dist/install/tty.js

@@ -0,0 +1,39 @@
+import { openSync, readSync, closeSync, writeSync } from 'node:fs';
+/**
+ * Prompt for a single choice, reading the answer from /dev/tty (works under `curl … | sh`,
+ * where stdin is the piped script). Returns `fallback` when /dev/tty can't be opened
+ * (CI / no controlling terminal) after printing a notice.
+ */
+export function promptChoice(question, choices, fallback) {
+    let fd;
+    try {
+        fd = openSync('/dev/tty', 'r');
+    }
+    catch {
+        process.stderr.write(`${question} — no terminal; defaulting to "${fallback}".\n`);
+        return fallback;
+    }
+    try {
+        let tty;
+        try {
+            tty = openSync('/dev/tty', 'w');
+        }
+        catch {
+            tty = 2;
+        }
+        try {
+            writeSync(tty, `${question} [${choices.join('/')}] (${fallback}): `);
+            const buf = Buffer.alloc(256); // 256 B is ample for a single-word choice; overflow just falls back to default
+            const n = readSync(fd, buf, 0, 256, null);
+            const ans = buf.toString('utf8', 0, n).trim().toLowerCase();
+            return choices.includes(ans) ? ans : fallback;
+        }
+        finally {
+            if (tty !== 2)
+                closeSync(tty);
+        }
+    }
+    finally {
+        closeSync(fd);
+    }
+}

package/dist/mutate.d.ts

@@ -0,0 +1,6 @@
+import type { ParsedThreaditFile, ParsedInboxFile, RawNode } from '@threadit/core';
+/** Load → apply an in-place mutation to the parsed file → save (guarded by the engine gate). */
+export declare function mutate(path: string, fn: (file: ParsedThreaditFile) => void): ParsedThreaditFile;
+/** Load → apply an in-place mutation to the inbox → save. */
+export declare function mutateInbox(path: string, fn: (inbox: ParsedInboxFile) => void): ParsedInboxFile;
+export declare function findNode(file: ParsedThreaditFile, id: string): RawNode;

package/dist/mutate.js

@@ -0,0 +1,21 @@
+import { loadThreadit, saveThreadit, loadInbox, saveInbox } from './yaml/io.js';
+/** Load → apply an in-place mutation to the parsed file → save (guarded by the engine gate). */
+export function mutate(path, fn) {
+    const file = loadThreadit(path);
+    fn(file);
+    saveThreadit(path, file);
+    return file;
+}
+/** Load → apply an in-place mutation to the inbox → save. */
+export function mutateInbox(path, fn) {
+    const inbox = loadInbox(path);
+    fn(inbox);
+    saveInbox(path, inbox);
+    return inbox;
+}
+export function findNode(file, id) {
+    const node = file.nodes.find((n) => n.id === id);
+    if (!node)
+        throw new Error(`No node with id "${id}" in threadit.yml`);
+    return node;
+}

package/dist/paths.d.ts

@@ -0,0 +1,13 @@
+import type { ParsedThreaditFile } from '@threadit/core';
+export declare const THREADIT_FILE = "threadit.yml";
+export declare const INBOX_FILE = "threadit-inbox.yml";
+/**
+ * Resolve the repo root. If `explicit` (from --repo) is given, use it verbatim.
+ * Otherwise walk up from `cwd` to the nearest dir containing threadit.yml; if none,
+ * fall back to the nearest dir containing .git; if neither, use cwd.
+ */
+export declare function resolveRepoRoot(cwd?: string, explicit?: string): string;
+export declare function resolveThreaditPath(repoRootOrUndefined?: string): string;
+export declare function resolveInboxPath(repoRootOrUndefined?: string): string;
+/** A path is "Threadit-owned" iff it is the yml/inbox file or the project's narrative sidecar. */
+export declare function isOwnedPath(relPath: string, file: ParsedThreaditFile): boolean;

package/dist/paths.js

@@ -0,0 +1,46 @@
+import { existsSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+export const THREADIT_FILE = 'threadit.yml';
+export const INBOX_FILE = 'threadit-inbox.yml';
+/**
+ * Resolve the repo root. If `explicit` (from --repo) is given, use it verbatim.
+ * Otherwise walk up from `cwd` to the nearest dir containing threadit.yml; if none,
+ * fall back to the nearest dir containing .git; if neither, use cwd.
+ */
+export function resolveRepoRoot(cwd = process.cwd(), explicit) {
+    if (explicit)
+        return resolve(explicit);
+    let dir = resolve(cwd);
+    for (;;) {
+        if (existsSync(join(dir, THREADIT_FILE)))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // second pass for .git
+    dir = resolve(cwd);
+    for (;;) {
+        if (existsSync(join(dir, '.git')))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return resolve(cwd);
+}
+export function resolveThreaditPath(repoRootOrUndefined) {
+    return join(resolveRepoRoot(process.cwd(), repoRootOrUndefined), THREADIT_FILE);
+}
+export function resolveInboxPath(repoRootOrUndefined) {
+    return join(resolveRepoRoot(process.cwd(), repoRootOrUndefined), INBOX_FILE);
+}
+/** A path is "Threadit-owned" iff it is the yml/inbox file or the project's narrative sidecar. */
+export function isOwnedPath(relPath, file) {
+    if (relPath === THREADIT_FILE || relPath === INBOX_FILE)
+        return true;
+    const narrative = file.project.narrative;
+    return narrative !== undefined && relPath === narrative;
+}

package/dist/reconcileFormat.d.ts

@@ -0,0 +1,3 @@
+import type { Proposal } from '@threadit/core';
+/** Human-readable, class-grouped rendering of the unified proposal list. */
+export declare function formatProposals(proposals: Proposal[]): string;