acker-dacker 0.1.0

package/src/gitignore.ts

@@ -0,0 +1,139 @@
+import path from 'node:path';
+import { globPatternToRegexSource, isPathWithin, normalizeArchivePath } from './path-patterns';
+
+type GitIgnoreRule = {
+    readonly directoryOnly: boolean;
+    readonly matcher: RegExp;
+    readonly negated: boolean;
+};
+
+const parseGitIgnoreRule = (line: string): GitIgnoreRule | null => {
+    let pattern = line.replace(/[ \t]+$/u, '');
+    if (pattern.length === 0 || pattern.startsWith('#')) {
+        return null;
+    }
+
+    const escapedLeadingMarker = pattern.startsWith('\\#') || pattern.startsWith('\\!');
+    if (escapedLeadingMarker) {
+        pattern = pattern.slice(1);
+    }
+
+    let negated = false;
+    if (!escapedLeadingMarker && pattern.startsWith('!')) {
+        negated = true;
+        pattern = pattern.slice(1);
+    }
+
+    const directoryOnly = pattern.endsWith('/') && !pattern.endsWith('\\/');
+    if (directoryOnly) {
+        pattern = pattern.slice(0, -1);
+    }
+
+    const anchored = pattern.startsWith('/');
+    if (anchored) {
+        pattern = pattern.slice(1);
+    }
+    if (pattern.length === 0) {
+        return null;
+    }
+
+    const hasSlash = pattern.includes('/');
+    const source = globPatternToRegexSource(pattern);
+    const matcher = new RegExp(anchored || hasSlash ? `^${source}$` : `(?:^|/)${source}(?:$|/)`);
+
+    return { directoryOnly, matcher, negated };
+};
+
+const parseGitIgnoreRules = (contents: string): readonly GitIgnoreRule[] => {
+    const rules: GitIgnoreRule[] = [];
+    for (const line of contents.split(/\r?\n/u)) {
+        const rule = parseGitIgnoreRule(line);
+        if (rule) {
+            rules.push(rule);
+        }
+    }
+    return rules;
+};
+
+const matchesGitIgnoreRule = (rule: GitIgnoreRule, relativePath: string, isDirectory: boolean): boolean => {
+    if (!rule.directoryOnly || isDirectory) {
+        return rule.matcher.test(relativePath);
+    }
+
+    const segments = relativePath.split('/');
+    for (let end = 1; end < segments.length; end += 1) {
+        if (rule.matcher.test(segments.slice(0, end).join('/'))) {
+            return true;
+        }
+    }
+    return false;
+};
+
+export class GitIgnoreMatcher {
+    private readonly rulesByDirectory = new Map<string, readonly GitIgnoreRule[]>();
+
+    public constructor(private readonly rootDir: string) {}
+
+    private async rulesForDirectory(directory: string): Promise<readonly GitIgnoreRule[]> {
+        const cachedRules = this.rulesByDirectory.get(directory);
+        if (cachedRules) {
+            return cachedRules;
+        }
+
+        const ignoreFile = Bun.file(path.join(directory, '.gitignore'));
+        if (!(await ignoreFile.exists())) {
+            this.rulesByDirectory.set(directory, []);
+            return [];
+        }
+
+        try {
+            const rules = parseGitIgnoreRules(await ignoreFile.text());
+            this.rulesByDirectory.set(directory, rules);
+            return rules;
+        } catch {
+            this.rulesByDirectory.set(directory, []);
+            return [];
+        }
+    }
+
+    public async isIgnored(absolutePath: string, isDirectory: boolean): Promise<boolean> {
+        const parentDirectory = path.dirname(absolutePath);
+        if (!isPathWithin(parentDirectory, this.rootDir)) {
+            return false;
+        }
+
+        const directories: string[] = [];
+        let directory = parentDirectory;
+        while (true) {
+            directories.push(directory);
+            if (directory === this.rootDir) {
+                break;
+            }
+
+            const parent = path.dirname(directory);
+            if (parent === directory || !isPathWithin(parent, this.rootDir)) {
+                return false;
+            }
+            directory = parent;
+        }
+
+        directories.reverse();
+
+        let ignored = false;
+        for (const ruleDirectory of directories) {
+            const relativePath = normalizeArchivePath(path.relative(ruleDirectory, absolutePath));
+            if (relativePath.length === 0 || relativePath === '..' || relativePath.startsWith('../')) {
+                continue;
+            }
+
+            const rules = await this.rulesForDirectory(ruleDirectory);
+            for (const rule of rules) {
+                if (matchesGitIgnoreRule(rule, relativePath, isDirectory)) {
+                    ignored = !rule.negated;
+                }
+            }
+        }
+
+        return ignored;
+    }
+}

