@aaronshaf/confluence-cli 0.1.15 → 1.0.0

package/src/lib/dependency-sorter.ts

@@ -1,233 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { dirname, join, normalize, relative } from 'node:path';
-import type { PushCandidate } from './file-scanner.js';
-
-/**
- * Extract all local markdown links from content.
- *
- * Matches markdown links like [text](path.md) but excludes:
- * - http:// and https:// URLs
- * - Links to non-.md files
- *
- * @param content - Markdown content to extract links from
- * @returns Array of relative paths (as written in the markdown)
- */
-export function extractLocalLinks(content: string): string[] {
-  // Match markdown links: [text](path.md) or [text](path.md#anchor)
-  // The text part can contain nested brackets (e.g., [text [nested]](link.md))
-  // Pattern explanation:
-  // \[([^\[\]]+(?:\[[^\]]*\][^\[\]]*)*)\] - Match [text] allowing nested brackets
-  // \(([^)#]+\.md)(?:#[^)]*)?\) - Match (path.md) or (path.md#anchor)
-  const linkPattern = /\[([^[\]]+(?:\[[^\]]*\][^[\]]*)*)\]\(([^)#]+\.md)(?:#[^)]*)?\)/g;
-
-  const links: string[] = [];
-  let match: RegExpExecArray | null;
-
-  while ((match = linkPattern.exec(content)) !== null) {
-    const linkPath = match[2];
-
-    // Skip external URLs
-    if (linkPath.startsWith('http://') || linkPath.startsWith('https://')) {
-      continue;
-    }
-
-    // Remove any anchor fragments (e.g., file.md#section -> file.md)
-    const pathWithoutAnchor = linkPath.split('#')[0];
-
-    links.push(pathWithoutAnchor);
-  }
-
-  return links;
-}
-
-/**
- * Resolve a link path relative to the source file's directory.
- *
- * @param linkPath - The link path as written in markdown
- * @param sourceFilePath - The path of the file containing the link (relative to directory)
- * @returns Normalized path relative to directory root
- */
-function resolveLinkPath(linkPath: string, sourceFilePath: string): string {
-  // Get the directory containing the source file
-  const sourceDir = dirname(sourceFilePath);
-
-  // Join and normalize the path
-  const resolvedPath = normalize(join(sourceDir, linkPath));
-
-  return resolvedPath;
-}
-
-/**
- * Sort push candidates by dependencies so linked-to pages are pushed first.
- *
- * Uses Kahn's algorithm for topological sorting with cycle detection.
- * If cycles are detected, the files involved in cycles are still included
- * in the output (in their original relative order).
- *
- * @param candidates - Array of push candidates to sort
- * @param directory - Root directory for resolving file paths
- * @returns Object containing:
- *   - sorted: Candidates sorted so dependencies come first
- *   - cycles: Array of detected cycles (each cycle is array of paths)
- */
-export function sortByDependencies(
-  candidates: PushCandidate[],
-  directory: string,
-): { sorted: PushCandidate[]; cycles: string[][] } {
-  // Build a set of candidate paths for quick lookup
-  const candidatePaths = new Set(candidates.map((c) => c.path));
-
-  // Build dependency graph: file -> files it depends on (links to)
-  // dependsOn[A] = [B, C] means A links to B and C
-  const dependsOn = new Map<string, Set<string>>();
-
-  // Build reverse graph: file -> files that depend on it (link to it)
-  // dependedBy[B] = [A] means A links to B
-  const dependedBy = new Map<string, Set<string>>();
-
-  // Initialize maps for all candidates
-  for (const candidate of candidates) {
-    dependsOn.set(candidate.path, new Set());
-    dependedBy.set(candidate.path, new Set());
-  }
-
-  // Read each candidate's content and extract dependencies
-  for (const candidate of candidates) {
-    const fullPath = join(directory, candidate.path);
-
-    let content: string;
-    try {
-      content = readFileSync(fullPath, 'utf-8');
-    } catch {
-      // If we can't read the file, skip dependency analysis for it
-      continue;
-    }
-
-    const links = extractLocalLinks(content);
-
-    for (const link of links) {
-      // Resolve the link relative to the candidate's location
-      const resolvedLink = resolveLinkPath(link, candidate.path);
-
-      // Only track dependencies that are also candidates
-      if (candidatePaths.has(resolvedLink)) {
-        // candidate.path depends on resolvedLink
-        dependsOn.get(candidate.path)?.add(resolvedLink);
-        dependedBy.get(resolvedLink)?.add(candidate.path);
-      }
-    }
-  }
-
-  // Kahn's algorithm for topological sort
-  // Start with nodes that have no dependencies
-  const sorted: PushCandidate[] = [];
-  const candidateMap = new Map(candidates.map((c) => [c.path, c]));
-
-  // Queue of nodes with no remaining dependencies
-  const queue: string[] = [];
-
-  // Count of unprocessed dependencies for each node
-  const inDegree = new Map<string, number>();
-
-  // Initialize in-degrees
-  for (const candidate of candidates) {
-    const deps = dependsOn.get(candidate.path);
-    const depCount = deps?.size ?? 0;
-    inDegree.set(candidate.path, depCount);
-
-    if (depCount === 0) {
-      queue.push(candidate.path);
-    }
-  }
-
-  // Process queue
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (!current) break;
-
-    const candidate = candidateMap.get(current);
-    if (candidate) {
-      sorted.push(candidate);
-    }
-
-    // For each file that depends on current, decrement its in-degree
-    const dependents = dependedBy.get(current);
-    if (dependents) {
-      for (const dependent of dependents) {
-        const currentDegree = inDegree.get(dependent) ?? 0;
-        const newDegree = currentDegree - 1;
-        inDegree.set(dependent, newDegree);
-
-        if (newDegree === 0) {
-          queue.push(dependent);
-        }
-      }
-    }
-  }
-
-  // Detect cycles: any nodes not in sorted output are part of cycles
-  const cycles: string[][] = [];
-  const sortedPaths = new Set(sorted.map((c) => c.path));
-  const remainingPaths = candidates.filter((c) => !sortedPaths.has(c.path)).map((c) => c.path);
-
-  if (remainingPaths.length > 0) {
-    // Find cycles using DFS
-    const visited = new Set<string>();
-    const inStack = new Set<string>();
-
-    function findCycles(node: string, path: string[]): void {
-      if (inStack.has(node)) {
-        // Found a cycle - extract it from path
-        const cycleStart = path.indexOf(node);
-        const cycle = path.slice(cycleStart);
-        cycles.push(cycle);
-        return;
-      }
-
-      if (visited.has(node)) {
-        return;
-      }
-
-      visited.add(node);
-      inStack.add(node);
-      path.push(node);
-
-      const deps = dependsOn.get(node);
-      if (deps) {
-        for (const dep of deps) {
-          if (remainingPaths.includes(dep)) {
-            findCycles(dep, [...path]);
-          }
-        }
-      }
-
-      inStack.delete(node);
-    }
-
-    for (const start of remainingPaths) {
-      if (!visited.has(start)) {
-        findCycles(start, []);
-      }
-    }
-
-    // Add remaining candidates to sorted output, prioritizing new pages first
-    // so they get created and receive page_ids before modified pages are pushed.
-    // This allows modified pages to resolve links to the newly created pages.
-    const remainingCandidates = remainingPaths
-      .map((path) => candidateMap.get(path))
-      .filter((c): c is PushCandidate => c !== undefined)
-      .sort((a, b) => {
-        // New pages first, then modified
-        if (a.type === 'new' && b.type !== 'new') return -1;
-        if (a.type !== 'new' && b.type === 'new') return 1;
-        // Within same type, preserve original order (alphabetical)
-        return remainingPaths.indexOf(a.path) - remainingPaths.indexOf(b.path);
-      });
-
-    for (const candidate of remainingCandidates) {
-      sorted.push(candidate);
-    }
-  }
-
-  return { sorted, cycles };
-}

