@thoughtflow/core 0.1.2

package/dist/tools/workspace/project-scanner.tool.js

@@ -0,0 +1,979 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectScannerTool = exports.MONOREPO_RULES = exports.TECH_RULES = void 0;
+const zod_1 = require("zod");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const tool_base_class_1 = require("../base/tool-base.class");
+const path_utils_1 = require("../base/path-utils");
+/* ═══════════════════════════════════════════════════════════════
+   TECH RULES — sorted by category, then by specificity.
+   Framework rules should come AFTER language rules so the
+   output reads naturally (language first, then framework).
+   ═══════════════════════════════════════════════════════════════ */
+exports.TECH_RULES = [
+    // ——— Languages ———————————————————————————————————————
+    {
+        id: "typescript",
+        name: "TypeScript",
+        category: "language",
+        fileMarkers: ["tsconfig.json", "tsconfig.base.json"],
+        dirMarkers: [],
+        ignoreDirs: ["node_modules", "dist", "build", ".tsbuildinfo"],
+        keyFiles: ["tsconfig.json"],
+        explorePatterns: [],
+        hints: [],
+    },
+    {
+        id: "nodejs",
+        name: "Node.js",
+        category: "language",
+        fileMarkers: ["package.json"],
+        dirMarkers: [],
+        ignoreDirs: ["node_modules", "dist", "build", ".cache", ".parcel-cache"],
+        keyFiles: ["package.json"],
+        explorePatterns: [],
+        hints: ["Check 'scripts' in package.json for build/start/test commands"],
+    },
+    {
+        id: "python",
+        name: "Python",
+        category: "language",
+        fileMarkers: [
+            "pyproject.toml",
+            "setup.py",
+            "requirements.txt",
+            "Pipfile",
+            "setup.cfg",
+        ],
+        dirMarkers: [],
+        ignoreDirs: [
+            "__pycache__",
+            ".venv",
+            "venv",
+            "env",
+            ".eggs",
+            ".mypy_cache",
+            ".pytest_cache",
+            ".ruff_cache",
+        ],
+        keyFiles: ["pyproject.toml", "requirements.txt", "setup.py"],
+        explorePatterns: ["**/*.py"],
+        hints: ["Entry points in pyproject.toml [project.scripts] or setup.py"],
+    },
+    {
+        id: "rust",
+        name: "Rust",
+        category: "language",
+        fileMarkers: ["Cargo.toml"],
+        dirMarkers: [],
+        ignoreDirs: ["target"],
+        keyFiles: ["Cargo.toml", "src/main.rs", "src/lib.rs"],
+        explorePatterns: ["**/*.rs"],
+        hints: ["Binaries in src/bin/, library in src/lib.rs"],
+    },
+    {
+        id: "go",
+        name: "Go",
+        category: "language",
+        fileMarkers: ["go.mod"],
+        dirMarkers: [],
+        ignoreDirs: ["vendor"],
+        keyFiles: ["go.mod"],
+        explorePatterns: ["**/*.go"],
+        hints: ["Binaries in cmd/, private libs in internal/"],
+    },
+    {
+        id: "php",
+        name: "PHP",
+        category: "language",
+        fileMarkers: ["composer.json"],
+        dirMarkers: [],
+        ignoreDirs: ["vendor", "storage/framework"],
+        keyFiles: ["composer.json"],
+        explorePatterns: ["**/*.php"],
+        hints: ["PSR-4 autoloading in composer.json"],
+    },
+    {
+        id: "java",
+        name: "Java",
+        category: "language",
+        fileMarkers: ["pom.xml", "build.gradle", "build.gradle.kts"],
+        dirMarkers: [],
+        ignoreDirs: ["target", "build", ".gradle", "out"],
+        keyFiles: ["pom.xml", "build.gradle", "build.gradle.kts"],
+        explorePatterns: ["**/*.java", "**/*.kt"],
+        hints: ["Source in src/main/java, tests in src/test/java"],
+    },
+    {
+        id: "dotnet",
+        name: ".NET/C#",
+        category: "language",
+        fileMarkers: [], // detected via extension scan in detectTechs
+        dirMarkers: [],
+        ignoreDirs: ["bin", "obj", ".vs"],
+        keyFiles: [],
+        explorePatterns: ["**/*.cs", "**/*.csproj"],
+        hints: [".sln defines project structure, .csproj defines build"],
+    },
+    {
+        id: "ruby",
+        name: "Ruby",
+        category: "language",
+        fileMarkers: ["Gemfile"],
+        dirMarkers: [],
+        ignoreDirs: ["vendor/bundle", ".bundle"],
+        keyFiles: ["Gemfile"],
+        explorePatterns: ["**/*.rb"],
+        hints: ["Application code in lib/ or app/"],
+    },
+    // ——— Frameworks ——————————————————————————————————————
+    {
+        id: "nestjs",
+        name: "NestJS",
+        category: "framework",
+        fileMarkers: ["nest-cli.json"],
+        dirMarkers: [],
+        packageDeps: ["@nestjs/core"],
+        ignoreDirs: [],
+        keyFiles: ["nest-cli.json", "src/main.ts", "src/app.module.ts"],
+        explorePatterns: [
+            "**/*.controller.ts",
+            "**/*.module.ts",
+            "**/*.service.ts",
+            "**/*.guard.ts",
+            "**/*.gateway.ts",
+        ],
+        hints: [
+            "Controllers: @Get/@Post/@Put/@Delete define HTTP endpoints",
+            "Modules: imports[] shows feature dependencies",
+        ],
+    },
+    {
+        id: "angular",
+        name: "Angular",
+        category: "framework",
+        fileMarkers: ["angular.json"],
+        dirMarkers: [],
+        packageDeps: ["@angular/core"],
+        ignoreDirs: [".angular"],
+        keyFiles: [
+            "angular.json",
+            "src/app/app.routes.ts",
+            "src/app/app.module.ts",
+            "src/app/app.config.ts",
+        ],
+        explorePatterns: [
+            "**/*.component.ts",
+            "**/*routing*",
+            "**/*.module.ts",
+        ],
+        hints: [
+            "Routes: app.routes.ts (standalone) or *-routing.module.ts",
+            "Components: @Component decorator, templates inline or .html",
+        ],
+    },
+    {
+        id: "react",
+        name: "React",
+        category: "framework",
+        fileMarkers: [],
+        dirMarkers: [],
+        packageDeps: ["react"],
+        ignoreDirs: [],
+        keyFiles: ["src/App.tsx", "src/App.jsx", "src/index.tsx"],
+        explorePatterns: ["**/*.tsx", "**/*.jsx"],
+        hints: ["Components in src/, routing often in App.tsx or routes/"],
+    },
+    {
+        id: "nextjs",
+        name: "Next.js",
+        category: "framework",
+        fileMarkers: ["next.config.js", "next.config.mjs", "next.config.ts"],
+        dirMarkers: [],
+        packageDeps: ["next"],
+        ignoreDirs: [".next"],
+        keyFiles: ["next.config.js", "next.config.mjs", "next.config.ts"],
+        explorePatterns: ["app/**/page.tsx", "app/**/route.ts", "pages/**/*.tsx"],
+        hints: [
+            "App Router: app/ dir, page.tsx=pages, route.ts=API",
+            "Pages Router: pages/ dir, file-based routing",
+        ],
+    },
+    {
+        id: "vue",
+        name: "Vue.js",
+        category: "framework",
+        fileMarkers: ["vue.config.js"],
+        dirMarkers: [],
+        packageDeps: ["vue"],
+        ignoreDirs: [],
+        keyFiles: ["src/App.vue", "src/main.ts", "src/router/index.ts"],
+        explorePatterns: ["**/*.vue"],
+        hints: ["Single-file components (.vue), routing in src/router/"],
+    },
+    {
+        id: "nuxt",
+        name: "Nuxt",
+        category: "framework",
+        fileMarkers: ["nuxt.config.ts", "nuxt.config.js"],
+        dirMarkers: [],
+        packageDeps: ["nuxt"],
+        ignoreDirs: [".nuxt", ".output"],
+        keyFiles: ["nuxt.config.ts"],
+        explorePatterns: ["pages/**/*.vue", "server/api/**/*.ts"],
+        hints: ["File-based routing in pages/, server API in server/api/"],
+    },
+    {
+        id: "express",
+        name: "Express.js",
+        category: "framework",
+        fileMarkers: [],
+        dirMarkers: [],
+        packageDeps: ["express"],
+        ignoreDirs: [],
+        keyFiles: ["src/app.ts", "src/app.js", "src/server.ts"],
+        explorePatterns: ["**/*route*", "**/*controller*", "**/*middleware*"],
+        hints: ["Routes in routes/ or src/routes/"],
+    },
+    {
+        id: "fastify",
+        name: "Fastify",
+        category: "framework",
+        fileMarkers: [],
+        dirMarkers: [],
+        packageDeps: ["fastify"],
+        ignoreDirs: [],
+        keyFiles: ["src/app.ts", "src/server.ts"],
+        explorePatterns: ["**/*route*", "**/*plugin*"],
+        hints: ["Routes as plugins, registered via app.register()"],
+    },
+    {
+        id: "hono",
+        name: "Hono",
+        category: "framework",
+        fileMarkers: [],
+        dirMarkers: [],
+        packageDeps: ["hono"],
+        ignoreDirs: [],
+        keyFiles: ["src/index.ts"],
+        explorePatterns: ["**/*route*"],
+        hints: ["Lightweight HTTP framework, routes via app.get/post"],
+    },
+    {
+        id: "django",
+        name: "Django",
+        category: "framework",
+        fileMarkers: ["manage.py"],
+        dirMarkers: [],
+        ignoreDirs: ["staticfiles", "media"],
+        keyFiles: ["manage.py"],
+        explorePatterns: [
+            "**/views.py",
+            "**/models.py",
+            "**/urls.py",
+            "**/serializers.py",
+        ],
+        hints: [
+            "Apps in INSTALLED_APPS (settings.py)",
+            "URLs in urls.py, views define endpoints, models define DB",
+        ],
+    },
+    {
+        id: "fastapi",
+        name: "FastAPI",
+        category: "framework",
+        fileMarkers: [],
+        dirMarkers: [],
+        packageDeps: ["fastapi"],
+        ignoreDirs: [],
+        keyFiles: ["main.py", "app/main.py"],
+        explorePatterns: ["**/*router*", "**/*route*"],
+        hints: ["Routes with @app.get/@app.post, routers in separate files"],
+    },
+    {
+        id: "flask",
+        name: "Flask",
+        category: "framework",
+        fileMarkers: [],
+        dirMarkers: [],
+        packageDeps: ["flask"],
+        ignoreDirs: [],
+        keyFiles: ["app.py", "wsgi.py"],
+        explorePatterns: ["**/*route*", "**/*view*"],
+        hints: ["Routes via @app.route or blueprints"],
+    },
+    {
+        id: "laravel",
+        name: "Laravel",
+        category: "framework",
+        fileMarkers: ["artisan"],
+        dirMarkers: ["app/Http/Controllers"],
+        ignoreDirs: ["vendor", "storage/framework", "bootstrap/cache"],
+        keyFiles: [
+            "routes/web.php",
+            "routes/api.php",
+            "app/Http/Kernel.php",
+            ".env.example",
+        ],
+        explorePatterns: [
+            "app/Http/Controllers/**/*.php",
+            "app/Models/**/*.php",
+            "database/migrations/*.php",
+        ],
+        hints: [
+            "Routes: routes/web.php + routes/api.php",
+            "Controllers: app/Http/Controllers, Models: app/Models",
+        ],
+    },
+    {
+        id: "rails",
+        name: "Ruby on Rails",
+        category: "framework",
+        fileMarkers: ["config/routes.rb"],
+        dirMarkers: ["app/controllers", "app/models"],
+        ignoreDirs: ["vendor/bundle", "tmp", "log"],
+        keyFiles: ["config/routes.rb", "Gemfile", "config/database.yml"],
+        explorePatterns: [
+            "app/controllers/**/*.rb",
+            "app/models/**/*.rb",
+            "db/migrate/*.rb",
+        ],
+        hints: ["Routes in config/routes.rb, MVC in app/"],
+    },
+    {
+        id: "spring",
+        name: "Spring Boot",
+        category: "framework",
+        fileMarkers: [
+            "src/main/resources/application.properties",
+            "src/main/resources/application.yml",
+        ],
+        dirMarkers: [],
+        ignoreDirs: ["target", "build"],
+        keyFiles: [
+            "src/main/resources/application.yml",
+            "src/main/resources/application.properties",
+        ],
+        explorePatterns: [
+            "**/*Controller.java",
+            "**/*Service.java",
+            "**/*Repository.java",
+        ],
+        hints: ["@RestController, @Service, @Entity, JPA for data access"],
+    },
+    // ——— Database / ORM ——————————————————————————————————
+    {
+        id: "prisma",
+        name: "Prisma",
+        category: "database",
+        fileMarkers: ["prisma/schema.prisma"],
+        dirMarkers: [],
+        packageDeps: ["prisma", "@prisma/client"],
+        ignoreDirs: [],
+        keyFiles: ["prisma/schema.prisma"],
+        explorePatterns: ["prisma/migrations/**/migration.sql"],
+        hints: ["All models in schema.prisma, migrations in prisma/migrations/"],
+    },
+    {
+        id: "typeorm",
+        name: "TypeORM",
+        category: "database",
+        fileMarkers: ["ormconfig.json", "ormconfig.ts"],
+        dirMarkers: [],
+        packageDeps: ["typeorm"],
+        ignoreDirs: [],
+        keyFiles: ["ormconfig.json", "ormconfig.ts"],
+        explorePatterns: ["**/*.entity.ts", "**/migration/*.ts"],
+        hints: ["Entities with @Entity, migrations in migrations/"],
+    },
+    {
+        id: "drizzle",
+        name: "Drizzle ORM",
+        category: "database",
+        fileMarkers: ["drizzle.config.ts"],
+        dirMarkers: [],
+        packageDeps: ["drizzle-orm"],
+        ignoreDirs: [],
+        keyFiles: ["drizzle.config.ts"],
+        explorePatterns: ["**/*schema*", "**/drizzle/**"],
+        hints: ["Schema in schema files, migrations in drizzle/"],
+    },
+    {
+        id: "sequelize",
+        name: "Sequelize",
+        category: "database",
+        fileMarkers: [".sequelizerc"],
+        dirMarkers: [],
+        packageDeps: ["sequelize"],
+        ignoreDirs: [],
+        keyFiles: [".sequelizerc"],
+        explorePatterns: ["**/models/**", "**/migrations/**"],
+        hints: ["Models in models/, migrations in migrations/"],
+    },
+    {
+        id: "mongoose",
+        name: "Mongoose",
+        category: "database",
+        fileMarkers: [],
+        dirMarkers: [],
+        packageDeps: ["mongoose"],
+        ignoreDirs: [],
+        keyFiles: [],
+        explorePatterns: ["**/*schema*", "**/*model*"],
+        hints: ["MongoDB schemas, usually in schemas/ or models/"],
+    },
+    // ——— Infrastructure ——————————————————————————————————
+    {
+        id: "docker",
+        name: "Docker",
+        category: "infra",
+        fileMarkers: [
+            "Dockerfile",
+            "docker-compose.yml",
+            "docker-compose.yaml",
+            "compose.yml",
+            "compose.yaml",
+        ],
+        dirMarkers: [],
+        ignoreDirs: [],
+        keyFiles: [
+            "Dockerfile",
+            "docker-compose.yml",
+            "docker-compose.yaml",
+            "compose.yml",
+            "compose.yaml",
+            ".dockerignore",
+        ],
+        explorePatterns: ["**/Dockerfile*"],
+        hints: ["docker-compose defines services, ports, volumes, networks"],
+    },
+    {
+        id: "kubernetes",
+        name: "Kubernetes",
+        category: "infra",
+        fileMarkers: ["kustomization.yaml", "skaffold.yaml"],
+        dirMarkers: ["k8s", "kubernetes", "manifests"],
+        ignoreDirs: [],
+        keyFiles: ["kustomization.yaml"],
+        explorePatterns: ["k8s/**/*.yaml", "kubernetes/**/*.yaml"],
+        hints: ["Manifests: deployments, services, configmaps, secrets"],
+    },
+    {
+        id: "terraform",
+        name: "Terraform",
+        category: "infra",
+        fileMarkers: ["main.tf"],
+        dirMarkers: [],
+        ignoreDirs: [".terraform"],
+        keyFiles: ["main.tf", "variables.tf", "outputs.tf"],
+        explorePatterns: ["**/*.tf"],
+        hints: ["main.tf=resources, variables.tf=inputs, outputs.tf=exports"],
+    },
+    // ——— Testing —————————————————————————————————————————
+    {
+        id: "jest",
+        name: "Jest",
+        category: "testing",
+        fileMarkers: ["jest.config.ts", "jest.config.js", "jest.config.mjs"],
+        dirMarkers: [],
+        packageDeps: ["jest"],
+        ignoreDirs: [],
+        keyFiles: ["jest.config.ts", "jest.config.js"],
+        explorePatterns: ["**/*.test.ts", "**/*.spec.ts"],
+        hints: ["Tests in *.test.ts / *.spec.ts"],
+    },
+    {
+        id: "vitest",
+        name: "Vitest",
+        category: "testing",
+        fileMarkers: ["vitest.config.ts", "vitest.config.js"],
+        dirMarkers: [],
+        packageDeps: ["vitest"],
+        ignoreDirs: [],
+        keyFiles: ["vitest.config.ts"],
+        explorePatterns: ["**/*.test.ts", "**/*.spec.ts"],
+        hints: ["Tests in *.test.ts / *.spec.ts"],
+    },
+    {
+        id: "pytest",
+        name: "pytest",
+        category: "testing",
+        fileMarkers: ["pytest.ini", "conftest.py"],
+        dirMarkers: [],
+        ignoreDirs: [".pytest_cache"],
+        keyFiles: ["pytest.ini", "conftest.py"],
+        explorePatterns: ["**/test_*.py", "**/*_test.py"],
+        hints: ["Tests in test_*.py, fixtures in conftest.py"],
+    },
+    {
+        id: "playwright",
+        name: "Playwright",
+        category: "testing",
+        fileMarkers: ["playwright.config.ts", "playwright.config.js"],
+        dirMarkers: [],
+        packageDeps: ["@playwright/test"],
+        ignoreDirs: ["test-results", "playwright-report"],
+        keyFiles: ["playwright.config.ts"],
+        explorePatterns: ["**/*.spec.ts"],
+        hints: ["E2E tests, config in playwright.config.ts"],
+    },
+    // ——— Build tools —————————————————————————————————————
+    {
+        id: "webpack",
+        name: "Webpack",
+        category: "build",
+        fileMarkers: ["webpack.config.js", "webpack.config.ts"],
+        dirMarkers: [],
+        packageDeps: ["webpack"],
+        ignoreDirs: [],
+        keyFiles: ["webpack.config.js", "webpack.config.ts"],
+        explorePatterns: [],
+        hints: [],
+    },
+    {
+        id: "vite",
+        name: "Vite",
+        category: "build",
+        fileMarkers: ["vite.config.ts", "vite.config.js"],
+        dirMarkers: [],
+        packageDeps: ["vite"],
+        ignoreDirs: [],
+        keyFiles: ["vite.config.ts", "vite.config.js"],
+        explorePatterns: [],
+        hints: [],
+    },
+    {
+        id: "esbuild",
+        name: "esbuild",
+        category: "build",
+        fileMarkers: [],
+        dirMarkers: [],
+        packageDeps: ["esbuild"],
+        ignoreDirs: [],
+        keyFiles: [],
+        explorePatterns: [],
+        hints: [],
+    },
+];
+/* ═══════════════════════════════════════════════════════════════
+   MONOREPO RULES
+   ═══════════════════════════════════════════════════════════════ */
+exports.MONOREPO_RULES = [
+    {
+        id: "nx",
+        name: "NX",
+        fileMarkers: ["nx.json"],
+        workspaceDirs: ["apps", "libs", "packages"],
+        ignoreDirs: [".nx", "node_modules"],
+        hints: [
+            "project.json in each sub-project defines targets (build/serve/test)",
+            "nx graph shows dependency graph",
+        ],
+    },
+    {
+        id: "turborepo",
+        name: "Turborepo",
+        fileMarkers: ["turbo.json"],
+        workspaceDirs: ["apps", "packages"],
+        ignoreDirs: [".turbo", "node_modules"],
+        hints: ["Pipeline in turbo.json, packages in packages/ and apps/"],
+    },
+    {
+        id: "lerna",
+        name: "Lerna",
+        fileMarkers: ["lerna.json"],
+        workspaceDirs: ["packages"],
+        ignoreDirs: ["node_modules"],
+        hints: ["Packages in packages/, version mgmt via lerna.json"],
+    },
+    {
+        id: "pnpm-workspaces",
+        name: "pnpm workspaces",
+        fileMarkers: ["pnpm-workspace.yaml"],
+        workspaceDirs: ["packages", "apps", "libs"],
+        ignoreDirs: ["node_modules"],
+        hints: ["Workspace members defined in pnpm-workspace.yaml"],
+    },
+    {
+        id: "go-workspaces",
+        name: "Go workspaces",
+        fileMarkers: ["go.work"],
+        workspaceDirs: ["cmd", "internal", "pkg"],
+        ignoreDirs: ["vendor"],
+        hints: ["Workspace modules in go.work"],
+    },
+];
+/** Dirs always excluded regardless of detected tech. */
+const ALWAYS_IGNORE = new Set([".git", "coverage", ".idea", ".vscode"]);
+/* ═══════════════════════════════════════════════════════════════
+   TOOL
+   ═══════════════════════════════════════════════════════════════ */
+class ProjectScannerTool extends tool_base_class_1.ToolBase {
+    rootDir;
+    name = "projectScanner";
+    readonly = true;
+    description = "Fast structural scan of a project or monorepo. " +
+        "Detects languages, frameworks, databases, infrastructure, testing, build tools, " +
+        "and monorepo layout including sub-projects. " +
+        "Returns compact guidance: dirs to ignore, key files to read, " +
+        "patterns for find_files, and technology-specific hints. " +
+        "Use FIRST before any deep file exploration.";
+    constructor(rootDir) {
+        super(zod_1.z.object({
+            path: zod_1.z
+                .string()
+                .optional()
+                .describe("Path to scan, relative to project root. Defaults to root."),
+        }));
+        this.rootDir = rootDir;
+    }
+    async run(input, _ctx) {
+        const relPath = input.path || ".";
+        const scanDir = (0, path_utils_1.resolveSafePath)(this.rootDir, relPath);
+        if (!scanDir) {
+            return { success: false, error: "Path traversal not allowed." };
+        }
+        if (!fs.existsSync(scanDir) || !fs.statSync(scanDir).isDirectory()) {
+            return { success: false, error: `Not a directory: ${relPath}` };
+        }
+        const result = this.scan(scanDir);
+        return { success: true, output: this.format(result, scanDir) };
+    }
+    /* ——— Scanning ——————————————————————————————————————— */
+    scan(dir) {
+        const rootDeps = this.readDeps(dir);
+        const rootTechs = this.detectTechs(dir, rootDeps);
+        // Monorepo detection
+        let monorepo = null;
+        for (const rule of exports.MONOREPO_RULES) {
+            if (rule.fileMarkers.some((f) => fs.existsSync(path.join(dir, f)))) {
+                monorepo = rule;
+                break;
+            }
+        }
+        // Yarn/npm workspaces (package.json "workspaces" field)
+        const yarnWorkspaceDirs = [];
+        const pkg = this.readPackageJson(dir);
+        if (pkg?.workspaces) {
+            const patterns = Array.isArray(pkg.workspaces)
+                ? pkg.workspaces
+                : pkg.workspaces.packages || [];
+            for (const pattern of patterns) {
+                const prefix = pattern.split(/[*{]/)[0].replace(/\/$/, "");
+                if (prefix && !yarnWorkspaceDirs.includes(prefix)) {
+                    yarnWorkspaceDirs.push(prefix);
+                }
+            }
+        }
+        // Collect workspace dirs to scan
+        const wsDirs = new Set();
+        if (monorepo) {
+            for (const d of monorepo.workspaceDirs)
+                wsDirs.add(d);
+        }
+        for (const d of yarnWorkspaceDirs)
+            wsDirs.add(d);
+        // Detect sub-projects
+        const subProjects = [];
+        for (const wsDir of wsDirs) {
+            this.scanWorkspaceDir(dir, wsDir, rootDeps, subProjects);
+        }
+        // No monorepo tool detected — check for plain multi-project layout
+        if (!monorepo && yarnWorkspaceDirs.length === 0 && subProjects.length === 0) {
+            this.detectPlainSubProjects(dir, subProjects);
+        }
+        return { monorepo, yarnWorkspaceDirs, rootTechs, subProjects };
+    }
+    scanWorkspaceDir(rootDir, wsDir, rootDeps, out) {
+        const full = path.join(rootDir, wsDir);
+        if (!fs.existsSync(full) || !fs.statSync(full).isDirectory())
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(full, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith("."))
+                continue;
+            const projDir = path.join(full, entry.name);
+            const projDeps = this.readDeps(projDir, rootDeps);
+            const techs = this.detectTechs(projDir, projDeps);
+            if (techs.length > 0) {
+                out.push({ relPath: path.relative(rootDir, projDir), techs });
+            }
+        }
+    }
+    /**
+     * Fallback: scan top-level dirs that have their own config file
+     * (looks like independent projects grouped in a directory).
+     */
+    detectPlainSubProjects(dir, out) {
+        const PROJECT_CONFIGS = [
+            "package.json",
+            "Cargo.toml",
+            "go.mod",
+            "pyproject.toml",
+            "composer.json",
+            "Gemfile",
+            "pom.xml",
+            "build.gradle",
+        ];
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith("."))
+                continue;
+            if (ALWAYS_IGNORE.has(entry.name))
+                continue;
+            const subDir = path.join(dir, entry.name);
+            const hasOwnConfig = PROJECT_CONFIGS.some((f) => fs.existsSync(path.join(subDir, f)));
+            if (!hasOwnConfig)
+                continue;
+            const subDeps = this.readDeps(subDir);
+            const techs = this.detectTechs(subDir, subDeps);
+            if (techs.length > 0) {
+                out.push({ relPath: entry.name, techs });
+            }
+        }
+    }
+    /* ——— Tech detection ———————————————————————————————— */
+    detectTechs(dir, deps) {
+        const detected = [];
+        for (const rule of exports.TECH_RULES) {
+            const evidence = [];
+            for (const f of rule.fileMarkers) {
+                if (fs.existsSync(path.join(dir, f)))
+                    evidence.push(f);
+            }
+            for (const d of rule.dirMarkers) {
+                const full = path.join(dir, d);
+                try {
+                    if (fs.existsSync(full) && fs.statSync(full).isDirectory()) {
+                        evidence.push(d + "/");
+                    }
+                }
+                catch {
+                    /* permission error etc. */
+                }
+            }
+            if (rule.packageDeps) {
+                for (const dep of rule.packageDeps) {
+                    if (deps.has(dep))
+                        evidence.push(`dep:${dep}`);
+                }
+            }
+            if (evidence.length > 0) {
+                detected.push({ rule, evidence });
+            }
+        }
+        // Special: .NET detection via extensions (no fixed filenames)
+        this.detectByExtension(dir, detected);
+        return detected;
+    }
+    detectByExtension(dir, detected) {
+        // Skip if .NET already detected
+        if (detected.some((d) => d.rule.id === "dotnet"))
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        const hasSln = entries.some((e) => e.endsWith(".sln"));
+        const hasCsproj = entries.some((e) => e.endsWith(".csproj"));
+        if (hasSln || hasCsproj) {
+            const rule = exports.TECH_RULES.find((r) => r.id === "dotnet");
+            const evidence = hasSln ? ["*.sln"] : ["*.csproj"];
+            detected.push({ rule, evidence });
+        }
+    }
+    /* ——— Dependency reading ————————————————————————————— */
+    readPackageJson(dir) {
+        const p = path.join(dir, "package.json");
+        try {
+            if (fs.existsSync(p)) {
+                return JSON.parse(fs.readFileSync(p, "utf-8"));
+            }
+        }
+        catch {
+            /* malformed JSON */
+        }
+        return null;
+    }
+    readDeps(dir, fallback) {
+        const deps = new Set(fallback ?? []);
+        // package.json
+        const pkg = this.readPackageJson(dir);
+        if (pkg) {
+            for (const section of [
+                "dependencies",
+                "devDependencies",
+                "peerDependencies",
+            ]) {
+                if (pkg[section]) {
+                    for (const name of Object.keys(pkg[section]))
+                        deps.add(name);
+                }
+            }
+        }
+        // Python: read requirements.txt package names
+        const reqTxt = path.join(dir, "requirements.txt");
+        try {
+            if (fs.existsSync(reqTxt)) {
+                const lines = fs.readFileSync(reqTxt, "utf-8").split("\n");
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("-"))
+                        continue;
+                    const name = trimmed.split(/[>=<!~\[;]/)[0].trim().toLowerCase();
+                    if (name)
+                        deps.add(name);
+                }
+            }
+        }
+        catch {
+            /* read error */
+        }
+        return deps;
+    }
+    /* ——— Output formatting ————————————————————————————— */
+    format(result, scanDir) {
+        const lines = [];
+        const hasSubProjects = result.subProjects.length > 0;
+        // Structure
+        if (result.monorepo) {
+            lines.push(`Structure: monorepo (${result.monorepo.name})`);
+        }
+        else if (result.yarnWorkspaceDirs.length > 0) {
+            lines.push(`Structure: monorepo (npm/yarn workspaces)`);
+        }
+        else if (hasSubProjects) {
+            lines.push(`Structure: multi-project`);
+        }
+        else {
+            lines.push(`Structure: single project`);
+        }
+        // Aggregate ignore dirs
+        const ignoreSet = new Set(ALWAYS_IGNORE);
+        const allTechs = [...result.rootTechs];
+        for (const sp of result.subProjects) {
+            for (const t of sp.techs)
+                allTechs.push(t);
+        }
+        if (result.monorepo) {
+            for (const d of result.monorepo.ignoreDirs)
+                ignoreSet.add(d);
+        }
+        for (const t of allTechs) {
+            for (const d of t.rule.ignoreDirs)
+                ignoreSet.add(d);
+        }
+        lines.push(`Ignore: ${[...ignoreSet].sort().join(", ")}`);
+        lines.push("");
+        // Root technologies
+        if (result.rootTechs.length > 0) {
+            const label = hasSubProjects ? "Root" : "Detected";
+            lines.push(this.formatSection(label, result.rootTechs, scanDir));
+        }
+        // Sub-projects
+        for (const sp of result.subProjects) {
+            const spDir = path.join(scanDir, sp.relPath);
+            lines.push(this.formatSection(sp.relPath, sp.techs, spDir));
+        }
+        // Monorepo-specific hints
+        if (result.monorepo && result.monorepo.hints.length > 0) {
+            lines.push("Monorepo:");
+            for (const h of result.monorepo.hints)
+                lines.push(`  ${h}`);
+        }
+        return lines.join("\n").trimEnd();
+    }
+    formatSection(label, techs, dir) {
+        const lines = [];
+        // Tech names
+        const names = techs.map((t) => t.rule.name).join(", ");
+        lines.push(`${label}: ${names}`);
+        // Key files (only those that actually exist on disk)
+        const keyFiles = [];
+        for (const t of techs) {
+            for (const f of t.rule.keyFiles) {
+                if (!keyFiles.includes(f) && fs.existsSync(path.join(dir, f))) {
+                    keyFiles.push(f);
+                }
+            }
+        }
+        if (keyFiles.length > 0) {
+            lines.push(`  read: ${keyFiles.join(", ")}`);
+        }
+        // Explore patterns (deduplicated)
+        const patterns = [];
+        for (const t of techs) {
+            for (const p of t.rule.explorePatterns) {
+                if (!patterns.includes(p))
+                    patterns.push(p);
+            }
+        }
+        if (patterns.length > 0) {
+            lines.push(`  find: ${patterns.join(", ")}`);
+        }
+        // Hints — only from framework, database, and infra categories (skip generic language/build hints)
+        const hints = [];
+        for (const t of techs) {
+            if (["framework", "database", "infra"].includes(t.rule.category)) {
+                for (const h of t.rule.hints)
+                    hints.push(h);
+            }
+        }
+        if (hints.length > 0) {
+            lines.push(`  hints: ${hints.join(" · ")}`);
+        }
+        lines.push("");
+        return lines.join("\n");
+    }
+}
+exports.ProjectScannerTool = ProjectScannerTool;
+//# sourceMappingURL=project-scanner.tool.js.map