@aikotools/repo-maintenance 1.0.2

package/dist/server/server/services/pull-all-service.js

@@ -0,0 +1,415 @@
+/**
+ * Service for pulling all repos in parallel with progress tracking,
+ * cancellation support, "no tracking information" fallback,
+ * and GitHub-based clone-missing + pull-existing flow.
+ * Follows the BulkService fire-and-forget pattern.
+ */
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import simpleGit from 'simple-git';
+import { spawnProcess } from './process';
+import { TaskQueue } from './task-queue';
+export class PullAllService {
+    defaultConcurrency;
+    configService;
+    executions = new Map();
+    abortControllers = new Map();
+    constructor(defaultConcurrency, configService) {
+        this.defaultConcurrency = defaultConcurrency;
+        this.configService = configService;
+    }
+    /**
+     * Start pulling all repos in the background.
+     * If repoMapping is configured, fetches GitHub repos, clones missing, and pulls existing.
+     * Otherwise falls back to pulling only locally known repos.
+     * Returns execution ID for polling.
+     */
+    startPullAll(repos, config) {
+        const id = `pull-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const execution = {
+            id,
+            status: 'running',
+            results: [],
+            completedCount: 0,
+            failedCount: 0,
+            withChanges: 0,
+            clonedCount: 0,
+            skippedCount: 0,
+            unmappedCount: 0,
+            total: 0,
+            startedAt: new Date().toISOString(),
+        };
+        this.executions.set(id, execution);
+        const controller = new AbortController();
+        this.abortControllers.set(id, controller);
+        // Fire-and-forget: resolve config (auto-import if needed) then execute
+        this.resolveConfigAndExecute(id, repos, config, controller.signal).catch((err) => {
+            console.error(`[PullAll] Execution ${id} failed:`, err);
+            const exec = this.executions.get(id);
+            if (exec && exec.status === 'running') {
+                exec.status = 'completed';
+                exec.completedAt = new Date().toISOString();
+            }
+        });
+        return id;
+    }
+    getExecution(id) {
+        return this.executions.get(id);
+    }
+    abort(id) {
+        const exec = this.executions.get(id);
+        if (!exec || exec.status !== 'running')
+            return false;
+        const controller = this.abortControllers.get(id);
+        if (controller)
+            controller.abort();
+        exec.status = 'aborted';
+        exec.completedAt = new Date().toISOString();
+        for (const result of exec.results) {
+            if (result.status === 'pending') {
+                result.status = 'aborted';
+                result.message = 'Aborted';
+            }
+        }
+        this.saveToHistory(exec);
+        return true;
+    }
+    // ── Config resolution: auto-import mapping if repo-maintenance.sh exists ──
+    async resolveConfigAndExecute(executionId, repos, config, signal) {
+        const exec = this.executions.get(executionId);
+        if (!exec)
+            return;
+        let effectiveConfig = config;
+        // Auto-import mapping from repo-maintenance.sh if not yet configured
+        const hasMapping = config.repoMapping && Object.keys(config.repoMapping).length > 0;
+        if (!hasMapping) {
+            const scriptPath = path.join(config.rootFolder, 'repo-maintenance.sh');
+            if (existsSync(scriptPath)) {
+                try {
+                    console.log('[PullAll] Auto-importing repo mapping from repo-maintenance.sh...');
+                    const scriptContent = readFileSync(scriptPath, 'utf-8');
+                    const result = await this.configService.importRepoMapping(scriptContent);
+                    console.log(`[PullAll] Imported ${Object.keys(result.mapping).length} mappings, ${result.ignore.length} ignore rules`);
+                    // Reload config with the newly imported mapping
+                    effectiveConfig = await this.configService.getProjectConfig();
+                }
+                catch (err) {
+                    console.error('[PullAll] Failed to auto-import mapping:', err);
+                }
+            }
+        }
+        const hasMappingNow = effectiveConfig.repoMapping && Object.keys(effectiveConfig.repoMapping).length > 0;
+        if (hasMappingNow) {
+            await this.executeWithGitHub(executionId, repos, effectiveConfig, signal);
+        }
+        else {
+            // Fallback: only pull locally known repos (old behavior)
+            exec.results = repos.map((r) => ({
+                repoId: r.path,
+                success: false,
+                message: '',
+                changes: 0,
+                status: 'pending',
+            }));
+            exec.total = repos.length;
+            await this.executeLocalOnly(executionId, repos, effectiveConfig.defaultBranch, signal);
+        }
+    }
+    // ── GitHub-based flow: fetch repos, clone missing, pull existing ──
+    async executeWithGitHub(executionId, localRepos, config, signal) {
+        const exec = this.executions.get(executionId);
+        if (!exec)
+            return;
+        const org = config.githubOrganizations[0];
+        if (!org) {
+            exec.status = 'completed';
+            exec.completedAt = new Date().toISOString();
+            return;
+        }
+        // 1. Fetch GitHub repos
+        let githubRepos;
+        try {
+            githubRepos = await this.fetchGithubRepos(org);
+        }
+        catch (err) {
+            console.error('[PullAll] Failed to fetch GitHub repos:', err);
+            // Fallback to local-only pull
+            exec.results = localRepos.map((r) => ({
+                repoId: r.path,
+                success: false,
+                message: '',
+                changes: 0,
+                status: 'pending',
+            }));
+            exec.total = localRepos.length;
+            await this.executeLocalOnly(executionId, localRepos, config.defaultBranch, signal);
+            return;
+        }
+        if (signal.aborted)
+            return;
+        // 2. Build local lookup: repo directory name → Repo
+        const localMap = new Map();
+        for (const repo of localRepos) {
+            const dirName = path.basename(repo.absolutePath);
+            localMap.set(dirName, repo);
+        }
+        // 3. Build execution items from GitHub repos
+        const items = [];
+        for (const ghRepo of githubRepos) {
+            if (config.ignoreRepos?.includes(ghRepo)) {
+                items.push({ name: ghRepo, action: 'skip' });
+            }
+            else if (!config.repoMapping?.[ghRepo]) {
+                items.push({ name: ghRepo, action: 'unmapped' });
+            }
+            else if (localMap.has(ghRepo)) {
+                items.push({ name: ghRepo, action: 'pull', repo: localMap.get(ghRepo) });
+            }
+            else {
+                items.push({
+                    name: ghRepo,
+                    action: 'clone',
+                    targetDir: config.repoMapping[ghRepo],
+                });
+            }
+        }
+        // 4. Initialize execution results
+        exec.results = items.map((item) => {
+            const repoId = item.action === 'pull'
+                ? item.repo.path
+                : item.action === 'clone'
+                    ? `${item.targetDir}/${item.name}`
+                    : item.name;
+            if (item.action === 'skip') {
+                exec.skippedCount++;
+                return {
+                    repoId,
+                    success: true,
+                    message: 'Ignored',
+                    changes: 0,
+                    status: 'skipped',
+                };
+            }
+            if (item.action === 'unmapped') {
+                exec.unmappedCount++;
+                return {
+                    repoId,
+                    success: true,
+                    message: 'No mapping defined',
+                    changes: 0,
+                    status: 'unmapped',
+                };
+            }
+            return {
+                repoId,
+                success: false,
+                message: '',
+                changes: 0,
+                status: 'pending',
+            };
+        });
+        exec.total = items.length;
+        // 5. Execute clone/pull items in parallel
+        const actionItems = items.filter((i) => i.action === 'pull' || i.action === 'clone');
+        const queue = new TaskQueue(this.defaultConcurrency);
+        await queue.run(actionItems, async (item) => {
+            if (signal.aborted)
+                return;
+            const result = exec.results.find((r) => r.repoId ===
+                (item.action === 'pull'
+                    ? item.repo.path
+                    : `${item.targetDir}/${item.name}`));
+            if (!result)
+                return;
+            result.status = 'running';
+            try {
+                if (item.action === 'pull') {
+                    const pullResult = await this.pullWithFallback(item.repo.absolutePath, config.defaultBranch);
+                    result.success = pullResult.success;
+                    result.message = pullResult.message;
+                    result.changes = pullResult.changes;
+                    result.status = pullResult.success ? 'completed' : 'failed';
+                    if (pullResult.success) {
+                        exec.completedCount++;
+                        if (pullResult.changes > 0)
+                            exec.withChanges++;
+                    }
+                    else {
+                        exec.failedCount++;
+                    }
+                }
+                else if (item.action === 'clone') {
+                    const cloneResult = await this.cloneRepo(org, item.name, path.join(config.rootFolder, item.targetDir, item.name));
+                    result.success = cloneResult.success;
+                    result.message = cloneResult.message;
+                    result.changes = 0;
+                    result.status = cloneResult.success ? 'cloned' : 'failed';
+                    if (cloneResult.success) {
+                        exec.clonedCount++;
+                    }
+                    else {
+                        exec.failedCount++;
+                    }
+                }
+            }
+            catch (err) {
+                if (signal.aborted)
+                    return;
+                result.status = 'failed';
+                result.success = false;
+                result.message = `Failed (${item.name}): ${err instanceof Error ? err.message : String(err)}`;
+                exec.failedCount++;
+            }
+        });
+        if (exec.status === 'running') {
+            exec.status = 'completed';
+            exec.completedAt = new Date().toISOString();
+        }
+        this.saveToHistory(exec);
+    }
+    // ── Fallback: pull only local repos (old behavior) ──
+    async executeLocalOnly(executionId, repos, defaultBranch, signal) {
+        const exec = this.executions.get(executionId);
+        if (!exec)
+            return;
+        const queue = new TaskQueue(this.defaultConcurrency);
+        await queue.run(repos, async (repo) => {
+            if (signal.aborted)
+                return;
+            const resultIndex = exec.results.findIndex((r) => r.repoId === repo.path);
+            if (resultIndex === -1)
+                return;
+            const result = exec.results[resultIndex];
+            result.status = 'running';
+            try {
+                const pullResult = await this.pullWithFallback(repo.absolutePath, defaultBranch);
+                result.success = pullResult.success;
+                result.message = pullResult.message;
+                result.changes = pullResult.changes;
+                result.status = pullResult.success ? 'completed' : 'failed';
+                if (pullResult.success) {
+                    exec.completedCount++;
+                    if (pullResult.changes > 0) {
+                        exec.withChanges++;
+                    }
+                }
+                else {
+                    exec.failedCount++;
+                }
+            }
+            catch (err) {
+                if (signal.aborted)
+                    return;
+                result.status = 'failed';
+                result.success = false;
+                result.message = `Pull failed (${repo.path}): ${err instanceof Error ? err.message : String(err)}`;
+                exec.failedCount++;
+            }
+        });
+        if (exec.status === 'running') {
+            exec.status = 'completed';
+            exec.completedAt = new Date().toISOString();
+        }
+        this.saveToHistory(exec);
+    }
+    // ── Helper methods ──
+    /**
+     * Fetch all non-archived repo names from a GitHub organization via `gh` CLI.
+     */
+    async fetchGithubRepos(org) {
+        const { promise } = spawnProcess([
+            'gh', 'repo', 'list', org, '--limit', '200', '--no-archived', '--json', 'name', '--jq', '.[].name',
+        ]);
+        const result = await promise;
+        if (result.exitCode !== 0) {
+            throw new Error(`gh repo list failed (exit ${result.exitCode}): ${result.stderr}`);
+        }
+        return result.stdout
+            .trim()
+            .split('\n')
+            .filter(Boolean)
+            .sort();
+    }
+    /**
+     * Clone a repo from GitHub into the target path.
+     */
+    async cloneRepo(org, name, targetPath) {
+        // If target already exists with .git, treat as already cloned
+        if (existsSync(path.join(targetPath, '.git'))) {
+            return { success: true, message: 'Already exists locally' };
+        }
+        const { promise } = spawnProcess([
+            'gh', 'repo', 'clone', `${org}/${name}`, targetPath, '--', '--quiet',
+        ]);
+        const result = await promise;
+        if (result.exitCode !== 0) {
+            return { success: false, message: `Clone failed: ${result.stderr.trim()}` };
+        }
+        return { success: true, message: 'Cloned successfully' };
+    }
+    /**
+     * Pull a repo. If it fails with "no tracking information", retry with
+     * explicit origin + defaultBranch.
+     */
+    async pullWithFallback(repoPath, defaultBranch) {
+        const git = simpleGit(repoPath);
+        try {
+            const result = await git.pull();
+            return {
+                success: true,
+                message: result.summary.changes
+                    ? `${result.summary.changes} changes, ${result.summary.insertions} insertions, ${result.summary.deletions} deletions`
+                    : 'Already up to date',
+                changes: result.summary.changes,
+            };
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            // Fallback: try explicit origin + defaultBranch
+            if (errMsg.includes('no tracking information') || errMsg.includes('There is no tracking')) {
+                try {
+                    const result = await git.pull('origin', defaultBranch);
+                    return {
+                        success: true,
+                        message: result.summary.changes
+                            ? `${result.summary.changes} changes (via origin/${defaultBranch})`
+                            : `Already up to date (via origin/${defaultBranch})`,
+                        changes: result.summary.changes,
+                    };
+                }
+                catch (retryErr) {
+                    return {
+                        success: false,
+                        message: `Pull failed: ${retryErr instanceof Error ? retryErr.message : String(retryErr)}`,
+                        changes: 0,
+                    };
+                }
+            }
+            return {
+                success: false,
+                message: `Pull failed: ${errMsg}`,
+                changes: 0,
+            };
+        }
+    }
+    saveToHistory(exec) {
+        this.configService
+            .savePullAllHistory({
+            id: exec.id,
+            status: exec.status === 'aborted' ? 'aborted' : 'completed',
+            total: exec.total,
+            completedCount: exec.completedCount,
+            failedCount: exec.failedCount,
+            withChanges: exec.withChanges,
+            clonedCount: exec.clonedCount,
+            skippedCount: exec.skippedCount,
+            unmappedCount: exec.unmappedCount,
+            startedAt: exec.startedAt,
+            completedAt: exec.completedAt,
+            results: exec.results,
+        })
+            .catch((err) => {
+            console.error('[PullAll] Failed to save history:', err);
+        });
+    }
+}

package/dist/server/server/services/repo-scanner.js

@@ -0,0 +1,230 @@
+/**
+ * Service for scanning the repo/ directory and extracting package info.
+ * Builds the complete list of repos with their metadata, domains, and internal dependencies.
+ */
+import { readFile, readdir, stat } from 'fs/promises';
+import path from 'path';
+/** Known sub-group directories within domains */
+const KNOWN_SUB_GROUPS = new Set([
+    'outbound',
+    'inbound',
+    'validators',
+    'gov-api',
+    'tax',
+    'export',
+]);
+/** Directories to skip during scanning */
+const SKIP_DIRS = new Set(['node_modules', 'dist', '.git', 'coverage', '.repoMaintenance']);
+export class RepoScanner {
+    rootFolder;
+    npmOrgs;
+    constructor(rootFolder, npmOrgs) {
+        this.rootFolder = rootFolder;
+        this.npmOrgs = npmOrgs;
+    }
+    async scan(domainOverrides) {
+        const repoDir = this.rootFolder;
+        const repos = [];
+        // Scan all domain directories under repo/
+        const domainDirs = await this.listDirs(repoDir);
+        for (const domainName of domainDirs) {
+            const domainPath = path.join(repoDir, domainName);
+            await this.scanDomain(domainPath, domainName, repos);
+        }
+        // Apply domain overrides (repoId → domain)
+        if (domainOverrides) {
+            for (const repo of repos) {
+                const override = domainOverrides[repo.id];
+                if (override) {
+                    repo.domain = override;
+                }
+            }
+        }
+        // Build npm name -> repo ID lookup
+        const npmToRepo = new Map();
+        for (const repo of repos) {
+            npmToRepo.set(repo.npmPackage, repo.id);
+        }
+        // Resolve dependency repo IDs
+        for (const repo of repos) {
+            for (const dep of repo.dependencies) {
+                const repoId = npmToRepo.get(dep.npmName);
+                if (repoId) {
+                    dep.repoId = repoId;
+                }
+            }
+            // Filter out deps that don't map to a known repo
+            repo.dependencies = repo.dependencies.filter((d) => d.repoId);
+        }
+        // Compute dependents (reverse lookup)
+        for (const repo of repos) {
+            for (const dep of repo.dependencies) {
+                const depRepo = repos.find((r) => r.id === dep.repoId);
+                if (depRepo && !depRepo.dependents.includes(repo.id)) {
+                    depRepo.dependents.push(repo.id);
+                }
+            }
+        }
+        // Build domain structure
+        const domains = this.buildDomains(repos);
+        return { repos, domains };
+    }
+    async scanDomain(domainPath, domainName, repos) {
+        const entries = await this.listDirs(domainPath);
+        for (const entry of entries) {
+            const entryPath = path.join(domainPath, entry);
+            if (KNOWN_SUB_GROUPS.has(entry)) {
+                // This is a sub-group (e.g. invoice/outbound/) - scan its children
+                const subEntries = await this.listDirs(entryPath);
+                for (const subEntry of subEntries) {
+                    const subPath = path.join(entryPath, subEntry);
+                    const repo = await this.tryParseRepo(subPath, domainName, entry);
+                    if (repo)
+                        repos.push(repo);
+                }
+            }
+            else if (domainName === 'apps') {
+                // apps/ has nested structure: apps/invoice/saas-invoice-backend
+                const appEntries = await this.listDirs(entryPath);
+                for (const appEntry of appEntries) {
+                    const appPath = path.join(entryPath, appEntry);
+                    const repo = await this.tryParseRepo(appPath, domainName, entry);
+                    if (repo)
+                        repos.push(repo);
+                }
+                // Also check if the entry itself is a repo (e.g. apps/invoice.xhub-customer-saas)
+                const directRepo = await this.tryParseRepo(entryPath, domainName);
+                if (directRepo)
+                    repos.push(directRepo);
+            }
+            else {
+                // Direct repo directory
+                const repo = await this.tryParseRepo(entryPath, domainName);
+                if (repo)
+                    repos.push(repo);
+            }
+        }
+    }
+    async tryParseRepo(repoPath, domain, subGroup) {
+        const pkgPath = path.join(repoPath, 'package.json');
+        try {
+            const content = await readFile(pkgPath, 'utf-8');
+            const pkg = JSON.parse(content);
+            if (!pkg.name)
+                return null;
+            const relativePath = path.relative(this.rootFolder, repoPath);
+            const dirName = path.basename(repoPath);
+            // Extract internal dependencies
+            const allDeps = {
+                ...pkg.dependencies,
+                ...pkg.peerDependencies,
+            };
+            const internalDeps = this.filterInternalDeps(allDeps);
+            return {
+                id: dirName,
+                path: relativePath,
+                absolutePath: repoPath,
+                domain,
+                subGroup,
+                type: this.detectRepoType(pkg.name, dirName),
+                npmPackage: pkg.name,
+                version: pkg.version || '0.0.0',
+                dependencies: internalDeps,
+                dependents: [],
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    detectRepoType(npmName, dirName) {
+        const name = npmName.replace(/^@[^/]+\//, '');
+        if (name === 'kernel')
+            return 'kernel';
+        if (name === 'frontend-kernel')
+            return 'frontend-kernel';
+        if (name.startsWith('kernel-plugin-'))
+            return 'kernel-plugin';
+        if (name.startsWith('frontend-plugin-'))
+            return 'frontend-plugin';
+        if (name.startsWith('frontend-ui-') || name === 'frontend-ui-components')
+            return 'frontend-ui';
+        if (name.startsWith('frontend-app-'))
+            return 'frontend-ui';
+        if (name.startsWith('lib-'))
+            return 'lib';
+        if (name.startsWith('saas-'))
+            return 'app';
+        if (name.startsWith('tool-'))
+            return 'tool';
+        if (name.startsWith('mock-'))
+            return 'mock';
+        if (dirName.includes('xhub-'))
+            return 'integration';
+        return 'lib';
+    }
+    filterInternalDeps(deps) {
+        if (!deps)
+            return [];
+        const result = [];
+        for (const [name, version] of Object.entries(deps)) {
+            const isInternal = this.npmOrgs.some((org) => name.startsWith(`${org}/`));
+            if (isInternal) {
+                result.push({
+                    npmName: name,
+                    repoId: '',
+                    versionSpec: version,
+                });
+            }
+        }
+        return result;
+    }
+    buildDomains(repos) {
+        const domainMap = new Map();
+        for (const repo of repos) {
+            if (!domainMap.has(repo.domain)) {
+                domainMap.set(repo.domain, {
+                    id: repo.domain,
+                    path: `${repo.domain}/`,
+                    repoCount: 0,
+                    hasUncommitted: false,
+                    subGroups: [],
+                });
+            }
+            const domain = domainMap.get(repo.domain);
+            domain.repoCount++;
+            if (repo.subGroup) {
+                let subGroup = domain.subGroups.find((sg) => sg.id === repo.subGroup);
+                if (!subGroup) {
+                    subGroup = {
+                        id: repo.subGroup,
+                        path: `${repo.domain}/${repo.subGroup}/`,
+                        repoIds: [],
+                    };
+                    domain.subGroups.push(subGroup);
+                }
+                subGroup.repoIds.push(repo.id);
+            }
+        }
+        return Array.from(domainMap.values()).sort((a, b) => a.id.localeCompare(b.id));
+    }
+    async listDirs(dirPath) {
+        try {
+            const entries = await readdir(dirPath);
+            const dirs = [];
+            for (const entry of entries) {
+                if (SKIP_DIRS.has(entry) || entry.startsWith('.'))
+                    continue;
+                const entryPath = path.join(dirPath, entry);
+                const s = await stat(entryPath);
+                if (s.isDirectory()) {
+                    dirs.push(entry);
+                }
+            }
+            return dirs.sort();
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/dist/server/server/services/task-queue.js

@@ -0,0 +1,29 @@
+/**
+ * Generic parallel task execution helper with controlled concurrency.
+ */
+export class TaskQueue {
+    concurrency;
+    constructor(concurrency) {
+        this.concurrency = concurrency;
+    }
+    async run(items, fn) {
+        const results = [];
+        let index = 0;
+        const runNext = async () => {
+            while (index < items.length) {
+                const currentIndex = index++;
+                const item = items[currentIndex];
+                try {
+                    const result = await fn(item);
+                    results[currentIndex] = { item, result };
+                }
+                catch (err) {
+                    results[currentIndex] = { item, error: err instanceof Error ? err : new Error(String(err)) };
+                }
+            }
+        };
+        const workers = Array.from({ length: Math.min(this.concurrency, items.length) }, () => runNext());
+        await Promise.all(workers);
+        return results;
+    }
+}

package/dist/server/server/trpc/context.js

@@ -0,0 +1,4 @@
+/**
+ * tRPC context - holds all services and in-memory state.
+ * No auth needed since this is a local-only tool.
+ */

package/dist/server/server/trpc/init.js

@@ -0,0 +1,7 @@
+/**
+ * tRPC initialization with context type.
+ */
+import { initTRPC } from '@trpc/server';
+const t = initTRPC.context().create();
+export const router = t.router;
+export const publicProcedure = t.procedure;