@hyperdrive.bot/gut 0.1.15 → 0.2.0

package/dist/services/discovery.service.d.ts

@@ -0,0 +1,14 @@
+import { DiscoveredRepo } from '../models/entity.model.js';
+import { ConfigService } from './config.service.js';
+import { EntityService } from './entity.service.js';
+export declare class DiscoveryService {
+    private configService;
+    private entityService;
+    constructor(configService: ConfigService, entityService: EntityService);
+    discover(maxDepth?: number): Promise<DiscoveredRepo[]>;
+    discoverUntracked(maxDepth?: number): Promise<DiscoveredRepo[]>;
+    private buildRegisteredPathIndex;
+    private hasGitEntry;
+    private relativize;
+    private shouldSkipDir;
+}

package/dist/services/discovery.service.js

@@ -0,0 +1,115 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const DEFAULT_MAX_DEPTH = 5;
+const IGNORE_DIRS = new Set([
+    '.cache',
+    '.next',
+    '.serverless',
+    '.specstory',
+    '.turbo',
+    'build',
+    'coverage',
+    'dist',
+    'node_modules',
+    'out',
+]);
+const IGNORE_DIR_PATTERNS = [
+    /^\.serverless-/,
+    /^\.composer-stage-/,
+];
+export class DiscoveryService {
+    configService;
+    entityService;
+    constructor(configService, entityService) {
+        this.configService = configService;
+        this.entityService = entityService;
+    }
+    async discover(maxDepth = DEFAULT_MAX_DEPTH) {
+        const workspaceRoot = this.configService.getWorkspaceRoot();
+        const registeredPaths = this.buildRegisteredPathIndex();
+        const results = [];
+        const queue = [{ absPath: workspaceRoot, depth: 0 }];
+        while (queue.length > 0) {
+            const { absPath, depth } = queue.shift();
+            const isWorkspaceRoot = absPath === workspaceRoot;
+            if (this.hasGitEntry(absPath)) {
+                const relativePath = this.relativize(workspaceRoot, absPath);
+                const registered = registeredPaths.get(path.resolve(absPath));
+                results.push({
+                    entityName: registered,
+                    isRegistered: Boolean(registered),
+                    isWorkspaceRoot,
+                    path: absPath,
+                    relativePath,
+                });
+                // A nested repo's subtree is its own concern — stop descending.
+                // Exception: the workspace root. The super-repo itself owns submodules
+                // and nested untracked repos; we must descend past it to find them.
+                if (!isWorkspaceRoot)
+                    continue;
+            }
+            if (depth >= maxDepth) {
+                continue;
+            }
+            let children;
+            try {
+                children = fs.readdirSync(absPath);
+            }
+            catch {
+                continue;
+            }
+            for (const child of children) {
+                if (this.shouldSkipDir(child))
+                    continue;
+                const childPath = path.join(absPath, child);
+                let stat;
+                try {
+                    stat = fs.lstatSync(childPath);
+                }
+                catch {
+                    continue;
+                }
+                // Skip symlinks to avoid loops and leaking outside the workspace.
+                if (stat.isSymbolicLink())
+                    continue;
+                if (!stat.isDirectory())
+                    continue;
+                queue.push({ absPath: childPath, depth: depth + 1 });
+            }
+        }
+        return results;
+    }
+    async discoverUntracked(maxDepth = DEFAULT_MAX_DEPTH) {
+        const all = await this.discover(maxDepth);
+        return all.filter(repo => !repo.isRegistered);
+    }
+    buildRegisteredPathIndex() {
+        const index = new Map();
+        for (const entity of this.entityService.getAllEntities()) {
+            const absolute = path.resolve(this.entityService.resolveEntityPath(entity));
+            index.set(absolute, entity.name);
+        }
+        return index;
+    }
+    hasGitEntry(dirPath) {
+        // .git can be a directory (normal repo) or a file (submodule / worktree).
+        const gitPath = path.join(dirPath, '.git');
+        try {
+            return fs.existsSync(gitPath);
+        }
+        catch {
+            return false;
+        }
+    }
+    relativize(workspaceRoot, absPath) {
+        if (absPath === workspaceRoot)
+            return '.';
+        const rel = path.relative(workspaceRoot, absPath);
+        return rel === '' ? '.' : rel;
+    }
+    shouldSkipDir(name) {
+        if (IGNORE_DIRS.has(name))
+            return true;
+        return IGNORE_DIR_PATTERNS.some(pattern => pattern.test(name));
+    }
+}

