acker-dacker 0.1.0 → 0.2.0

package/src/{repository-pack.ts → pack/repository-pack.ts}

@@ -1,9 +1,11 @@
 import type { Dirent } from 'node:fs';
 import { mkdir, readdir, stat } from 'node:fs/promises';
 import path from 'node:path';
+import { expandTildePath } from '../cli/cli';
 import { detectXcodeProject, isExcludedDirectory, isExcludedFile } from './file-policy';
 import { GitIgnoreMatcher } from './gitignore';
-import { compareStableStrings, normalizeArchivePath } from './path-patterns';
+import type { GitIgnoreMatcherOptions } from './gitignore';
+import { compareStableStrings, isPathWithin, normalizeArchivePath } from './path-patterns';
 
 export type RepositoryInfo = {
     readonly archivePrefix: string;
@@ -75,23 +77,97 @@ const findPackageLocalDependencies = (parsed: Record<string, unknown>): readonly
     return localPaths;
 };
 
-const resolveIncludePath = async (includeSpec: string, targetDir: string): Promise<string | null> => {
-    const rawPath = includeSpec.replace(/^~(?=$|\/)/, process.env.HOME ?? '');
+const splitGlobPath = (inputPath: string): { dirPrefix: string; globPattern: string } => {
+    const firstGlobIndex = inputPath.search(/[*?\[{]/);
+    if (firstGlobIndex === -1) {
+        return { dirPrefix: inputPath, globPattern: '' };
+    }
+    const lastSepBeforeGlob = Math.max(
+        inputPath.lastIndexOf('/', firstGlobIndex),
+        inputPath.lastIndexOf('\\', firstGlobIndex),
+    );
+    if (lastSepBeforeGlob === -1) {
+        return { dirPrefix: '.', globPattern: inputPath };
+    }
+    const dirPrefix = inputPath.slice(0, lastSepBeforeGlob) || (inputPath.startsWith('/') ? '/' : '.');
+    const globPattern = inputPath.slice(lastSepBeforeGlob + 1);
+    return { dirPrefix, globPattern };
+};
+
+const resolveIncludePaths = async (includeSpec: string, targetDir: string): Promise<readonly string[]> => {
+    const rawPath = expandTildePath(includeSpec);
     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;
+
+    const { dirPrefix, globPattern } = splitGlobPath(rawPath);
+    if (!globPattern) {
+        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 [];
+    }
+
+    const baseDirectories = path.isAbsolute(rawPath)
+        ? ['']
+        : [parentDirectory, targetDir, process.cwd()];
+
+    const glob = new Bun.Glob(globPattern);
+
+    for (const base of baseDirectories) {
+        const effectiveDir = base ? path.resolve(base, dirPrefix) : dirPrefix;
+        const dirStats = await stat(effectiveDir).catch(() => null);
+        if (!dirStats?.isDirectory()) {
+            continue;
+        }
+
+        const matchedDirectories: string[] = [];
+        try {
+            for (const match of glob.scanSync({ cwd: effectiveDir, onlyFiles: false })) {
+                const fullCandidate = path.resolve(effectiveDir, match);
+                const itemStats = await stat(fullCandidate).catch(() => null);
+                if (itemStats?.isDirectory()) {
+                    matchedDirectories.push(fullCandidate);
+                }
+            }
+        } catch {
+            continue;
+        }
+
+        if (matchedDirectories.length > 0) {
+            matchedDirectories.sort(compareStableStrings);
+            return matchedDirectories;
         }
     }
-    return null;
+
+    return [];
+};
+
+const resolveEnclosingRepositoryRoot = async (dirPath: string): Promise<string> => {
+    let current = path.resolve(dirPath);
+    let foundGitRoot: string | null = null;
+    while (true) {
+        const gitPath = path.join(current, '.git');
+        const gitStats = await stat(gitPath).catch(() => null);
+        if (gitStats) {
+            foundGitRoot = current;
+            break;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return foundGitRoot ?? path.resolve(dirPath);
 };
 
 export const discoverRecursiveRepositories = async (
@@ -108,9 +184,11 @@ export const discoverRecursiveRepositories = async (
     const queue: string[] = [canonicalTarget];
 
     for (const include of includes) {
-        const resolvedInclude = await resolveIncludePath(include, canonicalTarget);
-        if (resolvedInclude) {
-            queue.push(resolvedInclude);
+        const resolvedIncludes = await resolveIncludePaths(include, canonicalTarget);
+        if (resolvedIncludes.length > 0) {
+            for (const resolved of resolvedIncludes) {
+                queue.push(resolved);
+            }
         } else {
             console.warn(`Warning: Included path not found or not a directory: ${include}`);
         }
@@ -143,8 +221,9 @@ export const discoverRecursiveRepositories = async (
 
                 for (const localDependency of findPackageLocalDependencies(packageJson)) {
                     const resolvedDependency = path.resolve(canonicalPath, localDependency);
-                    if (!visited.has(resolvedDependency)) {
-                        queue.push(resolvedDependency);
+                    const repoRoot = await resolveEnclosingRepositoryRoot(resolvedDependency);
+                    if (!visited.has(repoRoot)) {
+                        queue.push(repoRoot);
                     }
                 }
             } catch {
@@ -158,23 +237,58 @@ export const discoverRecursiveRepositories = async (
         });
     }
 
+    // If any discovered repository is a descendant of another discovered repository,
+    // prune the descendant repository because the parent repository already contains all its files.
+    const allDiscoveredPaths = [...discoveredRepositories.keys()];
+    for (const childPath of allDiscoveredPaths) {
+        for (const parentPath of allDiscoveredPaths) {
+            if (childPath !== parentPath && isPathWithin(childPath, parentPath)) {
+                discoveredRepositories.delete(childPath);
+                break;
+            }
+        }
+    }
+
     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}`))) {
+        let found = false;
+        while (true) {
+            const isParent = allPaths.every((repositoryPath) =>
+                repositoryPath === candidate ||
+                repositoryPath.startsWith(candidate.endsWith(path.sep) ? candidate : `${candidate}${path.sep}`),
+            );
+            if (isParent) {
                 commonParent = candidate;
+                found = true;
+                break;
+            }
+            const nextParent = path.dirname(candidate);
+            if (nextParent === candidate) {
                 break;
             }
-            candidate = path.dirname(candidate);
+            candidate = nextParent;
+        }
+        if (!found) {
+            throw new Error(`Discovered repositories do not share a common ancestor: ${allPaths.join(', ')}`);
         }
     }
 
     const repositories: RepositoryInfo[] = [];
     for (const [canonicalPath, repository] of discoveredRepositories.entries()) {
+        const relativeToCommon = path.relative(commonParent, canonicalPath);
+        const archivePrefix = normalizeArchivePath(relativeToCommon || path.basename(canonicalPath));
+        if (
+            archivePrefix.length === 0 ||
+            archivePrefix === '..' ||
+            archivePrefix.startsWith('../') ||
+            path.isAbsolute(archivePrefix)
+        ) {
+            throw new Error(`Unsafe archive prefix computed for repository ${canonicalPath}: ${archivePrefix}`);
+        }
         repositories.push({
-            archivePrefix: normalizeArchivePath(path.relative(commonParent, canonicalPath)),
+            archivePrefix,
             isXcodeProject: repository.isXcodeProject,
             name: repository.name,
             path: canonicalPath,
@@ -192,6 +306,7 @@ const processWalkEntry = async ({
     isXcodeProject,
     item,
     queue,
+    stagingRoot,
 }: {
     readonly destinationDirectory: string;
     readonly entry: Dirent;
@@ -200,6 +315,7 @@ const processWalkEntry = async ({
     readonly isXcodeProject: boolean;
     readonly item: WalkItem;
     readonly queue: WalkItem[];
+    readonly stagingRoot: string;
 }): Promise<{ bytes: number; isFile: boolean }> => {
     if (entry.isSymbolicLink()) {
         return { bytes: 0, isFile: false };
@@ -233,6 +349,9 @@ const processWalkEntry = async ({
     }
 
     const destinationPath = path.join(destinationDirectory, relativePath);
+    if (!isPathWithin(destinationPath, stagingRoot)) {
+        throw new Error(`Destination path escapes staging root: ${destinationPath}`);
+    }
     await mkdir(path.dirname(destinationPath), { recursive: true });
     const sourceFile = Bun.file(sourcePath);
     await Bun.write(destinationPath, sourceFile);
@@ -244,11 +363,15 @@ export const copyRepositoryFiles = async (
     repository: RepositoryInfo,
     stagingRoot: string,
     filterMatchers: readonly RegExp[],
+    ignoreOptions?: GitIgnoreMatcherOptions,
 ): Promise<RepositoryPackStats> => {
     let fileCount = 0;
     let totalBytes = 0;
     const destinationDirectory = path.join(stagingRoot, repository.archivePrefix);
-    const ignoreMatcher = new GitIgnoreMatcher(repository.path);
+    if (!isPathWithin(destinationDirectory, stagingRoot)) {
+        throw new Error(`Destination directory escapes staging root: ${destinationDirectory}`);
+    }
+    const ignoreMatcher = new GitIgnoreMatcher(repository.path, ignoreOptions);
     const queue: WalkItem[] = [{ relativePath: '', sourcePath: repository.path }];
 
     while (queue.length > 0) {
@@ -264,6 +387,7 @@ export const copyRepositoryFiles = async (
                 isXcodeProject: repository.isXcodeProject,
                 item,
                 queue,
+                stagingRoot,
             });
             if (result.isFile) {
                 fileCount += 1;