@meza/adr-tools 1.0.12 → 2.0.1

package/src/lib/adr.test.ts

@@ -0,0 +1,376 @@
+import fs from 'fs/promises';
+import open from 'open';
+import path from 'path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { generateToc, init, link, listAdrs, newAdr } from './adr.js';
+import { getDir, workingDir } from './config.js';
+import { findMatchingFilesFor, getLinkDetails } from './links.js';
+import { getTitleFrom, injectLink, supersede } from './manipulator.js';
+import { newNumber } from './numbering.js';
+import { askForClarification } from './prompt.js';
+import { template } from './template.js';
+
+vi.mock('fs/promises', () => ({
+  default: {
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    readdir: vi.fn(),
+    mkdir: vi.fn()
+  }
+}));
+vi.mock('open', () => ({ default: vi.fn() }));
+vi.mock('./config.js', () => ({
+  getDir: vi.fn(),
+  workingDir: vi.fn()
+}));
+vi.mock('./links.js', () => ({
+  getLinkDetails: vi.fn(),
+  findMatchingFilesFor: vi.fn()
+}));
+vi.mock('./manipulator.js', () => ({
+  getTitleFrom: vi.fn(),
+  injectLink: vi.fn(),
+  supersede: vi.fn()
+}));
+vi.mock('./numbering.js', () => ({
+  newNumber: vi.fn()
+}));
+vi.mock('./prompt.js', () => ({
+  askForClarification: vi.fn()
+}));
+vi.mock('./template.js', () => ({
+  template: vi.fn()
+}));
+
+describe('adr helpers', () => {
+  const mockReaddir = vi.mocked(fs.readdir) as unknown as {
+    mockResolvedValueOnce: (value: string[]) => void;
+  };
+
+  afterEach(() => {
+    vi.resetAllMocks();
+    vi.unstubAllEnvs();
+  });
+
+  it('generates the toc from adr files', async () => {
+    vi.mocked(getDir).mockResolvedValueOnce('/repo/doc/adr');
+    mockReaddir.mockResolvedValueOnce(['0001-first.md', 'notes.txt']);
+    vi.mocked(fs.readFile).mockResolvedValueOnce('# First ADR');
+    vi.mocked(getTitleFrom).mockReturnValueOnce('ADR 1: First');
+
+    await generateToc({ prefix: '/p/' });
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      path.resolve('/repo/doc/adr', 'decisions.md'),
+      '# Table of Contents\n\n- [ADR 1: First](/p/0001-first.md)'
+    );
+  });
+
+  it('generates the toc without a prefix', async () => {
+    vi.mocked(getDir).mockResolvedValueOnce('/repo/doc/adr');
+    mockReaddir.mockResolvedValueOnce(['0001-first.md']);
+    vi.mocked(fs.readFile).mockResolvedValueOnce('# First ADR');
+    vi.mocked(getTitleFrom).mockReturnValueOnce('ADR 1: First');
+
+    await generateToc();
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      path.resolve('/repo/doc/adr', 'decisions.md'),
+      '# Table of Contents\n\n- [ADR 1: First](0001-first.md)'
+    );
+  });
+
+  it('includes ADRs with more than four digits', async () => {
+    vi.mocked(getDir).mockResolvedValueOnce('/repo/doc/adr');
+    mockReaddir.mockResolvedValueOnce(['10000-future.md']);
+    vi.mocked(fs.readFile).mockResolvedValueOnce('# Future ADR');
+    vi.mocked(getTitleFrom).mockReturnValueOnce('ADR 10000: Future');
+
+    await generateToc();
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      path.resolve('/repo/doc/adr', 'decisions.md'),
+      '# Table of Contents\n\n- [ADR 10000: Future](10000-future.md)'
+    );
+  });
+
+  it('excludes ADRs with fewer than four digits', async () => {
+    vi.mocked(getDir).mockResolvedValueOnce('/repo/doc/adr');
+    mockReaddir.mockResolvedValueOnce(['123-short.md', '0001-first.md']);
+    vi.mocked(fs.readFile).mockResolvedValueOnce('# First ADR');
+    vi.mocked(getTitleFrom).mockReturnValueOnce('ADR 1: First');
+
+    await generateToc();
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      path.resolve('/repo/doc/adr', 'decisions.md'),
+      '# Table of Contents\n\n- [ADR 1: First](0001-first.md)'
+    );
+  });
+
+  it('creates a new adr without opening', async () => {
+    vi.mocked(newNumber).mockResolvedValueOnce(1);
+    vi.mocked(template).mockResolvedValueOnce('DATE\nTITLE\nNUMBER\nSTATUS\n');
+    vi.mocked(getDir).mockResolvedValue('/repo/doc/adr');
+    mockReaddir.mockResolvedValueOnce([]);
+
+    await newAdr('Example ADR', { open: false, date: 'DATE' });
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      path.resolve('/repo/doc/adr', '0001-example-adr.md'),
+      'DATE\nExample ADR\n1\nAccepted\n'
+    );
+    expect(open).not.toHaveBeenCalled();
+  });
+
+  it('falls back to error date when the system date is empty', async () => {
+    const dateSpy = vi.spyOn(Date.prototype, 'toISOString').mockReturnValue('');
+    vi.mocked(newNumber).mockResolvedValueOnce(1);
+    vi.mocked(template).mockResolvedValueOnce('DATE\nTITLE\nNUMBER\nSTATUS\n');
+    vi.mocked(getDir).mockResolvedValue('/repo/doc/adr');
+    mockReaddir.mockResolvedValueOnce([]);
+
+    await newAdr('Example ADR', { open: false });
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      path.resolve('/repo/doc/adr', '0001-example-adr.md'),
+      'ERROR\nExample ADR\n1\nAccepted\n'
+    );
+    dateSpy.mockRestore();
+  });
+
+  it('opens adr using open-with when provided', async () => {
+    vi.mocked(newNumber).mockResolvedValueOnce(1);
+    vi.mocked(template).mockResolvedValueOnce('DATE\nTITLE\nNUMBER\nSTATUS\n');
+    vi.mocked(getDir).mockResolvedValue('/repo/doc/adr');
+    mockReaddir.mockResolvedValueOnce([]);
+
+    await newAdr('Example ADR', { openWith: 'code --wait' });
+    const adrPath = path.resolve('/repo/doc/adr', '0001-example-adr.md');
+    expect(open).toHaveBeenCalledWith(adrPath, {
+      app: { name: 'code', arguments: ['--wait'] },
+      wait: false
+    });
+  });
+
+  it('opens adr with default opener when enabled without an editor', async () => {
+    vi.mocked(newNumber).mockResolvedValueOnce(1);
+    vi.mocked(template).mockResolvedValueOnce('DATE\nTITLE\nNUMBER\nSTATUS\n');
+    vi.mocked(getDir).mockResolvedValue('/repo/doc/adr');
+    mockReaddir.mockResolvedValueOnce([]);
+
+    await newAdr('Example ADR', { open: true });
+    expect(open).toHaveBeenCalledWith(path.resolve('/repo/doc/adr', '0001-example-adr.md'), { wait: false });
+  });
+
+  it('uses open on windows for open-with', async () => {
+    const originalPlatform = process.platform;
+    Object.defineProperty(process, 'platform', { value: 'win32' });
+    vi.mocked(newNumber).mockResolvedValueOnce(1);
+    vi.mocked(template).mockResolvedValueOnce('DATE\nTITLE\nNUMBER\nSTATUS\n');
+    vi.mocked(getDir).mockResolvedValue('/repo/doc/adr');
+    mockReaddir.mockResolvedValueOnce([]);
+
+    try {
+      await newAdr('Example ADR', { openWith: 'code --wait' });
+      expect(open).toHaveBeenCalledWith(path.resolve('/repo/doc/adr', '0001-example-adr.md'), {
+        app: { name: 'code', arguments: ['--wait'] },
+        wait: false
+      });
+    } finally {
+      Object.defineProperty(process, 'platform', { value: originalPlatform });
+    }
+  });
+
+  it('links superseded adrs when provided', async () => {
+    vi.mocked(newNumber).mockResolvedValueOnce(2);
+    vi.mocked(template).mockResolvedValueOnce('DATE\nTITLE\nNUMBER\nSTATUS\n');
+    vi.mocked(getDir).mockResolvedValue('/repo/doc/adr');
+    mockReaddir.mockResolvedValueOnce([]);
+    vi.mocked(fs.readFile).mockResolvedValue('# ADR\n');
+    vi.mocked(getTitleFrom).mockReturnValue('ADR Title');
+    vi.mocked(getLinkDetails).mockResolvedValueOnce({
+      link: 'Supersedes',
+      reverseLink: 'Superseded by',
+      matches: ['0001-first.md'],
+      original: '1',
+      pattern: '1'
+    });
+
+    await newAdr('Next ADR', { supersedes: ['1'] });
+    expect(supersede).toHaveBeenCalled();
+    expect(injectLink).toHaveBeenCalled();
+  });
+
+  it('asks for clarification when multiple supersede matches exist', async () => {
+    vi.mocked(newNumber).mockResolvedValueOnce(2);
+    vi.mocked(template).mockResolvedValueOnce('DATE\nTITLE\nNUMBER\nSTATUS\n');
+    vi.mocked(getDir).mockResolvedValue('/repo/doc/adr');
+    mockReaddir.mockResolvedValueOnce([]);
+    vi.mocked(fs.readFile).mockResolvedValue('# ADR\n');
+    vi.mocked(getTitleFrom).mockReturnValue('ADR Title');
+    vi.mocked(getLinkDetails).mockResolvedValueOnce({
+      link: 'Supersedes',
+      reverseLink: 'Superseded by',
+      matches: ['0001-first.md', '0001-other.md'],
+      original: '1',
+      pattern: '1'
+    });
+    vi.mocked(askForClarification).mockResolvedValue('0001-other.md');
+
+    await newAdr('Next ADR', { supersedes: ['1'] });
+    expect(askForClarification).toHaveBeenCalled();
+  });
+
+  it('throws when multiple supersede matches exist in quiet mode', async () => {
+    vi.mocked(newNumber).mockResolvedValueOnce(2);
+    vi.mocked(template).mockResolvedValueOnce('DATE\nTITLE\nNUMBER\nSTATUS\n');
+    vi.mocked(getDir).mockResolvedValue('/repo/doc/adr');
+    mockReaddir.mockResolvedValueOnce([]);
+    vi.mocked(getLinkDetails).mockResolvedValueOnce({
+      link: 'Supersedes',
+      reverseLink: 'Superseded by',
+      matches: ['0001-first.md', '0001-other.md'],
+      original: '1',
+      pattern: '1'
+    });
+
+    await expect(newAdr('Next ADR', { supersedes: ['1'], suppressPrompts: true })).rejects.toThrow(
+      'Multiple files match the search pattern'
+    );
+  });
+
+  it('links related adrs when provided', async () => {
+    vi.mocked(newNumber).mockResolvedValueOnce(2);
+    vi.mocked(template).mockResolvedValueOnce('DATE\nTITLE\nNUMBER\nSTATUS\n');
+    vi.mocked(getDir).mockResolvedValue('/repo/doc/adr');
+    mockReaddir.mockResolvedValueOnce([]);
+    vi.mocked(fs.readFile).mockResolvedValue('# ADR\n');
+    vi.mocked(getTitleFrom).mockReturnValue('ADR Title');
+    vi.mocked(getLinkDetails).mockResolvedValueOnce({
+      link: 'Relates to',
+      reverseLink: 'Related by',
+      matches: ['0001-first.md'],
+      original: '1:Relates to:Related by',
+      pattern: '1'
+    });
+
+    await newAdr('Next ADR', { links: ['1:Relates to:Related by'] });
+    expect(injectLink).toHaveBeenCalled();
+  });
+
+  it('asks for clarification when multiple link matches exist', async () => {
+    vi.mocked(newNumber).mockResolvedValueOnce(2);
+    vi.mocked(template).mockResolvedValueOnce('DATE\nTITLE\nNUMBER\nSTATUS\n');
+    vi.mocked(getDir).mockResolvedValue('/repo/doc/adr');
+    mockReaddir.mockResolvedValueOnce([]);
+    vi.mocked(fs.readFile).mockResolvedValue('# ADR\n');
+    vi.mocked(getTitleFrom).mockReturnValue('ADR Title');
+    vi.mocked(getLinkDetails).mockResolvedValueOnce({
+      link: 'Relates to',
+      reverseLink: 'Related by',
+      matches: ['0001-first.md', '0001-other.md'],
+      original: '1:Relates to:Related by',
+      pattern: '1'
+    });
+    vi.mocked(askForClarification).mockResolvedValue('0001-first.md');
+
+    await newAdr('Next ADR', { links: ['1:Relates to:Related by'] });
+    expect(askForClarification).toHaveBeenCalled();
+  });
+
+  it('initializes a new adr directory', async () => {
+    vi.mocked(getDir).mockResolvedValue('/repo/doc/adr');
+    vi.mocked(workingDir).mockReturnValue('/repo');
+    vi.mocked(newNumber).mockResolvedValue(1);
+    vi.mocked(template).mockResolvedValue('DATE\nTITLE\nNUMBER\nSTATUS\n');
+    mockReaddir.mockResolvedValueOnce([]);
+
+    await init('/repo/doc/adr');
+    expect(fs.mkdir).toHaveBeenCalledWith('/repo/doc/adr', { recursive: true });
+    expect(fs.writeFile).toHaveBeenCalledWith(path.join('/repo', '.adr-dir'), path.join('doc', 'adr'));
+  });
+
+  it('initializes using default directory when none provided', async () => {
+    vi.mocked(getDir).mockResolvedValue('/repo/doc/adr');
+    vi.mocked(workingDir).mockReturnValue('/repo');
+    vi.mocked(newNumber).mockResolvedValue(1);
+    vi.mocked(template).mockResolvedValue('DATE\nTITLE\nNUMBER\nSTATUS\n');
+    mockReaddir.mockResolvedValueOnce([]);
+
+    await init();
+    expect(fs.mkdir).toHaveBeenCalledWith('/repo/doc/adr', { recursive: true });
+  });
+
+  it('links adrs with explicit command', async () => {
+    vi.mocked(findMatchingFilesFor).mockResolvedValueOnce(['0001-first.md']);
+    vi.mocked(getDir).mockResolvedValue('/repo/doc/adr');
+    vi.mocked(fs.readFile).mockResolvedValue('# ADR\n');
+    vi.mocked(getTitleFrom).mockReturnValue('ADR Title');
+    vi.mocked(getLinkDetails).mockResolvedValueOnce({
+      link: 'Relates to',
+      reverseLink: 'Related by',
+      matches: ['0002-second.md'],
+      original: '2:Relates to:Related by',
+      pattern: '2'
+    });
+
+    await link('0001-first.md', 'Relates to', '2', 'Related by');
+    expect(injectLink).toHaveBeenCalled();
+  });
+
+  it('asks for clarification when multiple link sources exist', async () => {
+    vi.mocked(findMatchingFilesFor).mockResolvedValueOnce(['0001-first.md', '0001-second.md']);
+    vi.mocked(askForClarification).mockResolvedValueOnce('0001-first.md');
+    vi.mocked(getDir).mockResolvedValue('/repo/doc/adr');
+    vi.mocked(fs.readFile).mockResolvedValue('# ADR\n');
+    vi.mocked(getTitleFrom).mockReturnValue('ADR Title');
+    vi.mocked(getLinkDetails).mockResolvedValueOnce({
+      link: 'Relates to',
+      reverseLink: 'Related by',
+      matches: ['0002-second.md'],
+      original: '2:Relates to:Related by',
+      pattern: '2'
+    });
+
+    await link('0001', 'Relates to', '2', 'Related by');
+    expect(askForClarification).toHaveBeenCalled();
+  });
+
+  it('throws when multiple link matches exist in quiet mode', async () => {
+    vi.mocked(findMatchingFilesFor).mockResolvedValueOnce(['0001-first.md', '0001-second.md']);
+    await expect(link('0001', 'Relates', '2', 'Related by', { quiet: true })).rejects.toThrow(
+      'Multiple files match the search pattern'
+    );
+  });
+
+  it('throws when multiple link matches exist in quiet mode for newAdr links', async () => {
+    vi.mocked(newNumber).mockResolvedValueOnce(2);
+    vi.mocked(template).mockResolvedValueOnce('DATE\nTITLE\nNUMBER\nSTATUS\n');
+    vi.mocked(getDir).mockResolvedValue('/repo/doc/adr');
+    vi.mocked(fs.readdir).mockResolvedValue([]);
+    vi.mocked(getLinkDetails).mockResolvedValueOnce({
+      link: 'Relates to',
+      reverseLink: 'Related by',
+      matches: ['0001-first.md', '0001-second.md'],
+      original: '1:Relates to:Related by',
+      pattern: '1'
+    });
+
+    await expect(newAdr('Next ADR', { links: ['1:Relates to:Related by'], suppressPrompts: true })).rejects.toThrow(
+      'Multiple files match the search pattern'
+    );
+  });
+
+  it('lists adr files only', async () => {
+    vi.mocked(getDir).mockResolvedValue('/repo/doc/adr');
+    mockReaddir.mockResolvedValueOnce(['0001-first.md', 'notes.txt']);
+    const result = await listAdrs();
+    expect(result).toEqual([path.resolve('/repo/doc/adr', '0001-first.md')]);
+  });
+
+  it('lists adr files sorted by number', async () => {
+    vi.mocked(getDir).mockResolvedValue('/repo/doc/adr');
+    mockReaddir.mockResolvedValueOnce(['0010-ten.md', '0002-two.md', 'notes.txt', '0001-one.md']);
+    const result = await listAdrs();
+    expect(result).toEqual([
+      path.resolve('/repo/doc/adr', '0001-one.md'),
+      path.resolve('/repo/doc/adr', '0002-two.md'),
+      path.resolve('/repo/doc/adr', '0010-ten.md')
+    ]);
+  });
+});

