friction-log 0.0.0-stage → 0.6.0

package/CHANGELOG.md

@@ -0,0 +1,44 @@
+# Changelog
+
+All notable changes to `friction-log` are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.6.0] - 2026-10-10
+
+First release published to npm (`npm i -g friction-log`). Earlier versions ran from a local build of this repository. The entries below cover everything since the 0.5.0 milestone tag.
+
+### Added
+
+- Opt-in `sync_export` config block and a `sync-export` command: a deterministic, atomic, no-op-skipping export of the local database, written through after each of the six mutating commands (`log`, `update`, `rm`, `file`, `import`, `scan`). Without the config block everything is an exact no-op. See [sync export](docs/sync-export.md).
+- `digest --include-peers`: merges the exports of other machines into the digest, with origin-labeled sections, by replaying them into an in-memory database and reusing the regular digest query.
+- The npm package ships `LICENSE`, `README.md`, and this changelog next to `dist/` and `templates/`.
+
+### Changed
+
+- `engines.node` is now `>=22`, matching `better-sqlite3` 13 (which declares `>=22` and ships prebuilt binaries inside its own package, so the install needs no compiler and no download step). Node 20 is no longer a supported runtime.
+
+### Fixed
+
+- `log --session <id>` no longer fails with a raw `FOREIGN KEY constraint failed` when the session id is not yet in the `sessions` table: the row is now created before the friction is inserted.
+- `better-sqlite3` is bumped to `^13`, so the package installs on Node 26. `^11` has no prebuilt binary for that ABI and its source build fails against Node 26's V8 headers.
+
+### Security
+
+Runtime (shipped):
+
+- The declared `yaml` floor is raised to `^2.8.3` so installs cannot resolve an older release. The lockfile already resolved 2.9.0, so only the declared range changes.
+- `better-sqlite3` moves from 11.10.0 to 13.0.1 (see Changed and Fixed). Its install-time download chain (`prebuild-install`, `tar-fs`, `rc`, `minimist`, and related packages) is gone from the lockfile.
+
+Development-only (not shipped, not part of the published package):
+
+- `tsx` to `^4.22.4` (resolved 4.22.4), which pulls `esbuild` 0.28.1.
+- `vitest` to `^4.1.6` (resolved 4.1.11) and `vite` to 8.3.0, now built on `rolldown` 1.2.8 instead of `rollup`.
+- Lockfile bumps for `nanoid`, `postcss`, `source-map-js`, `picomatch`, and `tinyglobby`.
+
+### Notes
+
+Node 20 is unsupported: `better-sqlite3` 13 requires Node 22 or newer, and on Node 20 the process crashes with SIGSEGV on the first database command.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lan Nguyen Si
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,99 @@
-# Temporary Holding Version
+# friction-log
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Capture, query, and infer agent-workflow frictions. SQLite-backed, sink-pluggable, zero-config default.
+
+> Most agent tooling helps a model *write* the code. `friction-log` keeps a structured record of the moments where the agent's tools, MCP verbs, or harness behave unexpectedly, so the friction doesn't evaporate between sessions and the dogfood loop stays honest.
+
+## Overview
+
+Two recurring patterns in agent-driven development go unaddressed by most tooling: the per-friction reflex (the agent notices a tool acting unexpectedly mid-task, mentally notes it, then moves on and the note evaporates) and the end-of-session bilanz (a retrospective naming tools exercised, frictions observed, tasks filed, easy to skip if nothing makes it cheap). `friction-log` lowers the cost of both: a one-line `log` for the per-moment capture, a one-command `file` to push the friction into whatever issue tracker the team uses, and a passive Stop-hook scan plus `bilanz` so missed frictions still get a second chance at the session boundary. The data isn't the goal; the goal is the inferences a few weeks of accumulated data enable (which tools cause the most friction, which categories recur, how long frictions take to become fixes), which is why the schema (SQLite + FTS5) is the foundation everything else builds on.
+
+**Status:** M5 (this release) completes the v1 surface. `init` writes a YAML config and optionally installs the Claude Code Stop-hook in one command (with a `--yes` non-interactive mode for scripted bootstrap). `import --format markdown-frontmatter <dir>` bulk-loads existing markdown notes into the database, idempotent on re-run via a content-hash dedup. Four templates round out the v1 set (`tool-missing-capability`, `auth-expiry`, `schema-drift`, `doc-gap`), all auto-picked by matching the friction's `category`.
+
+## Key features
+
+- One-command `init`: detects the local environment and writes config, optionally installing the Claude Code Stop-hook
+- Structured `log`, `list`, `search` (FTS5), `export`, and `digest` (aggregations) over a local SQLite store
+- Five pluggable filing sinks: `markdown-file` (default, zero-dependency), `stdout-json`, `github-issues`, `agent-tasks`, `linear`
+- Idempotent `scan` of Claude Code transcripts (deduped on session, tool, and title) and `import` of existing markdown notes (content-hash deduped)
+- Optional multi-machine `sync-export`: deterministic, config-gated JSON file dump with read-only peer merge into `digest`
+- Auto-linked recurrence detection on repeated (tool, title) matches
+
+## Install / quick start
+
+Install from npm (Node.js 22 or later):
+
+```bash
+npm i -g friction-log
+friction-log --version
+
+# Log a friction you noticed
+friction-log log \
+  --title "tasks_list returns 149kB blob" \
+  --tool "mcp:agent-tasks/tasks_list" \
+  --category output-overflow \
+  --severity high
+
+# See it in the local database
+friction-log list
+
+# Render and file it via the default markdown sink
+friction-log file 1
+```
+
+The global install puts a `friction-log` command on PATH, which the Stop-hook below needs.
+
+To run from a local build instead (for development on this repository):
+
+```bash
+git clone https://github.com/LanNguyenSi/agent-dx && cd agent-dx
+cd packages/friction-log && npm install && npm run build
+node dist/cli.js --help
+```
+
+A markdown record lands under `~/.local/share/friction-log/frictions/` with full frontmatter, ready to commit, paste into a chat, or pipe into another tool.
+
+## Usage
+
+Wire automatic capture into every Claude Code session with a Stop-hook, then review with `bilanz`:
+
+```jsonc
+// ~/.claude/settings.json
+{
+  "hooks": {
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [{ "type": "command", "command": "friction-log scan --silent --stdin-payload" }]
+      }
+    ]
+  }
+}
+```
+
+```bash
+friction-log bilanz
+```
+
+See [Command reference](./docs/commands.md) for every subcommand, including manual transcript scanning; run any command with `--help` for its complete flag list.
+
+## Documentation
+
+- [Command reference](./docs/commands.md): full subcommand table, Stop-hook wiring, manual scan, templates
+- [Sinks](./docs/sinks.md): configuration for `markdown-file`, `stdout-json`, `github-issues`, `agent-tasks`, `linear`
+- [Sync-export](./docs/sync-export.md): optional multi-machine file merge, format, and write-through semantics
+- [Storage](./docs/storage.md): SQLite schema and `recurrence_of_id` matching rule
+- [Design notes](./docs/design.md): ADR for the sink options bag, roadmap, and how this relates to `slop-detector`
+
+## Development
+
+```bash
+npm install
+npm run typecheck
+npm run build
+npm test
+```
+
+## License
+
+MIT. See [LICENSE](./LICENSE).

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,504 @@
+#!/usr/bin/env node
+import { Command, Option } from "commander";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runBilanz } from "./commands/bilanz.js";
+import { formatDigest, runDigest } from "./commands/digest.js";
+import { runExport } from "./commands/export.js";
+import { runFile } from "./commands/file.js";
+import { runImport } from "./commands/import.js";
+import { runInit } from "./commands/init.js";
+import { formatTable, runList } from "./commands/list.js";
+import { runLog } from "./commands/log.js";
+import { runRm } from "./commands/rm.js";
+import { payloadToScanInput, runScan, summarize, } from "./commands/scan.js";
+import { runSearch } from "./commands/search.js";
+import { runSyncExport } from "./commands/sync-export.js";
+import { runUpdate } from "./commands/update.js";
+import { parseSinkOpts } from "./config.js";
+import { availableSinks } from "./sinks/index.js";
+function readPackageVersion() {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        const pkgPath = join(here, "..", "package.json");
+        const raw = readFileSync(pkgPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.version === "string" ? parsed.version : "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+const SEVERITY_CHOICES = ["low", "medium", "high", "critical"];
+const STATUS_CHOICES = ["open", "filed", "resolved", "wontfix"];
+const SOURCE_CHOICES = ["scan", "manual", "import"];
+const SCANNER_CHOICES = ["claude-code"];
+const DIGEST_GROUP_CHOICES = [
+    "tool",
+    "category",
+    "severity",
+    "source",
+];
+const EXPORT_FORMAT_CHOICES = ["json", "csv", "md"];
+const IMPORT_FORMAT_CHOICES = ["markdown-frontmatter"];
+const program = new Command();
+program
+    .name("friction-log")
+    .description("Capture, query, and infer agent-workflow frictions.")
+    .version(readPackageVersion());
+program
+    .command("log")
+    .description("Manually record a friction.")
+    .requiredOption("--title <title>", "Short title describing the friction")
+    .option("--description <text>", "Longer description / reproduction notes")
+    .option("--tool <surface>", "Tool surface that caused the friction (e.g. mcp:agent-tasks/tasks_list)")
+    .option("--category <name>", "Category (e.g. output-overflow, tool-error)")
+    .addOption(new Option("--severity <level>", "Severity level").choices([
+    ...SEVERITY_CHOICES,
+]))
+    .option("--session <id>", "Session id to associate with this friction")
+    .option("--recurrence-of <id>", "Mark this friction as a recurrence of an existing one", (v) => Number(v))
+    .option("--db <path>", "Override database path (default: XDG)")
+    .action((opts) => {
+    const recurrenceOfRaw = opts.recurrenceOf;
+    let recurrenceOfId;
+    if (recurrenceOfRaw !== undefined) {
+        if (typeof recurrenceOfRaw !== "number" ||
+            !Number.isInteger(recurrenceOfRaw) ||
+            recurrenceOfRaw <= 0) {
+            process.stderr.write(`friction-log: --recurrence-of must be a positive integer, got "${String(recurrenceOfRaw)}"\n`);
+            process.exit(2);
+        }
+        recurrenceOfId = recurrenceOfRaw;
+    }
+    const out = runLog({
+        title: opts.title,
+        description: opts.description,
+        tool: opts.tool,
+        category: opts.category,
+        severity: opts.severity,
+        sessionId: opts.session,
+        recurrenceOfId,
+        dbPath: opts.db,
+    });
+    const recurrenceTag = out.recurrenceOfId != null ? ` recurrence_of=${out.recurrenceOfId}` : "";
+    process.stdout.write(`friction id=${out.id} captured_at=${out.capturedAt}${recurrenceTag}\n`);
+});
+program
+    .command("list")
+    .description("List frictions with optional filters.")
+    .addOption(new Option("--status <status>", "Filter by status").choices([
+    ...STATUS_CHOICES,
+]))
+    .option("--tool <surface>", "Filter by tool surface")
+    .option("--category <name>", "Filter by category")
+    .addOption(new Option("--source <source>", "Filter by source").choices([
+    ...SOURCE_CHOICES,
+]))
+    .option("--age <span>", "Only frictions newer than e.g. 14d, 4w, 12h")
+    .option("--limit <n>", "Max rows (default 100)", (v) => Number(v))
+    .option("--json", "Emit JSON instead of a table")
+    .option("--db <path>", "Override database path")
+    .action((opts) => {
+    const out = runList({
+        status: opts.status,
+        tool: opts.tool,
+        category: opts.category,
+        source: opts.source,
+        age: opts.age,
+        limit: typeof opts.limit === "number" ? opts.limit : undefined,
+        dbPath: opts.db,
+    });
+    if (opts.json) {
+        process.stdout.write(JSON.stringify(out.frictions, null, 2) + "\n");
+    }
+    else {
+        process.stdout.write(formatTable(out.frictions) + "\n");
+    }
+});
+program
+    .command("file <frictionId>")
+    .description("Push a friction to a configured sink. Default sink: markdown-file.")
+    .addOption(new Option("--sink <name>", "Sink to use")
+    .choices([...availableSinks])
+    .default("markdown-file"))
+    .option("--template <name>", "Template override (defaults to friction.category match)")
+    .option("--sink-target <value>", "Sink-specific target (markdown-file: directory path)")
+    .option("--sink-opt <key=value>", "Per-sink option override, repeatable (e.g. --sink-opt repo=owner/name)", (value, previous = []) => [...previous, value], [])
+    .option("--config <path>", "Override config file path (default: $XDG_CONFIG_HOME/friction-log/config.yml)")
+    .option("--db <path>", "Override database path")
+    .action(async (frictionId, opts) => {
+    const id = Number(frictionId);
+    if (!Number.isInteger(id) || id <= 0) {
+        process.stderr.write(`friction-log: <frictionId> must be a positive integer, got "${frictionId}"\n`);
+        process.exit(2);
+    }
+    try {
+        const sinkOptPairs = Array.isArray(opts.sinkOpt)
+            ? opts.sinkOpt
+            : [];
+        const sinkOpts = sinkOptPairs.length
+            ? parseSinkOpts(sinkOptPairs)
+            : undefined;
+        const out = await runFile({
+            frictionId: id,
+            sink: opts.sink,
+            template: opts.template,
+            sinkTarget: opts.sinkTarget,
+            sinkOpts,
+            configPath: opts.config,
+            dbPath: opts.db,
+        });
+        process.stdout.write(`filed friction id=${id} via sink=${out.sinkName} target=${out.sinkTarget}\n${out.message}\n`);
+    }
+    catch (err) {
+        process.stderr.write(`${err.message}\n`);
+        process.exit(1);
+    }
+});
+program
+    .command("scan")
+    .description("Scan a transcript for candidate frictions and store them.")
+    .option("--session <id>", "Session id (defaults to derivation from --transcript filename)")
+    .option("--transcript <path>", "Path to the transcript file (e.g. ~/.claude/projects/.../<id>.jsonl)")
+    .addOption(new Option("--adapter <name>", "Scanner adapter").choices([
+    ...SCANNER_CHOICES,
+]))
+    .option("--silent", "Never throw, exit 0 always (Stop-hook mode)")
+    .option("--stdin-payload", "Read a JSON Stop-hook payload from stdin to derive session+transcript")
+    .option("--db <path>", "Override database path")
+    .action(async (opts) => {
+    try {
+        let baseInput = {
+            sessionId: opts.session,
+            transcriptPath: opts.transcript,
+            adapter: opts.adapter,
+            dbPath: opts.db,
+        };
+        if (opts.stdinPayload) {
+            const payload = await readStdinPayload();
+            const derived = payloadToScanInput(payload, baseInput.adapter);
+            baseInput = {
+                sessionId: derived.sessionId ?? baseInput.sessionId,
+                transcriptPath: derived.transcriptPath ?? baseInput.transcriptPath,
+                adapter: derived.adapter ?? baseInput.adapter,
+                dbPath: baseInput.dbPath,
+            };
+        }
+        const out = await runScan(baseInput);
+        if (!opts.silent) {
+            process.stdout.write(summarize(out, out.sessionId) + "\n");
+        }
+    }
+    catch (err) {
+        if (opts.silent) {
+            process.stderr.write(`friction-log scan (silent): ${err.message}\n`);
+            process.exit(0);
+        }
+        process.stderr.write(`${err.message}\n`);
+        process.exit(1);
+    }
+});
+program
+    .command("bilanz")
+    .description("Format a session-boundary bilanz: tools, frictions, tasks.")
+    .option("--session <id>", "Session id (defaults to most-recent in db)")
+    .option("--db <path>", "Override database path")
+    .action(async (opts) => {
+    try {
+        const out = await runBilanz({ sessionId: opts.session, dbPath: opts.db });
+        process.stdout.write(out.formatted);
+    }
+    catch (err) {
+        process.stderr.write(`${err.message}\n`);
+        process.exit(1);
+    }
+});
+program
+    .command("rm <frictionId>")
+    .description("Delete a friction (and any task rows pointing at it) from the local store.")
+    .option("--db <path>", "Override database path")
+    .action((frictionId, opts) => {
+    const id = Number(frictionId);
+    if (!Number.isInteger(id) || id <= 0) {
+        process.stderr.write(`friction-log: <frictionId> must be a positive integer, got "${frictionId}"\n`);
+        process.exit(2);
+    }
+    try {
+        const out = runRm({ frictionId: id, dbPath: opts.db });
+        process.stdout.write(`removed friction id=${id} (${out.removed ? "ok" : "no-op"})\n`);
+    }
+    catch (err) {
+        process.stderr.write(`${err.message}\n`);
+        process.exit(1);
+    }
+});
+program
+    .command("update <frictionId>")
+    .description("Update a friction (status only in M2; more fields in later milestones).")
+    .addOption(new Option("--status <status>", "New status")
+    .choices([...STATUS_CHOICES])
+    .makeOptionMandatory(true))
+    .option("--db <path>", "Override database path")
+    .action((frictionId, opts) => {
+    const id = Number(frictionId);
+    if (!Number.isInteger(id) || id <= 0) {
+        process.stderr.write(`friction-log: <frictionId> must be a positive integer, got "${frictionId}"\n`);
+        process.exit(2);
+    }
+    try {
+        const out = runUpdate({
+            frictionId: id,
+            status: opts.status,
+            dbPath: opts.db,
+        });
+        process.stdout.write(`updated friction id=${out.id} status=${out.status}\n`);
+    }
+    catch (err) {
+        process.stderr.write(`${err.message}\n`);
+        process.exit(1);
+    }
+});
+program
+    .command("search <query>")
+    .description("Full-text search over title + description (FTS5).")
+    .addOption(new Option("--status <status>", "Filter by status").choices([
+    ...STATUS_CHOICES,
+]))
+    .option("--tool <surface>", "Filter by tool surface")
+    .option("--category <name>", "Filter by category")
+    .addOption(new Option("--source <source>", "Filter by source").choices([
+    ...SOURCE_CHOICES,
+]))
+    .option("--age <span>", "Only frictions newer than e.g. 14d, 4w, 12h")
+    .option("--limit <n>", "Max rows (default 100)", (v) => Number(v))
+    .option("--json", "Emit JSON instead of a table")
+    .option("--db <path>", "Override database path")
+    .action((query, opts) => {
+    try {
+        const out = runSearch({
+            query,
+            status: opts.status,
+            tool: opts.tool,
+            category: opts.category,
+            source: opts.source,
+            age: opts.age,
+            limit: typeof opts.limit === "number" ? opts.limit : undefined,
+            dbPath: opts.db,
+        });
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(out.frictions, null, 2) + "\n");
+        }
+        else {
+            process.stdout.write(formatTable(out.frictions) + "\n");
+        }
+    }
+    catch (err) {
+        process.stderr.write(`${err.message}\n`);
+        process.exit(1);
+    }
+});
+program
+    .command("digest")
+    .description("Aggregations over frictions: counts, open-vs-filed, recurrences, avg hours to triage.")
+    .addOption(new Option("--group-by <field>", "Group by field")
+    .choices([...DIGEST_GROUP_CHOICES])
+    .makeOptionMandatory(true))
+    .option("--last <span>", "Restrict to frictions newer than e.g. 30d, 4w, 12h")
+    .option("--include-peers", "Also render read-only digest sections for each configured sync_export.peer_paths file")
+    .option("--json", "Emit JSON instead of a table")
+    .option("--config <path>", "Override config file path (only used by --include-peers)")
+    .option("--db <path>", "Override database path")
+    .action((opts) => {
+    try {
+        const out = runDigest({
+            groupBy: opts.groupBy,
+            last: opts.last,
+            dbPath: opts.db,
+            configPath: opts.config,
+            includePeers: Boolean(opts.includePeers),
+        });
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(out, null, 2) + "\n");
+        }
+        else {
+            process.stdout.write(formatDigest(out) + "\n");
+        }
+        if (out.peers) {
+            for (const peer of out.peers) {
+                if (peer.error) {
+                    process.stderr.write(`friction-log: warning: peer digest source ${peer.sourcePath} (origin=${peer.origin}) skipped: ${peer.error}\n`);
+                }
+                else if (peer.skipped > 0) {
+                    process.stderr.write(`friction-log: warning: peer digest source ${peer.sourcePath} (origin=${peer.origin}) skipped ${peer.skipped} malformed record(s)\n`);
+                }
+            }
+        }
+    }
+    catch (err) {
+        process.stderr.write(`${err.message}\n`);
+        process.exit(1);
+    }
+});
+program
+    .command("export")
+    .description("Export frictions as JSON, CSV, or Markdown.")
+    .addOption(new Option("--format <fmt>", "Output format")
+    .choices([...EXPORT_FORMAT_CHOICES])
+    .default("json"))
+    .option("--out <path>", "Write to a file instead of stdout")
+    .option("--query <text>", "Only export frictions matching an FTS5 query")
+    .addOption(new Option("--status <status>", "Filter by status").choices([
+    ...STATUS_CHOICES,
+]))
+    .option("--tool <surface>", "Filter by tool surface")
+    .option("--category <name>", "Filter by category")
+    .addOption(new Option("--source <source>", "Filter by source").choices([
+    ...SOURCE_CHOICES,
+]))
+    .option("--age <span>", "Only frictions newer than e.g. 14d, 4w, 12h")
+    .option("--limit <n>", "Max rows (default 100)", (v) => Number(v))
+    .option("--db <path>", "Override database path")
+    .action((opts) => {
+    try {
+        const out = runExport({
+            format: opts.format,
+            out: opts.out,
+            query: opts.query,
+            status: opts.status,
+            tool: opts.tool,
+            category: opts.category,
+            source: opts.source,
+            age: opts.age,
+            limit: typeof opts.limit === "number" ? opts.limit : undefined,
+            dbPath: opts.db,
+        });
+        if (out.out) {
+            process.stderr.write(`exported ${out.count} records (${out.format}) to ${out.out}\n`);
+        }
+        else {
+            process.stdout.write(out.rendered);
+        }
+    }
+    catch (err) {
+        process.stderr.write(`${err.message}\n`);
+        process.exit(1);
+    }
+});
+program
+    .command("sync-export")
+    .description("Write every friction as deterministic, origin-tagged JSON to the configured sync_export.path. " +
+    'No-op error unless "sync_export" (path + origin) is set in config.yml or via FRICTION_LOG_SYNC_EXPORT_PATH/_ORIGIN.')
+    .option("--config <path>", "Override config file path")
+    .option("--db <path>", "Override database path")
+    .action((opts) => {
+    try {
+        const out = runSyncExport({
+            configPath: opts.config,
+            dbPath: opts.db,
+        });
+        process.stderr.write(`sync-export: wrote ${out.count} frictions (origin=${out.origin}) to ${out.path}\n`);
+    }
+    catch (err) {
+        process.stderr.write(`${err.message}\n`);
+        process.exit(1);
+    }
+});
+program
+    .command("init")
+    .description("Interactive setup: write config.yml, optionally install Stop-hook.")
+    .addOption(new Option("--sink <name>", "Default sink (skips the interactive prompt)").choices([...availableSinks]))
+    .option("-y, --yes", "Non-interactive; use --sink (or markdown-file fallback) and skip Stop-hook offer")
+    .option("--install-stop-hook", "Force-install the Claude Code Stop-hook (skip the interactive y/N)")
+    .option("--config <path>", "Override config file path")
+    .option("--sync-export-path <path>", "Opt in to sync-export: write this config's sync_export.path")
+    .option("--sync-export-origin <name>", "Opt in to sync-export: this machine's sync_export.origin label")
+    .option("--sync-export-peer <path>", "Peer sync-export file to read for `digest --include-peers`, repeatable", (value, previous = []) => [...previous, value], [])
+    .action(async (opts) => {
+    try {
+        const syncExportPath = opts.syncExportPath;
+        const syncExportOrigin = opts.syncExportOrigin;
+        if (Boolean(syncExportPath) !== Boolean(syncExportOrigin)) {
+            process.stderr.write("friction-log: --sync-export-path and --sync-export-origin must be given together\n");
+            process.exit(2);
+        }
+        const syncExportPeers = Array.isArray(opts.syncExportPeer)
+            ? opts.syncExportPeer
+            : [];
+        const out = await runInit({
+            configPath: opts.config,
+            sink: opts.sink,
+            yes: Boolean(opts.yes),
+            installStopHook: opts.installStopHook === true ? true : undefined,
+            syncExport: syncExportPath && syncExportOrigin
+                ? {
+                    path: syncExportPath,
+                    origin: syncExportOrigin,
+                    peerPaths: syncExportPeers,
+                }
+                : undefined,
+        });
+        process.stdout.write(`init: ${out.configWritten ? "wrote" : "no change to"} ${out.configPath}\n` +
+            (out.stopHookWrittenTo
+                ? `init: Stop-hook installed at ${out.stopHookWrittenTo}\n`
+                : "") +
+            "\nNext steps:\n" +
+            out.nextSteps.map((s) => `  ${s}`).join("\n") +
+            "\n");
+    }
+    catch (err) {
+        process.stderr.write(`${err.message}\n`);
+        process.exit(1);
+    }
+});
+program
+    .command("import <path>")
+    .description("Bulk-ingest frictions from a directory of markdown files.")
+    .addOption(new Option("--format <fmt>", "Source format")
+    .choices([...IMPORT_FORMAT_CHOICES])
+    .default("markdown-frontmatter"))
+    .option("--db <path>", "Override database path")
+    .action((path, opts) => {
+    try {
+        const out = runImport({
+            format: opts.format,
+            path,
+            dbPath: opts.db,
+        });
+        process.stdout.write(`import: scanned=${out.scanned} imported=${out.imported} skipped=${out.skipped}\n`);
+        if (out.errors.length) {
+            process.stderr.write(`import: ${out.errors.length} errors:\n`);
+            for (const e of out.errors.slice(0, 10)) {
+                process.stderr.write(`  ${e.file}: ${e.reason}\n`);
+            }
+            if (out.errors.length > 10) {
+                process.stderr.write(`  ... and ${out.errors.length - 10} more\n`);
+            }
+        }
+    }
+    catch (err) {
+        process.stderr.write(`${err.message}\n`);
+        process.exit(1);
+    }
+});
+async function readStdinPayload() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const text = Buffer.concat(chunks).toString("utf8").trim();
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return {};
+    }
+}
+program.parseAsync(process.argv).catch((err) => {
+    process.stderr.write(`friction-log: ${err.message}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map