harnery 0.0.1 → 0.2.0

package/dist/commands/sync.js

@@ -0,0 +1,275 @@
+/**
+ * `harn sync`: keep a curated subset of `.harnery/` live across machines
+ * via rclone (typically a Google Drive remote, but any rclone remote works).
+ *
+ * Scope: a deliberately small set of file types: durable identities,
+ * archived scratchpads, council manifests. The high-churn machine-local
+ * stuff (events.ndjson, .pid-map/, active/, .last-intent.*) stays put.
+ *
+ * Subcommands:
+ *   init:    interactive: `rclone config` walks through Google OAuth, then
+ *            we record the chosen remote name in ~/.config/harnery/sync.json
+ *   status:  diff local vs remote (rclone check --one-way)
+ *   push:    local to remote (rclone copy)
+ *   pull:    remote to local (rclone copy)
+ *   list:    show what's in the remote
+ *
+ * Power users override via env (HARNERY_SYNC_REMOTE, HARNERY_SYNC_PREFIX) or by
+ * editing the config file. Like `harn backup`, this surfaces rclone rather
+ * than abstracting it.
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+// What we sync. Anything matching one of these (relative to .harnery/) is
+// considered part of the sync set. Everything else stays local-only.
+const SYNC_PATHS = ["identities/", "scratch/archived/", "councils/"];
+function configPath() {
+    return path.join(os.homedir(), ".config", "harnery", "sync.json");
+}
+function loadConfig() {
+    const envRemote = process.env.HARNERY_SYNC_REMOTE;
+    const envPrefix = process.env.HARNERY_SYNC_PREFIX ?? "harnery";
+    if (envRemote)
+        return { remote: envRemote, prefix: envPrefix };
+    const p = configPath();
+    if (!existsSync(p))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(p, "utf-8"));
+        if (typeof parsed.remote === "string" && typeof parsed.prefix === "string") {
+            return parsed;
+        }
+    }
+    catch {
+        /* fall through */
+    }
+    return null;
+}
+function saveConfig(cfg) {
+    const p = configPath();
+    mkdirSync(path.dirname(p), { recursive: true });
+    writeFileSync(p, `${JSON.stringify(cfg, null, 2)}\n`, "utf-8");
+}
+function findHarneryDir() {
+    let dir = process.cwd();
+    for (let i = 0; i < 8; i++) {
+        if (existsSync(path.join(dir, ".harnery"))) {
+            return path.join(dir, ".harnery");
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+function checkRclone(emit) {
+    const r = spawnSync("rclone", ["version"], { encoding: "utf-8" });
+    if (r.status !== 0) {
+        emit.error({
+            code: "rclone_missing",
+            message: "rclone is not on PATH",
+            hint: "Install via `curl https://rclone.org/install.sh | sudo bash` or " +
+                "https://rclone.org/downloads/",
+        });
+        return false;
+    }
+    return true;
+}
+function listRemotes() {
+    const r = spawnSync("rclone", ["listremotes"], { encoding: "utf-8" });
+    if (r.status !== 0)
+        return [];
+    return r.stdout
+        .split("\n")
+        .map((s) => s.trim().replace(/:$/, ""))
+        .filter(Boolean);
+}
+function ensureConfig(emit) {
+    const cfg = loadConfig();
+    if (cfg)
+        return cfg;
+    emit.error({
+        code: "not_initialized",
+        message: "no harn sync config",
+        hint: "Run `harn sync init` to pick an rclone remote and record it.",
+    });
+    return null;
+}
+function buildRcloneArgs(cfg, harneryDir, direction) {
+    const local = harneryDir;
+    const remote = `${cfg.remote}:${cfg.prefix}`;
+    return direction === "push" ? { local, remote } : { local, remote };
+}
+function syncIncludeFlags() {
+    const out = [];
+    for (const p of SYNC_PATHS) {
+        out.push("--include", `/${p}**`);
+    }
+    return out;
+}
+export function registerSyncCommand(program, emit) {
+    const sync = program
+        .command("sync")
+        .description("Cross-machine sync of curated .harnery/ subset (identities, archived " +
+        "scratchpads, council manifests) via rclone. Google Drive is the " +
+        "expected remote; any rclone backend works.");
+    sync
+        .command("init")
+        .description("Pick the rclone remote to sync against. Run `rclone config` first " +
+        "if you haven't set up a remote yet (harnery doesn't wrap the OAuth " +
+        "flow; rclone's own config wizard handles that).")
+        .option("--remote <name>", "Use this rclone remote (skips the picker)")
+        .option("--prefix <path>", "Subpath under the remote root (default: harnery)", "harnery")
+        .action((opts) => {
+        if (!checkRclone(emit)) {
+            emit.setExitCode(1);
+            return;
+        }
+        const remotes = listRemotes();
+        if (remotes.length === 0) {
+            emit.error({
+                code: "no_remotes",
+                message: "rclone has no remotes configured",
+                hint: "Run `rclone config` to add one (Google Drive: choose `drive`).",
+            });
+            emit.setExitCode(1);
+            return;
+        }
+        let remote = opts.remote;
+        if (!remote) {
+            if (remotes.length === 1) {
+                remote = remotes[0];
+            }
+            else {
+                emit.error({
+                    code: "remote_required",
+                    message: `multiple rclone remotes; pass --remote <name>; available: ${remotes.join(", ")}`,
+                });
+                emit.setExitCode(1);
+                return;
+            }
+        }
+        if (!remotes.includes(remote)) {
+            emit.error({
+                code: "unknown_remote",
+                message: `remote "${remote}" not in rclone config (have: ${remotes.join(", ")})`,
+            });
+            emit.setExitCode(1);
+            return;
+        }
+        saveConfig({ remote, prefix: opts.prefix });
+        emit.text(`recorded: remote=${remote}  prefix=${opts.prefix}`);
+        emit.text(`config: ${configPath()}`);
+    });
+    sync
+        .command("status")
+        .description("Diff local .harnery/ subset vs the remote (rclone check --one-way).")
+        .option("--dry-run", "Same as no-op for status; kept for symmetry with push/pull")
+        .option("--verbose", "Pass -v to rclone")
+        .action((opts) => {
+        if (!checkRclone(emit)) {
+            emit.setExitCode(1);
+            return;
+        }
+        const cfg = ensureConfig(emit);
+        if (!cfg) {
+            emit.setExitCode(1);
+            return;
+        }
+        const hDir = findHarneryDir();
+        if (!hDir) {
+            emit.error({ code: "no_harnery", message: "no .harnery/ found above cwd" });
+            emit.setExitCode(1);
+            return;
+        }
+        const { local, remote } = buildRcloneArgs(cfg, hDir, "push");
+        const args = ["check", local, remote, "--one-way", ...syncIncludeFlags()];
+        if (opts.verbose)
+            args.push("-v");
+        const r = spawnSync("rclone", args, { stdio: "inherit" });
+        emit.setExitCode(r.status ?? 1);
+    });
+    sync
+        .command("push")
+        .description("Push local .harnery/ subset to the remote (rclone copy).")
+        .option("--dry-run", "Pass --dry-run to rclone")
+        .option("--verbose", "Pass -v to rclone")
+        .action((opts) => {
+        if (!checkRclone(emit)) {
+            emit.setExitCode(1);
+            return;
+        }
+        const cfg = ensureConfig(emit);
+        if (!cfg) {
+            emit.setExitCode(1);
+            return;
+        }
+        const hDir = findHarneryDir();
+        if (!hDir) {
+            emit.error({ code: "no_harnery", message: "no .harnery/ found above cwd" });
+            emit.setExitCode(1);
+            return;
+        }
+        const { local, remote } = buildRcloneArgs(cfg, hDir, "push");
+        const args = ["copy", local, remote, ...syncIncludeFlags()];
+        if (opts.dryRun)
+            args.push("--dry-run");
+        if (opts.verbose)
+            args.push("-v");
+        const r = spawnSync("rclone", args, { stdio: "inherit" });
+        emit.setExitCode(r.status ?? 1);
+    });
+    sync
+        .command("pull")
+        .description("Pull the remote subset down into local .harnery/ (rclone copy).")
+        .option("--dry-run", "Pass --dry-run to rclone")
+        .option("--verbose", "Pass -v to rclone")
+        .action((opts) => {
+        if (!checkRclone(emit)) {
+            emit.setExitCode(1);
+            return;
+        }
+        const cfg = ensureConfig(emit);
+        if (!cfg) {
+            emit.setExitCode(1);
+            return;
+        }
+        const hDir = findHarneryDir();
+        if (!hDir) {
+            emit.error({ code: "no_harnery", message: "no .harnery/ found above cwd" });
+            emit.setExitCode(1);
+            return;
+        }
+        const { local, remote } = buildRcloneArgs(cfg, hDir, "pull");
+        const args = ["copy", remote, local, ...syncIncludeFlags()];
+        if (opts.dryRun)
+            args.push("--dry-run");
+        if (opts.verbose)
+            args.push("-v");
+        const r = spawnSync("rclone", args, { stdio: "inherit" });
+        emit.setExitCode(r.status ?? 1);
+    });
+    sync
+        .command("list")
+        .description("List what's currently in the remote (rclone lsf).")
+        .option("--depth <n>", "Max recursion depth", "4")
+        .action((opts) => {
+        if (!checkRclone(emit)) {
+            emit.setExitCode(1);
+            return;
+        }
+        const cfg = ensureConfig(emit);
+        if (!cfg) {
+            emit.setExitCode(1);
+            return;
+        }
+        const remote = `${cfg.remote}:${cfg.prefix}`;
+        const r = spawnSync("rclone", ["lsf", remote, "-R", "--max-depth", opts.depth], {
+            stdio: "inherit",
+        });
+        emit.setExitCode(r.status ?? 1);
+    });
+}

package/dist/commands/toc.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from "commander";
+import type { EmitContext } from "../commander.js";
+export declare function registerTocCommand(program: Command, emit: EmitContext): void;
+export declare function registerSectionCommand(program: Command, emit: EmitContext): void;
+//# sourceMappingURL=toc.d.ts.map

package/dist/commands/toc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toc.d.ts","sourceRoot":"","sources":["../../src/commands/toc.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AA4CnD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAqB5E;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CA0BhF"}

package/dist/commands/toc.js

@@ -0,0 +1,153 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { resolveBinName } from "../core/config.js";
+export function registerTocCommand(program, emit) {
+    program
+        .command("toc <file>")
+        .description("Print the markdown header outline (level + text + line number).")
+        .option("--json", "Structured JSON envelope")
+        .option("-d, --depth <n>", "Maximum header depth (1-6)")
+        .option("--with-sizes", "Include line count per section")
+        .action(async (file, opts) => {
+        try {
+            const result = await runToc(file, opts);
+            if (opts.json) {
+                emit.config({ format: "json" });
+                emit.data(result);
+                return;
+            }
+            emit.text(`${renderToc(result)}\n`);
+        }
+        catch (err) {
+            emit.error({ code: "toc_failed", message: err.message });
+            process.exit(1);
+        }
+    });
+}
+export function registerSectionCommand(program, emit) {
+    program
+        .command("section <file> <header...>")
+        .description("Extract one section from a markdown file by header substring (case-insensitive by default). " +
+        "Joins multi-word args into one query string.")
+        .option("--json", "Structured JSON envelope: {file, matched_header, line_start, line_end, content}")
+        .option("--case-sensitive", "Case-sensitive header match")
+        .action(async (file, header, opts) => {
+        try {
+            const result = await runSection(file, header.join(" "), opts);
+            if (opts.json) {
+                emit.config({ format: "json" });
+                emit.data(result);
+                return;
+            }
+            emit.text(`${result.content}\n`);
+        }
+        catch (err) {
+            emit.error({ code: "section_failed", message: err.message });
+            process.exit(1);
+        }
+    });
+}
+async function runToc(file, opts) {
+    const absPath = resolve(file);
+    if (!existsSync(absPath))
+        throw new Error(`no such file: ${file}`);
+    const content = readFileSync(absPath, "utf8");
+    const lines = content.split("\n");
+    const maxDepth = opts.depth ? Number.parseInt(opts.depth, 10) : 6;
+    if (!Number.isFinite(maxDepth) || maxDepth < 1 || maxDepth > 6) {
+        throw new Error(`--depth must be 1-6 (got ${opts.depth})`);
+    }
+    const headers = [];
+    let inFence = false;
+    let fenceMarker = "";
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const fenceMatch = line.match(/^(\s*)(`{3,}|~{3,})/);
+        if (fenceMatch) {
+            const marker = fenceMatch[2];
+            if (!inFence) {
+                inFence = true;
+                fenceMarker = marker[0];
+            }
+            else if (marker[0] === fenceMarker) {
+                inFence = false;
+            }
+            continue;
+        }
+        if (inFence)
+            continue;
+        const headerMatch = line.match(/^(#{1,6})\s+(.+?)\s*#*\s*$/);
+        if (headerMatch) {
+            const level = headerMatch[1].length;
+            if (level > maxDepth)
+                continue;
+            headers.push({
+                level,
+                text: headerMatch[2],
+                line: i + 1,
+            });
+        }
+    }
+    if (opts.withSizes) {
+        for (let i = 0; i < headers.length; i++) {
+            const nextLine = i + 1 < headers.length ? headers[i + 1].line : lines.length + 1;
+            headers[i].size_lines = nextLine - headers[i].line;
+        }
+    }
+    return {
+        file,
+        total_lines: lines.length,
+        headers,
+    };
+}
+function renderToc(r) {
+    const lines = [];
+    lines.push(`toc · ${r.file} (${r.headers.length} header${r.headers.length === 1 ? "" : "s"}, ${r.total_lines} lines)`);
+    if (r.headers.length === 0) {
+        lines.push("(no markdown headers found)");
+        return lines.join("\n");
+    }
+    lines.push("");
+    for (const h of r.headers) {
+        const indent = "  ".repeat(h.level - 1);
+        const lineMark = `L${h.line}`.padEnd(6);
+        const size = h.size_lines !== undefined ? `  (${h.size_lines}L)` : "";
+        lines.push(`  ${lineMark}${indent}${"#".repeat(h.level)} ${h.text}${size}`);
+    }
+    return lines.join("\n");
+}
+async function runSection(file, query, opts) {
+    if (!query.trim())
+        throw new Error("header query required");
+    const tocResult = await runToc(file, {});
+    const absPath = resolve(file);
+    const lines = readFileSync(absPath, "utf8").split("\n");
+    const matches = tocResult.headers.filter((h) => opts.caseSensitive
+        ? h.text.includes(query)
+        : h.text.toLowerCase().includes(query.toLowerCase()));
+    if (matches.length === 0) {
+        throw new Error(`no header matching "${query}". Run \`${resolveBinName()} toc ${file}\` to list available headers.`);
+    }
+    if (matches.length > 1) {
+        const list = matches.map((h) => `  L${h.line}  ${"#".repeat(h.level)} ${h.text}`).join("\n");
+        throw new Error(`multiple headers match "${query}":\n${list}\n\nRefine the query or use exact text.`);
+    }
+    const matched = matches[0];
+    const idx = tocResult.headers.findIndex((h) => h.line === matched.line);
+    let endLine = lines.length;
+    for (let i = idx + 1; i < tocResult.headers.length; i++) {
+        if (tocResult.headers[i].level <= matched.level) {
+            endLine = tocResult.headers[i].line - 1;
+            break;
+        }
+    }
+    const content = lines.slice(matched.line - 1, endLine).join("\n");
+    return {
+        file,
+        matched_header: matched.text,
+        matched_level: matched.level,
+        line_start: matched.line,
+        line_end: endLine,
+        content,
+    };
+}

package/dist/commands/tokens.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+import type { EmitContext } from "../commander.js";
+export declare function registerTokensCommand(program: Command, emit: EmitContext): void;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/commands/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../src/commands/tokens.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAwBnD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAyC/E"}

package/dist/commands/tokens.js

@@ -0,0 +1,48 @@
+import { readFileSync } from "node:fs";
+import { countTokens } from "gpt-tokenizer/model/gpt-4o";
+export function registerTokensCommand(program, emit) {
+    program
+        .command("tokens")
+        .description("Count tokens in text/markdown files (offline, uses o200k_base as Claude proxy)")
+        .argument("<files...>", "One or more file paths (globs are shell-expanded)")
+        .option("--limit <n>", "Flag files exceeding N tokens; exit non-zero if any exceed", (v) => Number.parseInt(v, 10))
+        .option("--format <type>", "Output format: table, json, plain", "table")
+        .action((files, opts) => {
+        if (opts.format === "json")
+            emit.config({ format: "json" });
+        const results = files.map(countFile);
+        const over = opts.limit !== undefined
+            ? results.filter((r) => !r.error && r.tokens > opts.limit)
+            : [];
+        const enriched = results.map((r) => ({
+            path: r.path,
+            chars: r.chars,
+            tokens: r.tokens,
+            error: r.error,
+            over_limit: opts.limit !== undefined && !r.error ? r.tokens > opts.limit : null,
+            pct_of_limit: opts.limit !== undefined && !r.error
+                ? Math.round((r.tokens / opts.limit) * 100)
+                : null,
+        }));
+        emit.data({
+            ok: true,
+            tokenizer: "o200k_base",
+            limit: opts.limit ?? null,
+            count: enriched.length,
+            over_count: over.length,
+            results: enriched,
+        });
+        if (over.length > 0)
+            emit.setExitCode(1);
+    });
+}
+function countFile(path) {
+    try {
+        const content = readFileSync(path, "utf8");
+        return { path, chars: content.length, tokens: countTokens(content), error: null };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { path, chars: 0, tokens: 0, error: msg };
+    }
+}

package/dist/commands/tunnel.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+import type { EmitContext, HarneryProgramContext } from "../commander.js";
+export declare function registerTunnelCommand(program: Command, emitParam: EmitContext, contextParam?: HarneryProgramContext): void;
+//# sourceMappingURL=tunnel.d.ts.map

package/dist/commands/tunnel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tunnel.d.ts","sourceRoot":"","sources":["../../src/commands/tunnel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AA4jB1E,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,WAAW,EACtB,YAAY,CAAC,EAAE,qBAAqB,GACnC,IAAI,CAuDN"}