@meza/adr-tools 2.0.2 → 2.0.4

package/doc/adr/0001-record-architecture-decisions.md

@@ -1,21 +0,0 @@
-# 1. Record architecture decisions
-
-Date: 2022-06-22
-
-## Status
-
-Accepted
-
-## Context
-
-We need to record the architectural decisions made on this project.
-
-## Decision
-
-We will use Architecture Decision Records, as [described by Michael Nygard](http://thinkrelevance.com/blog/2011/11/15/documenting-architecture-decisions).
-
-## Consequences
-
-See Michael Nygard's article, linked above.
-For a lightweight ADR toolset, see Nat Pryce's [adr-tools](https://github.com/npryce/adr-tools).
-> For a node version of the same tooling, see Meza's [adr-tools](https://github.com/meza/adr-tools).

package/doc/adr/0002-using-heavy-e2e-tests.md

@@ -1,20 +0,0 @@
-# 2. Using Heavy E2E Tests
-
-Date: 2022-06-22
-
-## Status
-
-Accepted
-
-## Context
-
-The original tool has an [exhaustive test suite](https://github.com/npryce/adr-tools/tree/master/tests) that allows us to make sure that we're backwards compatible.
-
-## Decision
-
-We'll be re-implementing those tests for ourselves too. This means that we will be using the original examples,
-expectations and the ethos of invoking the tool with the given examples.
-
-## Consequences
-
-The E2E test suite will be very slow to run and it can only be executed sequentially.

package/doc/adr/0003-esm.md

@@ -1,34 +0,0 @@
-# 3. ESM
-
-Date: 2022-06-29
-
-## Status
-
-Accepted
-
-## Context
-
-With typescript 4.7 come proper ESM modules.
-
-ECMAScript modules are the official standard format to package JavaScript code for reuse. Modules are defined using a variety of import and export statements.
-
-## Decision
-
-Since this is a new project, there's no reason to _not_ go with the flow.
-
-## Consequences
-
-There's some changes to the way the project is set up.
-Everything is described here, in [Typescript's official documentation](https://devblogs.microsoft.com/typescript/announcing-typescript-4-7-beta/#ecmascript-module-support-in-node-js)
-
-However, some highlights:
-
-We **must** import code with extensions and `.js` at that (even though the file's actual type is .ts)
-
-`__dirname` and `__filename` are no longer available. Use this instead:
-```typescript
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);```

package/doc/adr/0004-gate-editor-opening-behind---open-and---open-with.md

@@ -1,55 +0,0 @@
-# 4. Gate editor opening behind --open and --open-with
-
-Date: 2026-01-04
-
-## Status
-
-Accepted
-
-## Context
-
-This tool historically tries to open a newly created ADR in the user's editor by reading the `VISUAL` and `EDITOR`
-environment variables.
-
-In 2025, a common way to run Node CLIs is via `npx`/`npm exec`. npm injects an `EDITOR` value into child processes
-based on npm config (`npm_config_editor`), even when the user did not intend to configure an editor for this tool.
-
-This creates two classes of problems:
-
-1. Unwanted side effects. Creating an ADR can unexpectedly launch an editor or attempt to launch a placeholder value.
-2. Cross-platform friction. Windows shells, quoting rules, and editor invocation are inconsistent, making the default
-   "auto open" behavior more fragile than the rest of the CLI.
-
-We still want a good "create and open" workflow, but it must be explicit and predictable, and it must work well on
-Windows, macOS, and Linux.
-
-## Decision
-
-We will stop automatically opening an editor after `adr new` by default.
-
-We will add two flags to the CLI:
-
-- `--open`: Open the newly created ADR file after creation.
-- `--open-with <command>`: Open the newly created ADR file using the provided command (optionally including args).
-
-When `--open` is supplied, the tool will select an opener in this order:
-
-1. `--open-with <command>` if provided.
-2. `VISUAL` if it is set by the user and not empty.
-3. `EDITOR` if it is set by the user and not empty.
-4. OS default application for the file type.
-
-To handle cross-platform differences, we will use a dedicated dependency (`open`) to perform the actual launching
-when possible, rather than building platform-specific process spawning logic in this project.
-
-## Consequences
-
-This makes ADR creation deterministic and side-effect free by default, including when invoked via `npx` or within CI.
-
-Users who want the "open after create" workflow can still have it, but must opt in via `--open` or explicitly specify
-an opener via `--open-with`.
-
-This reduces platform-specific bugs and maintenance burden by relying on a well-maintained cross-platform opener.
-
-This is a breaking behavior change for users who relied on implicit editor opening when `VISUAL`/`EDITOR` were set,
-but the new behavior is more predictable and better aligned with modern Node execution environments.

package/doc/adr/decisions.md

@@ -1,6 +0,0 @@
-# Table of Contents
-
-- [1. Record architecture decisions](0001-record-architecture-decisions.md)
-- [2. Using Heavy E2E Tests](0002-using-heavy-e2e-tests.md)
-- [3. ESM](0003-esm.md)
-- [4. Gate editor opening behind --open and --open-with](0004-gate-editor-opening-behind---open-and---open-with.md)

package/lefthook.yml

@@ -1,14 +0,0 @@
-pre-commit:
-  jobs:
-    - name: lint
-      run: yarn lint
-
-pre-push:
-  jobs:
-    - name: ci
-      run: yarn ci
-
-commit-msg:
-  jobs:
-    - name: commitlint
-      run: yarn -s commitlint --edit {1}

package/scripts/inject-version.mjs

@@ -1,34 +0,0 @@
-import { readFileSync, writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
-
-export const buildVersionSource = (version) => `export const LIB_VERSION = '${version}';\n`;
-
-export const resolveTargetPath = (argv) => {
-  const target = argv[2];
-  if (!target) {
-    throw new Error('Usage: node scripts/inject-version.mjs <output-file>');
-  }
-  return target;
-};
-
-export const writeVersionFile = (target, version) => {
-  writeFileSync(resolve(process.cwd(), target), buildVersionSource(version), 'utf8');
-};
-
-const readPackageVersion = () =>
-  JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
-
-const run = () => {
-  try {
-    const target = resolveTargetPath(process.argv);
-    writeVersionFile(target, readPackageVersion());
-  } catch (error) {
-    console.error(error.message);
-    process.exit(1);
-  }
-};
-
-if (pathToFileURL(process.argv[1]).href === import.meta.url) {
-  run();
-}

package/src/index.test.ts

@@ -1,222 +0,0 @@
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import chalk from 'chalk';
-import type { Command } from 'commander';
-import { describe, expect, it, vi } from 'vitest';
-import { buildProgram, defaultOnError, isDirectRun, maybeRun, run } from './index.js';
-
-const createDeps = () => {
-  const deps = {
-    generateToc: vi.fn(),
-    init: vi.fn(),
-    link: vi.fn(),
-    listAdrs: vi.fn(),
-    newAdr: vi.fn(),
-    workingDir: vi.fn(),
-    readFile: vi.fn(),
-    getLinksFrom: vi.fn(),
-    getTitleFrom: vi.fn(),
-    version: '1.2.3',
-    onError: vi.fn(),
-    log: vi.fn(),
-    warn: vi.fn()
-  };
-
-  return deps;
-};
-
-describe('adr CLI', () => {
-  it('wires program metadata', () => {
-    const deps = createDeps();
-    const program = buildProgram(deps);
-    expect(program.name()).toEqual('adr');
-    expect(program.version()).toEqual('1.2.3');
-  });
-
-  it('runs the new command with options', async () => {
-    const deps = createDeps();
-    await run(['node', 'adr', 'new', 'My', 'ADR', '--open'], deps);
-    expect(deps.newAdr).toHaveBeenCalledWith('My ADR', {
-      supersedes: [],
-      date: process.env.ADR_DATE,
-      suppressPrompts: false,
-      links: [],
-      open: true,
-      openWith: undefined
-    });
-  });
-
-  it('invokes error handler when newAdr fails', async () => {
-    const deps = createDeps();
-    deps.newAdr.mockRejectedValueOnce(new Error('boom'));
-    await run(['node', 'adr', 'new', 'My', 'ADR'], deps);
-    expect(deps.onError).toHaveBeenCalled();
-  });
-
-  it('routes generate toc', async () => {
-    const deps = createDeps();
-    await run(['node', 'adr', 'generate', 'toc', '-p', '/prefix/'], deps);
-    expect(deps.generateToc).toHaveBeenCalledWith({ prefix: '/prefix/' });
-  });
-
-  it('generates graph output', async () => {
-    const deps = createDeps();
-    deps.listAdrs.mockResolvedValue(['/repo/doc/adr/0001-one.md', '/repo/doc/adr/0002-two.md']);
-    deps.readFile.mockResolvedValue('# Title');
-    deps.getTitleFrom.mockReturnValue('ADR Title');
-    deps.getLinksFrom.mockReturnValue([
-      { label: 'Relates to', targetNumber: '0002' },
-      { label: 'Superseded by', targetNumber: '0003' }
-    ]);
-    await run(['node', 'adr', 'generate', 'graph', '-e', '.md', '-p', '/p/'], deps);
-    const output = deps.log.mock.calls[0][0] as string;
-    expect(output).toContain('digraph');
-    expect(output).toContain('_1 -> _2 [style="dotted"');
-    expect(output).toContain('label="Relates to"');
-    expect(output).not.toContain('Superseded by');
-  });
-
-  it('generates graph output with default prefix', async () => {
-    const deps = createDeps();
-    deps.listAdrs.mockResolvedValue(['/repo/doc/adr/0001-one.md']);
-    deps.readFile.mockResolvedValue('# Title');
-    deps.getTitleFrom.mockReturnValue('ADR Title');
-    deps.getLinksFrom.mockReturnValue([]);
-    await run(['node', 'adr', 'generate', 'graph'], deps);
-    const output = deps.log.mock.calls[0][0] as string;
-    expect(output).toContain('0001-one.html');
-  });
-
-  it('links graph nodes by adr number', async () => {
-    const deps = createDeps();
-    deps.listAdrs.mockResolvedValue(['/repo/doc/adr/0001-one.md', '/repo/doc/adr/0003-three.md']);
-    deps.readFile.mockResolvedValue('# Title');
-    deps.getTitleFrom.mockReturnValue('ADR Title');
-    deps.getLinksFrom.mockReturnValue([{ label: 'Relates to', targetNumber: '3' }]);
-    await run(['node', 'adr', 'generate', 'graph'], deps);
-    const output = deps.log.mock.calls[0][0] as string;
-    expect(output).toContain('_1 -> _3 [style="dotted"');
-    expect(output).toContain('_1 -> _3 [label="Relates to"');
-  });
-
-  it('skips graph links that target missing nodes', async () => {
-    const deps = createDeps();
-    deps.listAdrs.mockResolvedValue(['/repo/doc/adr/0001-one.md']);
-    deps.readFile.mockResolvedValue('# Title');
-    deps.getTitleFrom.mockReturnValue('ADR Title');
-    deps.getLinksFrom.mockReturnValue([{ label: 'Relates to', targetNumber: '99' }]);
-    await run(['node', 'adr', 'generate', 'graph'], deps);
-    const output = deps.log.mock.calls[0][0] as string;
-    expect(output).not.toContain('_1 -> _99');
-    expect(deps.warn).toHaveBeenCalledWith('Skipping graph link from ADR 1 to missing ADR 99: Relates to');
-  });
-
-  it('skips files without numeric prefixes', async () => {
-    const deps = createDeps();
-    deps.listAdrs.mockResolvedValue(['/repo/doc/adr/notes.md', '/repo/doc/adr/0001-one.md']);
-    deps.readFile.mockResolvedValue('# Title');
-    deps.getTitleFrom.mockReturnValue('ADR Title');
-    deps.getLinksFrom.mockReturnValue([]);
-    await run(['node', 'adr', 'generate', 'graph'], deps);
-    expect(deps.readFile).toHaveBeenCalledTimes(2);
-    expect(deps.readFile).toHaveBeenNthCalledWith(1, '/repo/doc/adr/0001-one.md', 'utf8');
-    expect(deps.readFile).toHaveBeenNthCalledWith(2, '/repo/doc/adr/0001-one.md', 'utf8');
-  });
-
-  it('escapes graph labels and urls', async () => {
-    const deps = createDeps();
-    deps.listAdrs.mockResolvedValue(['/repo/doc/adr/0001-one.md']);
-    deps.readFile.mockResolvedValue('# Title');
-    deps.getTitleFrom.mockReturnValue('ADR "Title" \\\\ path\nline');
-    deps.getLinksFrom.mockReturnValue([]);
-    await run(['node', 'adr', 'generate', 'graph', '-e', '.md', '-p', '/p/"weird"/'], deps);
-    const output = deps.log.mock.calls[0][0] as string;
-    const match = output.match(/label="([\s\S]*?)"; URL="([^"]+)"/);
-    expect(match?.[1]).toContain(String.raw`ADR \"Title\" \\\\ path\\nline`);
-    expect(match?.[1]).not.toContain('\n');
-    expect(output).toContain(String.raw`URL="/p/\"weird\"/0001-one.md"`);
-  });
-
-  it('routes link command', async () => {
-    const deps = createDeps();
-    await run(['node', 'adr', 'link', '1', 'Amends', '2', 'Amended by'], deps);
-    const call = deps.link.mock.calls[0];
-    expect(call.slice(0, 4)).toEqual(['1', 'Amends', '2', 'Amended by']);
-  });
-
-  it('routes init command', async () => {
-    const deps = createDeps();
-    await run(['node', 'adr', 'init', 'doc/adr'], deps);
-    expect(deps.init).toHaveBeenCalledWith('doc/adr');
-  });
-
-  it('lists adrs relative to working dir', async () => {
-    const deps = createDeps();
-    deps.listAdrs.mockResolvedValue(['/repo/doc/adr/0001-one.md']);
-    deps.workingDir.mockReturnValue('/repo');
-    await run(['node', 'adr', 'list'], deps);
-    expect(deps.log).toHaveBeenCalledWith(path.join('doc', 'adr', '0001-one.md'));
-  });
-
-  it('collects repeated options for links and supersedes', async () => {
-    const deps = createDeps();
-    await run(
-      [
-        'node',
-        'adr',
-        'new',
-        'My',
-        'ADR',
-        '-l',
-        '1:Links:Linked by',
-        '-l',
-        '2:Relates:Related by',
-        '-s',
-        '1',
-        '-s',
-        '2'
-      ],
-      deps
-    );
-    const [, options] = deps.newAdr.mock.calls[0];
-    expect(options.links).toEqual(['1:Links:Linked by', '2:Relates:Related by']);
-    expect(options.supersedes).toEqual(['1', '2']);
-  });
-
-  it('detects direct runs based on argv', () => {
-    const indexPath = path.resolve(process.cwd(), 'src/index.ts');
-    const moduleUrl = pathToFileURL(indexPath).href;
-    expect(isDirectRun(['node', indexPath], moduleUrl)).toBe(true);
-    expect(isDirectRun(['node'], moduleUrl)).toBe(false);
-  });
-
-  it('returns false when maybeRun is not direct', () => {
-    const deps = createDeps();
-    expect(maybeRun(['node', '/other/entry'], deps)).toBe(false);
-  });
-
-  it('runs when maybeRun detects direct execution', async () => {
-    const deps = createDeps();
-    deps.listAdrs.mockResolvedValue([]);
-    const indexPath = path.resolve(process.cwd(), 'src/index.ts');
-    expect(maybeRun(['node', indexPath, 'list'], deps)).toBe(true);
-    expect(deps.listAdrs).toHaveBeenCalled();
-  });
-
-  it('handles rejected direct runs without an unhandled rejection', async () => {
-    const deps = createDeps();
-    deps.listAdrs.mockRejectedValueOnce(new Error('boom'));
-    const indexPath = path.resolve(process.cwd(), 'src/index.ts');
-
-    expect(maybeRun(['node', indexPath, 'list'], deps)).toBe(true);
-    await vi.waitFor(() => expect(deps.listAdrs).toHaveBeenCalled());
-    await new Promise<void>((resolve) => setImmediate(resolve));
-  });
-
-  it('formats errors with the default handler', () => {
-    const errorHandler = vi.fn();
-    const program = { error: errorHandler } as unknown as Command;
-    defaultOnError(program, new Error('boom'));
-    expect(errorHandler).toHaveBeenCalledWith(chalk.red('boom'), { exitCode: 1 });
-  });
-});

package/src/index.ts

@@ -1,261 +0,0 @@
-#!/usr/bin/env node
-
-import fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import chalk from 'chalk';
-import { Command } from 'commander';
-import { generateToc, init, link, listAdrs, newAdr } from './lib/adr.js';
-import { workingDir } from './lib/config.js';
-import { getLinksFrom, getTitleFrom } from './lib/manipulator.js';
-import { LIB_VERSION } from './version.js';
-
-const collectLinks = (val: string, memo: string[]) => {
-  memo.push(val);
-  return memo;
-};
-
-const collectSupersedes = (val: string, memo: string[]) => {
-  memo.push(val);
-  return memo;
-};
-
-type ProgramDeps = {
-  generateToc: typeof generateToc;
-  init: typeof init;
-  link: typeof link;
-  listAdrs: typeof listAdrs;
-  newAdr: typeof newAdr;
-  workingDir: typeof workingDir;
-  readFile: typeof fs.readFile;
-  getLinksFrom: typeof getLinksFrom;
-  getTitleFrom: typeof getTitleFrom;
-  version: string;
-  onError: (program: Command, error: Error) => void;
-  log: (message: string) => void;
-  warn: (message: string) => void;
-};
-
-export const defaultOnError = (program: Command, error: Error) => {
-  program.error(chalk.red(error.message), { exitCode: 1 });
-};
-
-const defaultDeps: ProgramDeps = {
-  generateToc,
-  init,
-  link,
-  listAdrs,
-  newAdr,
-  workingDir,
-  readFile: fs.readFile,
-  getLinksFrom,
-  getTitleFrom,
-  version: LIB_VERSION,
-  onError: defaultOnError,
-  log: console.log,
-  warn: console.warn
-};
-
-const escapeDotString = (value: string) =>
-  value
-    .replace(/\\/g, '\\\\')
-    .replace(/"/g, '\\"')
-    .replace(/\r\n|\n|\r/g, '\\\\n');
-
-const getAdrNumberFromPath = (adrPath: string): number | undefined => {
-  const baseName = path.basename(adrPath, '.md');
-  const match = baseName.match(/^0*(\d+)-/);
-  if (!match) {
-    return undefined;
-  }
-  return Number.parseInt(match[1], 10);
-};
-
-type GraphNode = { adrPath: string; number: number };
-
-const resolveGraphNodes = (adrs: string[]): GraphNode[] =>
-  adrs
-    .map((adrPath) => ({ adrPath, number: getAdrNumberFromPath(adrPath) }))
-    .filter((node): node is GraphNode => node.number !== undefined);
-
-const appendGraphNodes = async (
-  deps: ProgramDeps,
-  nodes: GraphNode[],
-  options: { prefix?: string; extension?: string } | undefined,
-  lines: string[]
-) => {
-  for (let i = 0; i < nodes.length; i++) {
-    const n = nodes[i].number;
-    const adrPath = nodes[i].adrPath;
-    const contents = await deps.readFile(adrPath, 'utf8');
-    const title = deps.getTitleFrom(contents);
-    const url = `${options?.prefix || ''}${path.basename(adrPath, '.md')}${options?.extension}`;
-    lines.push(`    _${n} [label="${escapeDotString(title)}"; URL="${escapeDotString(url)}"];`);
-    const previous = nodes[i - 1]?.number;
-    if (previous !== undefined) {
-      lines.push(`    _${previous} -> _${n} [style="dotted", weight=1];`);
-    }
-  }
-};
-
-const resolveTargetNodeId = (nodeIds: Set<number>, targetNumber: string): number | undefined => {
-  const number = Number.parseInt(targetNumber, 10);
-  if (!Number.isFinite(number) || !nodeIds.has(number)) {
-    return undefined;
-  }
-  return number;
-};
-
-const appendGraphEdges = async (deps: ProgramDeps, nodes: GraphNode[], lines: string[]) => {
-  const nodeIds = new Set(nodes.map((node) => node.number));
-  for (const node of nodes) {
-    const contents = await deps.readFile(node.adrPath, 'utf8');
-    const linksInADR = deps.getLinksFrom(contents);
-    for (const link of linksInADR) {
-      if (link.label.endsWith('by')) {
-        continue;
-      }
-      const target = resolveTargetNodeId(nodeIds, link.targetNumber);
-      if (target !== undefined) {
-        lines.push(`  _${node.number} -> _${target} [label="${link.label}", weight=0]`);
-      } else {
-        deps.warn(`Skipping graph link from ADR ${node.number} to missing ADR ${link.targetNumber}: ${link.label}`);
-      }
-    }
-  }
-};
-
-const generateGraph = async (deps: ProgramDeps, options?: { prefix: string; extension: string }) => {
-  const lines: string[] = [];
-  lines.push('digraph {');
-  lines.push('  node [shape=plaintext];');
-  lines.push('  subgraph {');
-
-  const adrs = await deps.listAdrs();
-  const nodes = resolveGraphNodes(adrs);
-  await appendGraphNodes(deps, nodes, options, lines);
-
-  lines.push('  }');
-  await appendGraphEdges(deps, nodes, lines);
-  lines.push('}');
-
-  deps.log(`${lines.join('\n')}\n`);
-};
-
-export const buildProgram = (deps: ProgramDeps = defaultDeps) => {
-  const program = new Command();
-  program.name('adr').version(deps.version).description('Manage Architecture Decision Logs');
-
-  program
-    .command('new')
-    .argument('<title...>', 'The title of the decision')
-    .option(
-      '-q, --quiet',
-      'Do not ask for clarification. If multiple files match the search pattern, an error will be thrown.'
-    )
-    .option('--open', 'Open the created ADR after writing it (use OS default or `--open-with`).')
-    .option(
-      '--open-with <COMMAND>',
-      'Open the created ADR with a specific command (optionally with args); implies `--open`.'
-    )
-    .option(
-      '-s, --supersede <SUPERSEDE>',
-      'A reference (number or partial filename) of a previous decision that the new decision supercedes.\n' +
-        'A Markdown link to the superceded ADR is inserted into the Status section.\n' +
-        'The status of the superceded ADR is changed to record that it has been superceded by the new ADR.',
-      collectSupersedes,
-      []
-    )
-    .option(
-      '-l, --link "<TARGET:LINK:REVERSE-LINK>"',
-      'Links the new ADR to a previous ADR.\n' +
-        `${chalk.bold('TARGET')} is a reference (number or partial filename) of a previous decision.\n` +
-        `${chalk.bold('LINK')} is the description of the link created in the new ADR.\n` +
-        `${chalk.bold('REVERSE-LINK')} is the description of the link created in the existing ADR that will refer to the new ADR`,
-      collectLinks,
-      []
-    )
-    .action(async (title: string[], options) => {
-      try {
-        await deps.newAdr(title.join(' '), {
-          supersedes: options.supersede,
-          date: process.env.ADR_DATE,
-          suppressPrompts: options.quiet || false,
-          links: options.link,
-          open: options.open || Boolean(options.openWith),
-          openWith: options.openWith
-        });
-      } catch (e) {
-        deps.onError(program, e as Error);
-      }
-    });
-
-  const generate = program.command('generate');
-
-  generate
-    .command('toc')
-    .option('-p, --prefix <PREFIX>', 'The prefix to use for each file link in the generated TOC.')
-    .action((options) => deps.generateToc(options));
-
-  generate
-    .command('graph')
-    .option('-p, --prefix <PREFIX>', 'Prefix each decision file link with PREFIX.')
-    .option(
-      '-e, --extension <EXTENSION>',
-      'the file extension of the documents to which generated links refer. Defaults to .html',
-      '.html'
-    )
-    .action(async (options) => {
-      await generateGraph(deps, options);
-    });
-
-  program
-    .command('link')
-    .argument('<SOURCE>', 'Full or Partial reference number to an ADR')
-    .argument('<LINK>', 'The description of the link created in the SOURCE')
-    .argument('<TARGET>', 'Full or Partial reference number to an ADR')
-    .argument('<REVERSE-LINK>', 'The description of the link created in the TARGET')
-    .option(
-      '-q, --quiet',
-      'Do not ask for clarification. If multiple files match the search pattern, an error will be thrown.'
-    )
-    .action(deps.link);
-
-  program
-    .command('init')
-    .argument('[directory]', 'Initialize a new ADR directory')
-    .action(async (directory?: string) => {
-      await deps.init(directory);
-    });
-
-  program.command('list').action(async () => {
-    const adrs = await deps.listAdrs();
-    deps.log(adrs.map((adr) => path.relative(deps.workingDir(), adr)).join('\n'));
-  });
-
-  return program;
-};
-
-export const run = async (argv = process.argv, deps: ProgramDeps = defaultDeps) => {
-  const program = buildProgram(deps);
-  await program.parseAsync(argv);
-  return program;
-};
-
-export const isDirectRun = (argv = process.argv, moduleUrl = import.meta.url) => {
-  if (!argv[1]) {
-    return false;
-  }
-  return path.resolve(argv[1]) === fileURLToPath(moduleUrl);
-};
-
-export const maybeRun = (argv = process.argv, deps?: ProgramDeps) => {
-  if (!isDirectRun(argv)) {
-    return false;
-  }
-  const runPromise = run(argv, deps);
-  runPromise.catch(() => undefined);
-  return true;
-};
-
-maybeRun();