package/dist/services/discovery.service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/discovery.service.test.js

@@ -0,0 +1,140 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { ConfigService } from './config.service.js';
+import { DiscoveryService } from './discovery.service.js';
+import { EntityService } from './entity.service.js';
+function mkdir(p) {
+    fs.mkdirSync(p, { recursive: true });
+}
+function mkGitDir(p) {
+    mkdir(p);
+    mkdir(path.join(p, '.git'));
+}
+function mkGitFile(p, content = 'gitdir: ../.git/worktrees/x\n') {
+    mkdir(p);
+    fs.writeFileSync(path.join(p, '.git'), content);
+}
+describe('DiscoveryService', () => {
+    let workspaceRoot;
+    let configService;
+    let entityService;
+    let discoveryService;
+    beforeEach(() => {
+        workspaceRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'gut-discovery-'));
+        mkdir(path.join(workspaceRoot, '.gut'));
+        fs.writeFileSync(path.join(workspaceRoot, '.gut', 'config.json'), JSON.stringify({ entities: [], initialized: true, workspace: workspaceRoot }));
+        mkGitDir(workspaceRoot);
+        configService = new ConfigService(workspaceRoot);
+        entityService = new EntityService(configService);
+        discoveryService = new DiscoveryService(configService, entityService);
+    });
+    afterEach(() => {
+        fs.rmSync(workspaceRoot, { force: true, recursive: true });
+    });
+    describe('discover()', () => {
+        it('always returns the workspace root as a discovered repo', async () => {
+            const result = await discoveryService.discover();
+            const workspaceRootHit = result.find(r => r.isWorkspaceRoot);
+            expect(workspaceRootHit).toBeDefined();
+            expect(workspaceRootHit.relativePath).toBe('.');
+            expect(workspaceRootHit.path).toBe(workspaceRoot);
+            expect(workspaceRootHit.isRegistered).toBe(false);
+        });
+        it('finds nested .git dirs as directories', async () => {
+            mkGitDir(path.join(workspaceRoot, 'packages', 'cli', 'foo'));
+            const result = await discoveryService.discover();
+            const foo = result.find(r => r.relativePath === path.join('packages', 'cli', 'foo'));
+            expect(foo).toBeDefined();
+            expect(foo.isRegistered).toBe(false);
+        });
+        it('treats .git files (worktree/submodule) as repo markers', async () => {
+            mkGitFile(path.join(workspaceRoot, 'packages', 'cli', 'worktree'));
+            const result = await discoveryService.discover();
+            const hit = result.find(r => r.relativePath === path.join('packages', 'cli', 'worktree'));
+            expect(hit).toBeDefined();
+        });
+        it('does not descend into a repo subtree once a .git is found', async () => {
+            // A repo at packages/cli/foo, and a nested .git inside its subdir should NOT be found.
+            mkGitDir(path.join(workspaceRoot, 'packages', 'cli', 'foo'));
+            mkGitDir(path.join(workspaceRoot, 'packages', 'cli', 'foo', 'vendored', 'nested'));
+            const result = await discoveryService.discover();
+            const nested = result.find(r => r.relativePath === path.join('packages', 'cli', 'foo', 'vendored', 'nested'));
+            expect(nested).toBeUndefined();
+        });
+        it('ignores node_modules/**, dist/**, build/**, .serverless/**, .serverless-*/', async () => {
+            mkGitDir(path.join(workspaceRoot, 'node_modules', 'pkg'));
+            mkGitDir(path.join(workspaceRoot, 'dist', 'hidden'));
+            mkGitDir(path.join(workspaceRoot, 'build', 'hidden'));
+            mkGitDir(path.join(workspaceRoot, '.serverless', 'hidden'));
+            mkGitDir(path.join(workspaceRoot, '.serverless-contacts', 'hidden'));
+            mkGitDir(path.join(workspaceRoot, '.composer-stage-1', 'hidden'));
+            const result = await discoveryService.discover();
+            expect(result.filter(r => !r.isWorkspaceRoot)).toHaveLength(0);
+        });
+        it('respects maxDepth — deeper repos are not found', async () => {
+            // Repo at depth 6: packages/a/b/c/d/e/.git
+            const deepPath = path.join(workspaceRoot, 'packages', 'a', 'b', 'c', 'd', 'e');
+            mkGitDir(deepPath);
+            const resultShallow = await discoveryService.discover(5);
+            expect(resultShallow.find(r => r.relativePath.endsWith('e'))).toBeUndefined();
+            const resultDeep = await discoveryService.discover(10);
+            expect(resultDeep.find(r => r.relativePath.endsWith('e'))).toBeDefined();
+        });
+        it('marks registered entities with isRegistered + entityName', async () => {
+            const entityDir = path.join(workspaceRoot, 'packages', 'cli', 'foo');
+            mkGitDir(entityDir);
+            fs.writeFileSync(path.join(workspaceRoot, '.gut', 'config.json'), JSON.stringify({
+                entities: [{ name: 'foo', path: 'packages/cli/foo', type: 'tool' }],
+                initialized: true,
+                workspace: workspaceRoot,
+            }));
+            // Rebuild services so the new config is picked up.
+            configService = new ConfigService(workspaceRoot);
+            entityService = new EntityService(configService);
+            discoveryService = new DiscoveryService(configService, entityService);
+            const result = await discoveryService.discover();
+            const foo = result.find(r => r.relativePath === path.join('packages', 'cli', 'foo'));
+            expect(foo).toBeDefined();
+            expect(foo.isRegistered).toBe(true);
+            expect(foo.entityName).toBe('foo');
+        });
+        it('skips symlinks to avoid loops and leaking outside workspace', async () => {
+            // Create an external "other" repo and symlink it inside the workspace.
+            const outside = fs.mkdtempSync(path.join(os.tmpdir(), 'gut-outside-'));
+            try {
+                mkGitDir(outside);
+                fs.symlinkSync(outside, path.join(workspaceRoot, 'linked'), 'dir');
+                const result = await discoveryService.discover();
+                expect(result.find(r => r.relativePath === 'linked')).toBeUndefined();
+            }
+            finally {
+                fs.rmSync(outside, { force: true, recursive: true });
+            }
+        });
+    });
+    describe('discoverUntracked()', () => {
+        it('returns only repos not covered by a registered entity', async () => {
+            mkGitDir(path.join(workspaceRoot, 'packages', 'cli', 'registered'));
+            mkGitDir(path.join(workspaceRoot, 'packages', 'cli', 'untracked'));
+            fs.writeFileSync(path.join(workspaceRoot, '.gut', 'config.json'), JSON.stringify({
+                entities: [{ name: 'registered', path: 'packages/cli/registered', type: 'tool' }],
+                initialized: true,
+                workspace: workspaceRoot,
+            }));
+            configService = new ConfigService(workspaceRoot);
+            entityService = new EntityService(configService);
+            discoveryService = new DiscoveryService(configService, entityService);
+            const result = await discoveryService.discoverUntracked();
+            const relPaths = result.map(r => r.relativePath).sort();
+            expect(relPaths).toEqual(['.', path.join('packages', 'cli', 'untracked')].sort());
+        });
+        it('super-repo root is always untracked (never in the entity list)', async () => {
+            const result = await discoveryService.discoverUntracked();
+            const root = result.find(r => r.isWorkspaceRoot);
+            expect(root).toBeDefined();
+            expect(root.isRegistered).toBe(false);
+        });
+    });
+});