package/src/path-patterns.ts

@@ -0,0 +1,79 @@
+import path from 'node:path';
+
+export const compareStableStrings = (left: string, right: string): number =>
+    left < right ? -1 : left > right ? 1 : 0;
+
+export const normalizeArchivePath = (filePath: string): string => filePath.split(path.sep).join('/');
+
+const escapeRegexCharacter = (character: string): string => character.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
+
+export const globPatternToRegexSource = (pattern: string): string => {
+    let source = '';
+
+    for (let index = 0; index < pattern.length; index += 1) {
+        const character = pattern[index]!;
+
+        if (character === '\\') {
+            if (index + 1 < pattern.length) {
+                index += 1;
+                source += escapeRegexCharacter(pattern[index]!);
+            } else {
+                source += '\\\\';
+            }
+            continue;
+        }
+
+        if (character === '*') {
+            if (pattern[index + 1] === '*') {
+                index += 1;
+                if (pattern[index + 1] === '/') {
+                    index += 1;
+                    source += '(?:.*/)?';
+                } else {
+                    source += '.*';
+                }
+            } else {
+                source += '[^/]*';
+            }
+            continue;
+        }
+
+        if (character === '?') {
+            source += '[^/]';
+            continue;
+        }
+
+        if (character === '[') {
+            const closingBracket = pattern.indexOf(']', index + 1);
+            if (closingBracket !== -1) {
+                const characterClass = pattern.slice(index + 1, closingBracket);
+                const classPrefix = characterClass.startsWith('!') ? '^' : '';
+                const classBody = characterClass.startsWith('!') ? characterClass.slice(1) : characterClass;
+                source += `[${classPrefix}${classBody}]`;
+                index = closingBracket;
+                continue;
+            }
+        }
+
+        source += escapeRegexCharacter(character);
+    }
+
+    return source;
+};
+
+export const globToRegex = (pattern: string): RegExp => {
+    const normalized = pattern.trim().replace(/\\/g, '/');
+    if (normalized.startsWith('*.')) {
+        const extension = normalized.slice(2).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return new RegExp(`\\.${extension}$`, 'i');
+    }
+    const regexSource = normalized
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '.*')
+        .replace(/(?<!\.)\*/g, '[^/]*');
+    return new RegExp(`(?:^|/)${regexSource}$`, 'i');
+};
+
+export const isPathWithin = (candidate: string, root: string): boolean => {
+    return candidate === root || candidate.startsWith(`${root}${path.sep}`);
+};

package/src/repository-pack.ts