package/src/lib/adr.ts

@@ -1,4 +1,3 @@
-import childProcess from 'node:child_process';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import fs from 'fs/promises';
@@ -11,12 +10,170 @@ import { template } from './template.js';
 
 const __filename = fileURLToPath(import.meta.url);
 
+const normalizeEditorCommand = (raw: string | undefined): string | undefined => {
+  if (!raw) {
+    return undefined;
+  }
+
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+
+  const unquoted = trimmed.replace(/^['"](.+)['"]$/, '$1').trim();
+  if (!unquoted) {
+    return undefined;
+  }
+
+  const lowered = unquoted.toLowerCase();
+  if (lowered === 'true' || lowered === 'false') {
+    return undefined;
+  }
+
+  return unquoted;
+};
+
+const unescapeDoubleQuoted = (value: string): string => {
+  let result = '';
+  for (let i = 0; i < value.length; i++) {
+    const ch = value[i];
+    if (ch === '\\' && i + 1 < value.length) {
+      const next = value[i + 1];
+      if (next === '\\' || next === '"') {
+        result += next;
+        i++;
+        continue;
+      }
+    }
+    result += ch;
+  }
+  return result;
+};
+
+const splitCommandLine = (commandLine: string): string[] => {
+  const tokens = commandLine.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g);
+  if (!tokens) {
+    return [];
+  }
+
+  return tokens.map((token) => {
+    if (token.startsWith('"') && token.endsWith('"')) {
+      return unescapeDoubleQuoted(token.slice(1, -1));
+    }
+
+    if (token.startsWith("'") && token.endsWith("'")) {
+      return token.slice(1, -1);
+    }
+
+    return token;
+  });
+};
+
+type OpenPlan = { type: 'none' } | { type: 'default' } | { type: 'app'; name: string; args: string[] };
+
+const openAdr = async (
+  adrPath: string,
+  options: { app?: { name: string; arguments: string[] }; wait: false },
+  openPromise: Promise<typeof import('open')>
+) => {
+  const { default: open } = await openPromise;
+  await open(adrPath, options);
+};
+
+const resolveOpenPlan = (config?: NewOptions): OpenPlan => {
+  if (!config || (config.open === undefined && !config.openWith)) {
+    return chooseOpenPlan(undefined);
+  }
+
+  return chooseOpenPlan({
+    ...(config.open !== undefined ? { open: config.open } : {}),
+    ...(config.openWith ? { openWith: config.openWith } : {})
+  });
+};
+
+const shouldLoadOpenLibrary = (openPlan: OpenPlan) => openPlan.type !== 'none';
+
+const openNewAdr = async (openPlan: OpenPlan, adrPath: string, openPromise?: Promise<typeof import('open')>) => {
+  if (openPlan.type === 'none') {
+    return;
+  }
+
+  if (openPlan.type === 'default') {
+    await openAdr(adrPath, { wait: false }, openPromise!);
+    return;
+  }
+
+  await openAdr(adrPath, { app: { name: openPlan.name, arguments: openPlan.args }, wait: false }, openPromise!);
+};
+
+const equalsIgnoreCase = (a: string, b: string) => a.toLowerCase() === b.toLowerCase();
+
+const isNpmInjectedEditor = (editor: string) => {
+  const env = process.env as NodeJS.ProcessEnv & {
+    npm_config_editor?: string;
+    npm_execpath?: string;
+  };
+  const npmEditor = normalizeEditorCommand(env.npm_config_editor);
+  if (!npmEditor) {
+    return false;
+  }
+
+  if (!equalsIgnoreCase(editor, npmEditor)) {
+    return false;
+  }
+
+  return Boolean(env.npm_execpath);
+};
+
+const toAppPlan = (commandLine: string | undefined): OpenPlan | undefined => {
+  const normalized = normalizeEditorCommand(commandLine);
+  if (!normalized) {
+    return undefined;
+  }
+
+  const [name, ...args] = splitCommandLine(normalized);
+  if (!name) {
+    return undefined;
+  }
+
+  return { type: 'app', name, args };
+};
+
+export const chooseOpenPlan = (options?: { open?: boolean; openWith?: string }): OpenPlan => {
+  const openWithPlan = toAppPlan(options?.openWith);
+  const shouldOpen = Boolean(options?.open) || Boolean(openWithPlan);
+  if (!shouldOpen) {
+    return { type: 'none' };
+  }
+
+  if (openWithPlan) {
+    return openWithPlan;
+  }
+
+  const visualPlan = toAppPlan(process.env.VISUAL);
+  if (visualPlan) {
+    return visualPlan;
+  }
+
+  const editorCommand = normalizeEditorCommand(process.env.EDITOR);
+  if (editorCommand && !isNpmInjectedEditor(editorCommand)) {
+    const editorPlan = toAppPlan(editorCommand);
+    if (editorPlan) {
+      return editorPlan;
+    }
+  }
+
+  return { type: 'default' };
+};
+
 interface NewOptions {
   supersedes?: string[];
   date?: string | undefined;
   suppressPrompts?: boolean;
   template?: string;
   links?: string[];
+  open?: boolean;
+  openWith?: string;
 }
 
 // eslint-disable-next-line no-unused-vars
@@ -58,8 +215,6 @@ const actuallyLink = async (task: LinkTask) => {
       );
       dirtyNew = injectLink(newAdrContent, `${task.link} [${oldTitle}](${task.targetPath})`);
       break;
-    default:
-      break;
   }
 
   await fs.writeFile(linkedFile, dirtyOld);