package/src/test/dependency-sorter.test.ts

@@ -1,384 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { extractLocalLinks, sortByDependencies } from '../lib/dependency-sorter.js';
-import type { PushCandidate } from '../lib/file-scanner.js';
-
-describe('dependency-sorter', () => {
-  let testDir: string;
-
-  beforeEach(() => {
-    testDir = mkdtempSync(join(tmpdir(), 'cn-test-'));
-  });
-
-  afterEach(() => {
-    rmSync(testDir, { recursive: true, force: true });
-  });
-
-  describe('extractLocalLinks', () => {
-    test('extracts simple markdown links to .md files', () => {
-      const content = 'Check out [my page](other-page.md) for more info.';
-
-      const links = extractLocalLinks(content);
-
-      expect(links).toEqual(['other-page.md']);
-    });
-
-    test('extracts multiple links', () => {
-      const content = `
-# Documentation
-
-See [intro](intro.md) for getting started.
-Then read [guide](guide.md) for details.
-`;
-
-      const links = extractLocalLinks(content);
-
-      expect(links).toEqual(['intro.md', 'guide.md']);
-    });
-
-    test('extracts links with relative paths', () => {
-      const content = 'See [parent](../parent.md) and [child](subdir/child.md).';
-
-      const links = extractLocalLinks(content);
-
-      expect(links).toEqual(['../parent.md', 'subdir/child.md']);
-    });
-
-    test('ignores http links', () => {
-      const content = 'See [external](http://example.com/page.md) for more.';
-
-      const links = extractLocalLinks(content);
-
-      expect(links).toEqual([]);
-    });
-
-    test('ignores https links', () => {
-      const content = 'See [secure](https://example.com/page.md) for more.';
-
-      const links = extractLocalLinks(content);
-
-      expect(links).toEqual([]);
-    });
-
-    test('removes anchor fragments from links', () => {
-      const content = 'See [section](guide.md#installation) for setup.';
-
-      const links = extractLocalLinks(content);
-
-      expect(links).toEqual(['guide.md']);
-    });
-
-    test('handles nested brackets in link text', () => {
-      const content = 'See [text [nested]](page.md) for info.';
-
-      const links = extractLocalLinks(content);
-
-      expect(links).toEqual(['page.md']);
-    });
-
-    test('returns empty array for content with no links', () => {
-      const content = '# Just a heading\n\nSome plain text.';
-
-      const links = extractLocalLinks(content);
-
-      expect(links).toEqual([]);
-    });
-
-    test('returns empty array for links to non-md files', () => {
-      const content = 'See [image](photo.png) and [doc](file.pdf).';
-
-      const links = extractLocalLinks(content);
-
-      expect(links).toEqual([]);
-    });
-  });
-
-  describe('sortByDependencies', () => {
-    function createCandidate(path: string, type: 'new' | 'modified' = 'new'): PushCandidate {
-      return {
-        path,
-        type,
-        title: path.replace('.md', ''),
-      };
-    }
-
-    test('returns original order when no files have links', () => {
-      writeFileSync(join(testDir, 'a.md'), '# File A');
-      writeFileSync(join(testDir, 'b.md'), '# File B');
-      writeFileSync(join(testDir, 'c.md'), '# File C');
-
-      const candidates: PushCandidate[] = [createCandidate('a.md'), createCandidate('b.md'), createCandidate('c.md')];
-
-      const { sorted, cycles } = sortByDependencies(candidates, testDir);
-
-      expect(cycles).toEqual([]);
-      expect(sorted.map((c) => c.path)).toEqual(['a.md', 'b.md', 'c.md']);
-    });
-
-    test('sorts linear chain so dependencies come first', () => {
-      // A links to B, B links to C
-      // Expected order: C, B, A
-      writeFileSync(join(testDir, 'a.md'), '# A\nSee [B](b.md)');
-      writeFileSync(join(testDir, 'b.md'), '# B\nSee [C](c.md)');
-      writeFileSync(join(testDir, 'c.md'), '# C');
-
-      const candidates: PushCandidate[] = [createCandidate('a.md'), createCandidate('b.md'), createCandidate('c.md')];
-
-      const { sorted, cycles } = sortByDependencies(candidates, testDir);
-
-      expect(cycles).toEqual([]);
-      expect(sorted.map((c) => c.path)).toEqual(['c.md', 'b.md', 'a.md']);
-    });
-
-    test('handles diamond dependency pattern', () => {
-      // A -> B, A -> C, B -> D, C -> D
-      // Expected: D first, then B and C (in any order), then A
-      writeFileSync(join(testDir, 'a.md'), '# A\nSee [B](b.md) and [C](c.md)');
-      writeFileSync(join(testDir, 'b.md'), '# B\nSee [D](d.md)');
-      writeFileSync(join(testDir, 'c.md'), '# C\nSee [D](d.md)');
-      writeFileSync(join(testDir, 'd.md'), '# D');
-
-      const candidates: PushCandidate[] = [
-        createCandidate('a.md'),
-        createCandidate('b.md'),
-        createCandidate('c.md'),
-        createCandidate('d.md'),
-      ];
-
-      const { sorted, cycles } = sortByDependencies(candidates, testDir);
-
-      expect(cycles).toEqual([]);
-
-      const paths = sorted.map((c) => c.path);
-      // D must come before B and C
-      expect(paths.indexOf('d.md')).toBeLessThan(paths.indexOf('b.md'));
-      expect(paths.indexOf('d.md')).toBeLessThan(paths.indexOf('c.md'));
-      // B and C must come before A
-      expect(paths.indexOf('b.md')).toBeLessThan(paths.indexOf('a.md'));
-      expect(paths.indexOf('c.md')).toBeLessThan(paths.indexOf('a.md'));
-    });
-
-    test('detects and reports simple circular dependency', () => {
-      // A -> B, B -> A
-      writeFileSync(join(testDir, 'a.md'), '# A\nSee [B](b.md)');
-      writeFileSync(join(testDir, 'b.md'), '# B\nSee [A](a.md)');
-
-      const candidates: PushCandidate[] = [createCandidate('a.md'), createCandidate('b.md')];
-
-      const { sorted, cycles } = sortByDependencies(candidates, testDir);
-
-      // Should detect cycle
-      expect(cycles.length).toBeGreaterThan(0);
-      // Both files should still be in output
-      expect(sorted).toHaveLength(2);
-    });
-
-    test('detects longer cycles', () => {
-      // A -> B -> C -> A
-      writeFileSync(join(testDir, 'a.md'), '# A\nSee [B](b.md)');
-      writeFileSync(join(testDir, 'b.md'), '# B\nSee [C](c.md)');
-      writeFileSync(join(testDir, 'c.md'), '# C\nSee [A](a.md)');
-
-      const candidates: PushCandidate[] = [createCandidate('a.md'), createCandidate('b.md'), createCandidate('c.md')];
-
-      const { sorted, cycles } = sortByDependencies(candidates, testDir);
-
-      expect(cycles.length).toBeGreaterThan(0);
-      // All files should still be in output
-      expect(sorted).toHaveLength(3);
-    });
-
-    test('ignores links to files not in candidates', () => {
-      // A links to B (candidate) and X (not a candidate)
-      writeFileSync(join(testDir, 'a.md'), '# A\nSee [B](b.md) and [X](x.md)');
-      writeFileSync(join(testDir, 'b.md'), '# B');
-      writeFileSync(join(testDir, 'x.md'), '# X (already synced)');
-
-      const candidates: PushCandidate[] = [createCandidate('a.md'), createCandidate('b.md')];
-
-      const { sorted, cycles } = sortByDependencies(candidates, testDir);
-
-      expect(cycles).toEqual([]);
-      // B should come before A because A depends on B
-      expect(sorted.map((c) => c.path)).toEqual(['b.md', 'a.md']);
-    });
-
-    test('handles links in subdirectories', () => {
-      mkdirSync(join(testDir, 'docs'));
-
-      // docs/a.md links to docs/b.md
-      writeFileSync(join(testDir, 'docs', 'a.md'), '# A\nSee [B](b.md)');
-      writeFileSync(join(testDir, 'docs', 'b.md'), '# B');
-
-      const candidates: PushCandidate[] = [createCandidate('docs/a.md'), createCandidate('docs/b.md')];
-
-      const { sorted, cycles } = sortByDependencies(candidates, testDir);
-
-      expect(cycles).toEqual([]);
-      expect(sorted.map((c) => c.path)).toEqual(['docs/b.md', 'docs/a.md']);
-    });
-
-    test('handles cross-directory links', () => {
-      mkdirSync(join(testDir, 'guides'));
-      mkdirSync(join(testDir, 'reference'));
-
-      // guides/a.md links to reference/b.md
-      writeFileSync(join(testDir, 'guides', 'a.md'), '# A\nSee [B](../reference/b.md)');
-      writeFileSync(join(testDir, 'reference', 'b.md'), '# B');
-
-      const candidates: PushCandidate[] = [createCandidate('guides/a.md'), createCandidate('reference/b.md')];
-
-      const { sorted, cycles } = sortByDependencies(candidates, testDir);
-
-      expect(cycles).toEqual([]);
-      expect(sorted.map((c) => c.path)).toEqual(['reference/b.md', 'guides/a.md']);
-    });
-
-    test('handles empty candidate list', () => {
-      const { sorted, cycles } = sortByDependencies([], testDir);
-
-      expect(sorted).toEqual([]);
-      expect(cycles).toEqual([]);
-    });
-
-    test('handles single candidate with no links', () => {
-      writeFileSync(join(testDir, 'only.md'), '# Only file');
-
-      const candidates: PushCandidate[] = [createCandidate('only.md')];
-
-      const { sorted, cycles } = sortByDependencies(candidates, testDir);
-
-      expect(cycles).toEqual([]);
-      expect(sorted).toEqual(candidates);
-    });
-
-    test('handles single candidate with self-link', () => {
-      writeFileSync(join(testDir, 'self.md'), '# Self\nSee [Self](self.md)');
-
-      const candidates: PushCandidate[] = [createCandidate('self.md')];
-
-      const { sorted, cycles } = sortByDependencies(candidates, testDir);
-
-      // Self-link creates a cycle
-      expect(cycles.length).toBeGreaterThan(0);
-      expect(sorted).toHaveLength(1);
-    });
-
-    test('preserves candidate type and title', () => {
-      writeFileSync(join(testDir, 'new.md'), '# New\nSee [modified](modified.md)');
-      writeFileSync(join(testDir, 'modified.md'), '# Modified');
-
-      const candidates: PushCandidate[] = [
-        { path: 'new.md', type: 'new', title: 'New Page' },
-        { path: 'modified.md', type: 'modified', title: 'Modified Page', pageId: '123' },
-      ];
-
-      const { sorted } = sortByDependencies(candidates, testDir);
-
-      // modified.md should come first (dependency)
-      expect(sorted[0]).toEqual({
-        path: 'modified.md',
-        type: 'modified',
-        title: 'Modified Page',
-        pageId: '123',
-      });
-      expect(sorted[1]).toEqual({
-        path: 'new.md',
-        type: 'new',
-        title: 'New Page',
-      });
-    });
-
-    test('handles mixed candidates with and without dependencies', () => {
-      // A -> B, C has no links, D -> E
-      writeFileSync(join(testDir, 'a.md'), '# A\nSee [B](b.md)');
-      writeFileSync(join(testDir, 'b.md'), '# B');
-      writeFileSync(join(testDir, 'c.md'), '# C (independent)');
-      writeFileSync(join(testDir, 'd.md'), '# D\nSee [E](e.md)');
-      writeFileSync(join(testDir, 'e.md'), '# E');
-
-      const candidates: PushCandidate[] = [
-        createCandidate('a.md'),
-        createCandidate('b.md'),
-        createCandidate('c.md'),
-        createCandidate('d.md'),
-        createCandidate('e.md'),
-      ];
-
-      const { sorted, cycles } = sortByDependencies(candidates, testDir);
-
-      expect(cycles).toEqual([]);
-
-      const paths = sorted.map((c) => c.path);
-      // B before A
-      expect(paths.indexOf('b.md')).toBeLessThan(paths.indexOf('a.md'));
-      // E before D
-      expect(paths.indexOf('e.md')).toBeLessThan(paths.indexOf('d.md'));
-      // All files included
-      expect(paths).toHaveLength(5);
-    });
-
-    test('gracefully handles unreadable files', () => {
-      writeFileSync(join(testDir, 'readable.md'), '# Readable\nSee [unreadable](unreadable.md)');
-      // unreadable.md doesn't exist as a file, but is in candidates
-
-      const candidates: PushCandidate[] = [createCandidate('readable.md'), createCandidate('unreadable.md')];
-
-      // Should not throw, even though unreadable.md can't be read
-      const { sorted, cycles } = sortByDependencies(candidates, testDir);
-
-      expect(cycles).toEqual([]);
-      expect(sorted).toHaveLength(2);
-    });
-
-    test('prioritizes new pages before modified pages in cycles', () => {
-      // Create circular dependency: modified -> new -> modified
-      // The new page should be pushed first so it gets a page_id,
-      // allowing the modified page to resolve links to it
-      mkdirSync(join(testDir, 'getting-started'));
-      mkdirSync(join(testDir, 'tools'));
-
-      writeFileSync(join(testDir, 'getting-started', 'onboarding.md'), '# Onboarding\nSee [CLI](../tools/cli.md)');
-      writeFileSync(join(testDir, 'tools', 'cli.md'), '# CLI\nSee [Onboarding](../getting-started/onboarding.md)');
-
-      const candidates: PushCandidate[] = [
-        { path: 'getting-started/onboarding.md', type: 'modified', title: 'Onboarding', pageId: '123' },
-        { path: 'tools/cli.md', type: 'new', title: 'CLI' },
-      ];
-
-      const { sorted, cycles } = sortByDependencies(candidates, testDir);
-
-      // Should detect the cycle
-      expect(cycles.length).toBeGreaterThan(0);
-      // Both files should be in output
-      expect(sorted).toHaveLength(2);
-      // New page should come FIRST (before modified) so it gets created first
-      expect(sorted[0].type).toBe('new');
-      expect(sorted[0].path).toBe('tools/cli.md');
-      expect(sorted[1].type).toBe('modified');
-      expect(sorted[1].path).toBe('getting-started/onboarding.md');
-    });
-
-    test('maintains alphabetical order within same type in cycles', () => {
-      // All new pages in a cycle should maintain alphabetical order
-      writeFileSync(join(testDir, 'c.md'), '# C\nSee [A](a.md)');
-      writeFileSync(join(testDir, 'a.md'), '# A\nSee [B](b.md)');
-      writeFileSync(join(testDir, 'b.md'), '# B\nSee [C](c.md)');
-
-      const candidates: PushCandidate[] = [
-        { path: 'c.md', type: 'new', title: 'C' },
-        { path: 'a.md', type: 'new', title: 'A' },
-        { path: 'b.md', type: 'new', title: 'B' },
-      ];
-
-      const { sorted, cycles } = sortByDependencies(candidates, testDir);
-
-      expect(cycles.length).toBeGreaterThan(0);
-      // All same type (new), should preserve original order from candidates array
-      // Original order is c, a, b
-      expect(sorted.map((c) => c.path)).toEqual(['c.md', 'a.md', 'b.md']);
-    });
-  });
-});