@@ -0,0 +1,276 @@
+import type { Dirent } from 'node:fs';
+import { mkdir, readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { detectXcodeProject, isExcludedDirectory, isExcludedFile } from './file-policy';
+import { GitIgnoreMatcher } from './gitignore';
+import { compareStableStrings, normalizeArchivePath } from './path-patterns';
+
+export type RepositoryInfo = {
+    readonly archivePrefix: string;
+    readonly isXcodeProject: boolean;
+    readonly name: string;
+    readonly path: string;
+};
+
+type WalkItem = {
+    readonly relativePath: string;
+    readonly sourcePath: string;
+};
+
+export type RepositoryPackStats = {
+    readonly fileCount: number;
+    readonly totalBytes: number;
+};
+
+const extractLocalPath = (spec: string): string | null => {
+    let cleaned = spec.trim();
+    if (cleaned.startsWith('file:')) {
+        cleaned = cleaned.slice(5);
+    } else if (cleaned.startsWith('link:')) {
+        cleaned = cleaned.slice(5);
+    } else if (!cleaned.startsWith('./') && !cleaned.startsWith('../') && !cleaned.startsWith('/')) {
+        return null;
+    }
+    const hashIndex = cleaned.indexOf('#');
+    if (hashIndex !== -1) {
+        cleaned = cleaned.slice(0, hashIndex);
+    }
+    return cleaned.length > 0 ? cleaned : null;
+};
+
+const findPackageLocalDependencies = (parsed: Record<string, unknown>): readonly string[] => {
+    const localPaths: string[] = [];
+    const dependencySections = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+
+    for (const section of dependencySections) {
+        const dependencies = parsed[section];
+        if (dependencies && typeof dependencies === 'object' && !Array.isArray(dependencies)) {
+            for (const value of Object.values(dependencies)) {
+                if (typeof value === 'string') {
+                    const localPath = extractLocalPath(value);
+                    if (localPath) {
+                        localPaths.push(localPath);
+                    }
+                }
+            }
+        }
+    }
+
+    const repository = parsed.repository;
+    if (typeof repository === 'string') {
+        const repositoryPath = extractLocalPath(repository);
+        if (repositoryPath) {
+            localPaths.push(repositoryPath);
+        }
+    } else if (repository && typeof repository === 'object' && !Array.isArray(repository)) {
+        const url = (repository as { url?: unknown }).url;
+        if (typeof url === 'string') {
+            const repositoryPath = extractLocalPath(url);
+            if (repositoryPath) {
+                localPaths.push(repositoryPath);
+            }
+        }
+    }
+
+    return localPaths;
+};
+
+const resolveIncludePath = async (includeSpec: string, targetDir: string): Promise<string | null> => {
+    const rawPath = includeSpec.replace(/^~(?=$|\/)/, process.env.HOME ?? '');
+    const parentDirectory = path.dirname(targetDir);
+    const candidates = [
+        path.resolve(parentDirectory, rawPath),
+        path.resolve(targetDir, rawPath),
+        path.resolve(process.cwd(), rawPath),
+        path.resolve(rawPath),
+    ];
+
+    for (const candidate of candidates) {
+        const candidateStats = await stat(candidate).catch(() => null);
+        if (candidateStats?.isDirectory()) {
+            return candidate;
+        }
+    }
+    return null;
+};
+
+export const discoverRecursiveRepositories = async (
+    targetDir: string,
+    includes: readonly string[],
+): Promise<readonly RepositoryInfo[]> => {
+    const canonicalTarget = path.resolve(targetDir);
+    const targetStats = await stat(canonicalTarget).catch(() => null);
+    if (!targetStats?.isDirectory()) {
+        throw new Error(`Target path is not a directory: ${canonicalTarget}`);
+    }
+
+    const discoveredRepositories = new Map<string, { isXcodeProject: boolean; name: string }>();
+    const queue: string[] = [canonicalTarget];
+
+    for (const include of includes) {
+        const resolvedInclude = await resolveIncludePath(include, canonicalTarget);
+        if (resolvedInclude) {
+            queue.push(resolvedInclude);
+        } else {
+            console.warn(`Warning: Included path not found or not a directory: ${include}`);
+        }
+    }
+
+    const visited = new Set<string>();
+
+    while (queue.length > 0) {
+        const current = queue.shift()!;
+        const canonicalPath = path.resolve(current);
+        if (visited.has(canonicalPath)) {
+            continue;
+        }
+        visited.add(canonicalPath);
+
+        const folderStats = await stat(canonicalPath).catch(() => null);
+        if (!folderStats?.isDirectory()) {
+            continue;
+        }
+
+        const packageJsonPath = path.join(canonicalPath, 'package.json');
+        let repositoryName = path.basename(canonicalPath);
+
+        if (await Bun.file(packageJsonPath).exists()) {
+            try {
+                const packageJson = (await Bun.file(packageJsonPath).json()) as Record<string, unknown>;
+                if (typeof packageJson.name === 'string' && packageJson.name.trim().length > 0) {
+                    repositoryName = packageJson.name.trim();
+                }
+
+                for (const localDependency of findPackageLocalDependencies(packageJson)) {
+                    const resolvedDependency = path.resolve(canonicalPath, localDependency);
+                    if (!visited.has(resolvedDependency)) {
+                        queue.push(resolvedDependency);
+                    }
+                }
+            } catch {
+                // Invalid package metadata does not prevent the repository itself from being packed.
+            }
+        }
+
+        discoveredRepositories.set(canonicalPath, {
+            isXcodeProject: await detectXcodeProject(canonicalPath),
+            name: repositoryName,
+        });
+    }
+
+    const allPaths = [...discoveredRepositories.keys()];
+    let commonParent = path.dirname(canonicalTarget);
+    if (allPaths.length > 1) {
+        let candidate = commonParent;
+        while (candidate !== path.dirname(candidate)) {
+            if (allPaths.every((repositoryPath) => repositoryPath === candidate || repositoryPath.startsWith(`${candidate}${path.sep}`))) {
+                commonParent = candidate;
+                break;
+            }
+            candidate = path.dirname(candidate);
+        }
+    }
+
+    const repositories: RepositoryInfo[] = [];
+    for (const [canonicalPath, repository] of discoveredRepositories.entries()) {
+        repositories.push({
+            archivePrefix: normalizeArchivePath(path.relative(commonParent, canonicalPath)),
+            isXcodeProject: repository.isXcodeProject,
+            name: repository.name,
+            path: canonicalPath,
+        });
+    }
+
+    return repositories.sort((left, right) => compareStableStrings(left.name, right.name));
+};
+
+const processWalkEntry = async ({
+    destinationDirectory,
+    entry,
+    filterMatchers,
+    ignoreMatcher,
+    isXcodeProject,
+    item,
+    queue,
+}: {
+    readonly destinationDirectory: string;
+    readonly entry: Dirent;
+    readonly filterMatchers: readonly RegExp[];
+    readonly ignoreMatcher: GitIgnoreMatcher;
+    readonly isXcodeProject: boolean;
+    readonly item: WalkItem;
+    readonly queue: WalkItem[];
+}): Promise<{ bytes: number; isFile: boolean }> => {
+    if (entry.isSymbolicLink()) {
+        return { bytes: 0, isFile: false };
+    }
+
+    const relativePath = item.relativePath ? path.join(item.relativePath, entry.name) : entry.name;
+    const sourcePath = path.join(item.sourcePath, entry.name);
+
+    if (entry.isDirectory()) {
+        if (!isExcludedDirectory(entry.name, isXcodeProject) && !(await ignoreMatcher.isIgnored(sourcePath, true))) {
+            queue.push({ relativePath, sourcePath });
+        }
+        return { bytes: 0, isFile: false };
+    }
+
+    if (!entry.isFile() || isExcludedFile(entry.name, isXcodeProject)) {
+        return { bytes: 0, isFile: false };
+    }
+    if (await ignoreMatcher.isIgnored(sourcePath, false)) {
+        return { bytes: 0, isFile: false };
+    }
+
+    if (filterMatchers.length > 0) {
+        const normalizedRelativePath = normalizeArchivePath(relativePath);
+        const matches = filterMatchers.some(
+            (matcher) => matcher.test(normalizedRelativePath) || matcher.test(entry.name),
+        );
+        if (!matches) {
+            return { bytes: 0, isFile: false };
+        }
+    }
+
+    const destinationPath = path.join(destinationDirectory, relativePath);
+    await mkdir(path.dirname(destinationPath), { recursive: true });
+    const sourceFile = Bun.file(sourcePath);
+    await Bun.write(destinationPath, sourceFile);
+
+    return { bytes: sourceFile.size, isFile: true };
+};
+
+export const copyRepositoryFiles = async (
+    repository: RepositoryInfo,
+    stagingRoot: string,
+    filterMatchers: readonly RegExp[],
+): Promise<RepositoryPackStats> => {
+    let fileCount = 0;
+    let totalBytes = 0;
+    const destinationDirectory = path.join(stagingRoot, repository.archivePrefix);
+    const ignoreMatcher = new GitIgnoreMatcher(repository.path);
+    const queue: WalkItem[] = [{ relativePath: '', sourcePath: repository.path }];
+
+    while (queue.length > 0) {
+        const item = queue.shift()!;
+        const entries = await readdir(item.sourcePath, { withFileTypes: true });
+
+        for (const entry of entries.sort((left, right) => compareStableStrings(left.name, right.name))) {
+            const result = await processWalkEntry({
+                destinationDirectory,
+                entry,
+                filterMatchers,
+                ignoreMatcher,
+                isXcodeProject: repository.isXcodeProject,
+                item,
+                queue,
+            });
+            if (result.isFile) {
+                fileCount += 1;
+                totalBytes += result.bytes;
+            }
+        }
+    }
+
+    return { fileCount, totalBytes };
+};