@@ -129,7 +284,7 @@ const injectLinksTo = async (sourcePath: string, links: string[] = [], suppressP
 export const generateToc = async (options?: { prefix?: string }) => {
   const adrDir = await getDir();
   const files = await fs.readdir(adrDir);
-  const toc = files.filter((file) => file.match(/^\d{4}-.*\.md$/)).sort();
+  const toc = files.filter((file) => file.match(/^\d{4,}-.*\.md$/)).sort();
 
   const titles = toc.map(async (file) => {
     const title = getTitleFrom(await fs.readFile(path.join(adrDir, file), 'utf8'));
@@ -143,6 +298,9 @@ export const generateToc = async (options?: { prefix?: string }) => {
 };
 
 export const newAdr = async (title: string, config?: NewOptions) => {
+  const openPlan = resolveOpenPlan(config);
+  const openPromise = shouldLoadOpenLibrary(openPlan) ? import('open') : undefined;
+
   const newNum = await newNumber();
   const formattedDate = config?.date || new Date().toISOString().split('T')[0] || 'ERROR';
   const tpl = await template(config?.template);
@@ -152,11 +310,7 @@ export const newAdr = async (title: string, config?: NewOptions) => {
     .replace('NUMBER', newNum.toString())
     .replace('STATUS', 'Accepted');
   const paddedNumber = newNum.toString().padStart(4, '0');
-  const cleansedTitle = title
-    .toLowerCase()
-    .replace(/\W/g, '-')
-    .replace(/^(.*)\W$/, '$1')
-    .replace(/^\W(.*)$/, '$1');
+  const cleansedTitle = title.toLowerCase().replace(/\W+/g, '-').replace(/^-+/, '').replace(/-+$/, '');
   const fileName = `${paddedNumber}-${cleansedTitle}.md`;
   const adrDirectory = await getDir();
   const adrPath = path.resolve(path.join(adrDirectory, fileName));
@@ -167,20 +321,7 @@ export const newAdr = async (title: string, config?: NewOptions) => {
   await injectLinksTo(adrPath, config?.links, config?.suppressPrompts);
   await generateToc();
 
-  if (process.env.VISUAL) {
-    await childProcess.spawn(process.env.VISUAL, [adrPath], {
-      stdio: 'inherit',
-      shell: true
-    });
-    return;
-  }
-  if (process.env.EDITOR) {
-    await childProcess.spawn(process.env.EDITOR, [adrPath], {
-      stdio: 'inherit',
-      shell: true
-    });
-    return;
-  }
+  await openNewAdr(openPlan, adrPath, openPromise);
 };
 
 export const init = async (directory?: string) => {
@@ -227,11 +368,16 @@ export const listAdrs = async () => {
   const toc = files
     .map((f) => {
       const adrFile = f.match(/^0*(\d+)-.*$/);
-      if (adrFile) {
-        return path.resolve(dir, adrFile[0]);
+      if (!adrFile) {
+        return null;
       }
-      return '';
+      return {
+        number: Number.parseInt(adrFile[1], 10),
+        path: path.resolve(dir, adrFile[0])
+      };
     })
-    .filter((f) => f !== '');
+    .filter((entry): entry is { number: number; path: string } => Boolean(entry))
+    .sort((a, b) => a.number - b.number)
+    .map((entry) => entry.path);
   return toc;
 };