@aikotools/repo-maintenance 1.0.2

package/dist/server/server/trpc/procedures/project.js

@@ -0,0 +1,181 @@
+/**
+ * Project configuration procedures.
+ */
+import { execSync } from 'child_process';
+import { existsSync, readFileSync, statSync } from 'fs';
+import path from 'path';
+import { z } from 'zod';
+import { BulkService } from '../../services/bulk-service';
+import { CascadeService } from '../../services/cascade-service';
+import { DependencyResolver } from '../../services/dependency-resolver';
+import { GitService } from '../../services/git-service';
+import { PackageService } from '../../services/package-service';
+import { PullAllService } from '../../services/pull-all-service';
+import { RepoScanner } from '../../services/repo-scanner';
+import { publicProcedure, router } from '../init';
+/** Re-initialize all services based on config values */
+function reinitializeContext(ctx, config) {
+    const rootFolder = config.rootFolder || '';
+    ctx.scanner = new RepoScanner(rootFolder, config.npmOrganizations || []);
+    ctx.gitService = new GitService(config.parallelTasks || 6);
+    ctx.cascadeService = new CascadeService(ctx.configService, config.parallelTasks || 6);
+    ctx.bulkService = new BulkService(config.parallelTasks || 6);
+    ctx.pullAllService = new PullAllService(config.parallelTasks || 6, ctx.configService);
+    ctx.packageService = new PackageService(rootFolder, config.npmOrganizations || []);
+    ctx.repos = [];
+    ctx.domains = [];
+    ctx.dependencyResolver = null;
+}
+/** Load cached repos/domains/graph into context */
+export async function loadCachedData(ctx) {
+    const cachedRepos = await ctx.configService.getCachedRepos();
+    if (cachedRepos && cachedRepos.length > 0) {
+        ctx.repos = cachedRepos;
+        ctx.dependencyResolver = new DependencyResolver(cachedRepos);
+        ctx.dependencyResolver.buildGraph();
+        // Rebuild domains from cached repos
+        const domainMap = new Map();
+        for (const repo of cachedRepos) {
+            if (!domainMap.has(repo.domain)) {
+                domainMap.set(repo.domain, {
+                    id: repo.domain,
+                    path: `${repo.domain}/`,
+                    repoCount: 0,
+                    hasUncommitted: false,
+                    subGroups: [],
+                });
+            }
+            domainMap.get(repo.domain).repoCount++;
+        }
+        ctx.domains = Array.from(domainMap.values()).sort((a, b) => a.id.localeCompare(b.id));
+    }
+    else {
+        ctx.repos = [];
+        ctx.domains = [];
+        ctx.dependencyResolver = null;
+    }
+}
+export const projectRouter = router({
+    get: publicProcedure.query(async ({ ctx }) => {
+        return ctx.configService.getProjectConfig();
+    }),
+    update: publicProcedure
+        .input(z.object({
+        name: z.string().optional(),
+        rootFolder: z.string().optional(),
+        npmOrganizations: z.array(z.string()).optional(),
+        githubOrganizations: z.array(z.string()).optional(),
+        npmRegistry: z.string().optional(),
+        parallelTasks: z.number().min(1).max(20).optional(),
+        defaultBranch: z.string().optional(),
+        domainOverrides: z.record(z.string(), z.string()).optional(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        if (input.rootFolder) {
+            if (!existsSync(input.rootFolder) || !statSync(input.rootFolder).isDirectory()) {
+                throw new Error(`Folder does not exist: ${input.rootFolder}`);
+            }
+        }
+        const current = await ctx.configService.getProjectConfig();
+        const updated = { ...current, ...input };
+        await ctx.configService.saveProjectConfig(updated);
+        reinitializeContext(ctx, updated);
+        return updated;
+    }),
+    importMapping: publicProcedure
+        .input(z.object({ scriptPath: z.string().optional() }).optional())
+        .mutation(async ({ ctx, input }) => {
+        // Find repo-maintenance.sh: use provided path or auto-detect in rootFolder
+        const config = await ctx.configService.getProjectConfig();
+        const scriptPath = input?.scriptPath ||
+            path.join(config.rootFolder, 'repo-maintenance.sh');
+        if (!existsSync(scriptPath)) {
+            throw new Error(`Script not found: ${scriptPath}`);
+        }
+        const scriptContent = readFileSync(scriptPath, 'utf-8');
+        const result = await ctx.configService.importRepoMapping(scriptContent);
+        return {
+            mappingCount: Object.keys(result.mapping).length,
+            ignoreCount: result.ignore.length,
+        };
+    }),
+    /** Update the full repo mapping (replace all entries) */
+    updateRepoMapping: publicProcedure
+        .input(z.object({ repoMapping: z.record(z.string(), z.string()) }))
+        .mutation(async ({ ctx, input }) => {
+        const config = await ctx.configService.getProjectConfig();
+        config.repoMapping = input.repoMapping;
+        await ctx.configService.saveProjectConfig(config);
+        return { count: Object.keys(input.repoMapping).length };
+    }),
+    /** Update the full ignore list (replace all entries) */
+    updateIgnoreRepos: publicProcedure
+        .input(z.object({ ignoreRepos: z.array(z.string()) }))
+        .mutation(async ({ ctx, input }) => {
+        const config = await ctx.configService.getProjectConfig();
+        config.ignoreRepos = input.ignoreRepos;
+        await ctx.configService.saveProjectConfig(config);
+        return { count: input.ignoreRepos.length };
+    }),
+    browseFolder: publicProcedure
+        .input(z.object({ currentPath: z.string().optional() }).optional())
+        .mutation(({ input }) => {
+        const startDir = input?.currentPath || process.env.HOME || '/';
+        try {
+            const script = `
+          set defaultDir to POSIX file "${startDir}" as alias
+          set chosenFolder to choose folder with prompt "Select root folder" default location defaultDir
+          return POSIX path of chosenFolder
+        `;
+            const result = execSync(`osascript -e '${script}'`, {
+                timeout: 60_000,
+                encoding: 'utf-8',
+            }).trim();
+            return { path: result.replace(/\/$/, '') };
+        }
+        catch {
+            return { path: null };
+        }
+    }),
+    // ── Multi-project endpoints ──
+    listProjects: publicProcedure.query(async ({ ctx }) => {
+        return ctx.configService.listProjectSummaries();
+    }),
+    createProject: publicProcedure
+        .input(z.object({
+        name: z.string().min(1),
+        rootFolder: z.string(),
+        npmOrganizations: z.array(z.string()).optional(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        if (input.rootFolder && !existsSync(input.rootFolder)) {
+            throw new Error(`Folder does not exist: ${input.rootFolder}`);
+        }
+        const slug = await ctx.configService.createProject(input.name, input.rootFolder);
+        // If npm orgs provided, save them into the new project config
+        if (input.npmOrganizations?.length) {
+            const config = await ctx.configService.peekProjectConfig(slug);
+            config.npmOrganizations = input.npmOrganizations;
+            // We need to switch temporarily to save, then switch back
+            const currentSlug = ctx.configService.getActiveProjectSlug();
+            await ctx.configService.switchProject(slug);
+            await ctx.configService.saveProjectConfig(config);
+            await ctx.configService.switchProject(currentSlug);
+        }
+        return { slug };
+    }),
+    switchProject: publicProcedure
+        .input(z.object({ slug: z.string() }))
+        .mutation(async ({ ctx, input }) => {
+        const config = await ctx.configService.switchProject(input.slug);
+        reinitializeContext(ctx, config);
+        await loadCachedData(ctx);
+        return config;
+    }),
+    deleteProject: publicProcedure
+        .input(z.object({ slug: z.string() }))
+        .mutation(async ({ ctx, input }) => {
+        await ctx.configService.deleteProject(input.slug);
+        return { success: true };
+    }),
+});

package/dist/server/server/trpc/procedures/repos.js

@@ -0,0 +1,42 @@
+/**
+ * Repository list, detail, and refresh procedures.
+ */
+import { TRPCError } from '@trpc/server';
+import { z } from 'zod';
+import { DependencyResolver } from '../../services/dependency-resolver';
+import { publicProcedure, router } from '../init';
+export const reposRouter = router({
+    list: publicProcedure.query(({ ctx }) => {
+        return { repos: ctx.repos, domains: ctx.domains };
+    }),
+    refresh: publicProcedure.mutation(async ({ ctx }) => {
+        const config = await ctx.configService.getProjectConfig();
+        const { repos, domains } = await ctx.scanner.scan(config.domainOverrides);
+        const resolver = new DependencyResolver(repos);
+        const graph = resolver.buildGraph();
+        // Update in-memory state
+        ctx.repos = repos;
+        ctx.domains = domains;
+        ctx.dependencyResolver = resolver;
+        // Persist to cache
+        await ctx.configService.saveCachedRepos(repos);
+        await ctx.configService.saveCachedGraph(graph);
+        // Auto-build repoMapping from scanned directory structure
+        const repoMapping = {};
+        for (const repo of repos) {
+            const domainPath = repo.subGroup ? `${repo.domain}/${repo.subGroup}` : repo.domain;
+            repoMapping[repo.id] = domainPath;
+        }
+        config.repoMapping = repoMapping;
+        // Update lastRefresh timestamp
+        config.lastRefresh = new Date().toISOString();
+        await ctx.configService.saveProjectConfig(config);
+        return { repoCount: repos.length, domainCount: domains.length };
+    }),
+    detail: publicProcedure.input(z.object({ id: z.string() })).query(({ ctx, input }) => {
+        const repo = ctx.repos.find((r) => r.id === input.id);
+        if (!repo)
+            throw new TRPCError({ code: 'NOT_FOUND', message: `Repo ${input.id} not found` });
+        return repo;
+    }),
+});

package/dist/server/server/trpc/router.js

@@ -0,0 +1,20 @@
+/**
+ * Root tRPC router - combines all procedure routers.
+ */
+import { router } from './init';
+import { bulkRouter } from './procedures/bulk';
+import { cascadeRouter } from './procedures/cascade';
+import { dependenciesRouter } from './procedures/dependencies';
+import { gitRouter } from './procedures/git';
+import { packageRouter } from './procedures/package';
+import { projectRouter } from './procedures/project';
+import { reposRouter } from './procedures/repos';
+export const appRouter = router({
+    project: projectRouter,
+    repos: reposRouter,
+    dependencies: dependenciesRouter,
+    git: gitRouter,
+    cascade: cascadeRouter,
+    bulk: bulkRouter,
+    package: packageRouter,
+});

package/dist/server/shared/types.js

@@ -0,0 +1,3 @@
+/**
+ * Shared types for RepoHub - used by both server and client.
+ */

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@aikotools/repo-maintenance",
+  "version": "1.0.2",
+  "private": false,
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "repohub": "./bin/repohub.js"
+  },
+  "files": [
+    "dist/",
+    "bin/"
+  ],
+  "scripts": {
+    "dev": "concurrently \"pnpm run dev:server\" \"pnpm run dev:client\"",
+    "dev:server": "npx tsx --watch src/server/index.ts",
+    "dev:client": "vite",
+    "build": "tsc -p tsconfig.server.json && vite build",
+    "build:check": "tsc --noEmit",
+    "format": "prettier --write \"{src,tests}/**/*.{ts,tsx,css,json}\"",
+    "lint": "eslint \"{src,tests}/**/*.{ts,tsx}\"",
+    "test": "pnpm lint && pnpm build && pnpm depcheck && vitest --run --coverage",
+    "depcheck": "depcheck",
+    "start": "node bin/repohub.js"
+  },
+  "dependencies": {
+    "@hono/node-server": "1.13.8",
+    "@tanstack/react-query": "5.90.21",
+    "@trpc/client": "11.10.0",
+    "@trpc/react-query": "11.10.0",
+    "@trpc/server": "11.10.0",
+    "@xyflow/react": "12.10.0",
+    "hono": "4.11.9",
+    "lucide-react": "0.564.0",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "simple-git": "3.27.0",
+    "zod": "4.3.6"
+  },
+  "devDependencies": {
+    "@eslint/js": "10.0.1",
+    "@semantic-release/commit-analyzer": "13.0.0",
+    "@semantic-release/github": "11.0.0",
+    "@semantic-release/npm": "12.0.0",
+    "@tailwindcss/postcss": "4.1.18",
+    "@types/node": "22.0.0",
+    "@types/react": "19.2.14",
+    "@types/react-dom": "19.2.3",
+    "@vitejs/plugin-react": "5.1.4",
+    "@vitest/coverage-v8": "4.0.18",
+    "concurrently": "9.0.0",
+    "depcheck": "1.4.7",
+    "eslint": "10.0.0",
+    "eslint-plugin-react-hooks": "7.0.1",
+    "eslint-plugin-react-refresh": "0.5.0",
+    "postcss": "8.5.6",
+    "prettier": "3.8.1",
+    "semantic-release": "24.0.0",
+    "tailwindcss": "4.1.18",
+    "tsx": "4.19.0",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.55.0",
+    "vite": "7.3.1",
+    "vitest": "4.0.18"
+  }
+}