archbyte 0.1.0

package/dist/agents/static/component-detector.js

@@ -0,0 +1,404 @@
+// Static Analysis — Component Detector
+// Detects project components via workspaces, conventional directories, build configs, or single-app fallback
+import { slugify, assignLayer } from "./utils.js";
+// Map well-known deps to architecturally significant tech names
+const TECH_MAP = {
+    react: "React", "react-dom": "React", "next": "Next.js", "vue": "Vue", "nuxt": "Nuxt",
+    svelte: "Svelte", angular: "Angular", "@angular/core": "Angular",
+    express: "Express", fastify: "Fastify", "@nestjs/core": "NestJS", hono: "Hono", koa: "Koa",
+    prisma: "Prisma", "@prisma/client": "Prisma", typeorm: "TypeORM", drizzle: "Drizzle",
+    sequelize: "Sequelize", mongoose: "Mongoose", pg: "PostgreSQL", mysql2: "MySQL",
+    redis: "Redis", ioredis: "Redis",
+    graphql: "GraphQL", "@apollo/server": "Apollo GraphQL",
+    "socket.io": "Socket.IO", ws: "WebSocket",
+    tailwindcss: "Tailwind CSS", "@xyflow/react": "React Flow",
+    commander: "Commander.js", yargs: "Yargs",
+    vite: "Vite", webpack: "Webpack", esbuild: "esbuild",
+    typescript: "TypeScript",
+    kafkajs: "Kafka", amqplib: "RabbitMQ", bullmq: "BullMQ", bull: "Bull",
+    stripe: "Stripe", "@stripe/stripe-js": "Stripe",
+    playwright: "Playwright", "@playwright/test": "Playwright",
+    jest: "Jest", vitest: "Vitest", mocha: "Mocha",
+    flutter: "Flutter",
+};
+// Conventional directory → type mapping (hint-based, not exclusive)
+const DIR_TYPE_HINTS = {
+    ui: { type: "frontend", label: "UI" },
+    web: { type: "frontend", label: "Web App" },
+    frontend: { type: "frontend", label: "Frontend" },
+    client: { type: "frontend", label: "Client" },
+    app: { type: "frontend", label: "App" },
+    server: { type: "api", label: "Server" },
+    api: { type: "api", label: "API" },
+    backend: { type: "api", label: "Backend" },
+    gateway: { type: "api", label: "Gateway" },
+    cli: { type: "service", label: "CLI" },
+    agents: { type: "library", label: "Agents" },
+    lib: { type: "library", label: "Library" },
+    packages: { type: "library", label: "Packages" },
+    shared: { type: "library", label: "Shared" },
+    common: { type: "library", label: "Common" },
+    cloud: { type: "service", label: "Cloud" },
+    infra: { type: "service", label: "Infrastructure" },
+    deploy: { type: "service", label: "Deployment" },
+    deployment: { type: "service", label: "Deployment" },
+    workers: { type: "worker", label: "Workers" },
+    jobs: { type: "worker", label: "Jobs" },
+    scripts: { type: "service", label: "Scripts" },
+    e2e: { type: "service", label: "E2E Tests" },
+    tests: { type: "service", label: "Tests" },
+    tools: { type: "service", label: "Tools" },
+    homepage: { type: "frontend", label: "Homepage" },
+    docs: { type: "service", label: "Docs" },
+};
+// Build config files that indicate a directory is a standalone component
+const BUILD_CONFIG_FILES = [
+    "package.json",
+    "Cargo.toml",
+    "go.mod",
+    "pyproject.toml",
+    "requirements.txt",
+    "setup.py",
+    "pubspec.yaml",
+    "build.gradle",
+    "pom.xml",
+    "Gemfile",
+    "Makefile",
+    "Dockerfile",
+    "wrangler.toml",
+    "tsconfig.json",
+];
+// Skip these dirs — not components
+const SKIP_DIRS = new Set([
+    "node_modules", "dist", "build", "target", ".git",
+    "coverage", "tmp", ".cache", "venv", "__pycache__",
+]);
+export async function detectComponents(tk, structure) {
+    // Strategy 1: Monorepo workspaces
+    if (structure.isMonorepo) {
+        const components = await detectFromWorkspaces(tk, structure);
+        if (components.length > 0)
+            return { components };
+    }
+    // Strategy 2: Scan ALL top-level directories for build configs + conventional names
+    const components = await detectAllComponents(tk, structure);
+    if (components.length > 0)
+        return { components };
+    // Strategy 3: Single app fallback
+    return { components: [buildSingleAppComponent(structure)] };
+}
+async function detectFromWorkspaces(tk, structure) {
+    // Collect workspace patterns from package.json OR pnpm-workspace.yaml
+    const workspaces = await resolveWorkspacePatterns(tk);
+    if (workspaces.length === 0)
+        return [];
+    const components = [];
+    for (const wsPattern of workspaces) {
+        // Skip root workspace (`.`)
+        if (wsPattern === ".")
+            continue;
+        // For glob patterns like "extensions/*", find matching package.json files
+        const matches = await tk.globFiles(`${wsPattern}/package.json`);
+        for (const match of matches) {
+            const wsDir = match.replace(/\/package\.json$/, "");
+            const wsPkg = await tk.readJSON(match);
+            if (!wsPkg)
+                continue;
+            const name = wsPkg.name ?? wsDir.split("/").pop() ?? wsDir;
+            const type = detectTypeFromDeps(wsPkg);
+            const techs = extractTechStack(wsPkg);
+            components.push({
+                id: slugify(name) ?? wsDir,
+                name,
+                type,
+                layer: assignLayer(type),
+                path: wsDir,
+                description: wsPkg.description ?? "",
+                technologies: techs,
+            });
+        }
+    }
+    // Also detect non-workspace components (Cargo.toml, Python, native apps, etc.)
+    const wsPaths = new Set(components.map((c) => c.path));
+    const allComponents = await detectAllComponents(tk, structure);
+    for (const c of allComponents) {
+        if (!wsPaths.has(c.path)) {
+            components.push(c);
+        }
+    }
+    return components;
+}
+/**
+ * Resolve workspace patterns from package.json workspaces OR pnpm-workspace.yaml.
+ * Deterministic — just reads config files.
+ */
+async function resolveWorkspacePatterns(tk) {
+    // 1. Try package.json workspaces
+    const pkg = await tk.readJSON("package.json");
+    if (pkg?.workspaces) {
+        return Array.isArray(pkg.workspaces)
+            ? pkg.workspaces
+            : (pkg.workspaces.packages ?? []);
+    }
+    // 2. Try pnpm-workspace.yaml
+    const pnpmWs = await tk.readYAML("pnpm-workspace.yaml");
+    if (pnpmWs?.packages && Array.isArray(pnpmWs.packages)) {
+        return pnpmWs.packages;
+    }
+    // 3. Try lerna.json
+    const lerna = await tk.readJSON("lerna.json");
+    if (lerna?.packages && Array.isArray(lerna.packages)) {
+        return lerna.packages;
+    }
+    return [];
+}
+/**
+ * Scan every top-level directory. If it has a build config, README, Dockerfile,
+ * or code files, treat it as a component. Use dir name hints + config file analysis
+ * to determine type.
+ */
+async function detectAllComponents(tk, structure) {
+    const components = [];
+    const dirs = Object.keys(structure.directories);
+    for (const dir of dirs) {
+        if (SKIP_DIRS.has(dir) || dir.startsWith("."))
+            continue;
+        const entries = await tk.listDir(dir);
+        if (entries.length === 0)
+            continue;
+        const fileNames = entries.map((e) => e.name);
+        // Check for build config files
+        const hasBuildConfig = BUILD_CONFIG_FILES.some((f) => fileNames.includes(f));
+        const hasCode = entries.some((e) => e.type === "file" &&
+            /\.(ts|js|tsx|jsx|py|go|rs|java|rb|dart|kt|swift|c|cpp|cs)$/.test(e.name));
+        const hasSrcDir = entries.some((e) => e.type === "directory" && (e.name === "src" || e.name === "lib" || e.name === "app"));
+        const hasReadme = fileNames.includes("README.md") || fileNames.includes("readme.md");
+        // Must have at least some signal that this is a real component
+        if (!hasBuildConfig && !hasCode && !hasSrcDir)
+            continue;
+        // Detect language + type + tech stack from config files
+        const detected = await detectFromBuildConfigs(tk, dir, fileNames);
+        const hint = DIR_TYPE_HINTS[dir.toLowerCase()];
+        const type = detected.type ?? hint?.type ?? "service";
+        const label = hint?.label ?? capitalize(dir);
+        const name = label;
+        // Read description from sub-README if available
+        let description = detected.description;
+        if (!description && hasReadme) {
+            const readme = await tk.readFileSafe(`${dir}/README.md`);
+            if (readme) {
+                description = extractFirstParagraph(readme);
+            }
+        }
+        components.push({
+            id: slugify(dir) ?? dir,
+            name,
+            type,
+            layer: assignLayer(type),
+            path: dir,
+            description: description ?? "",
+            technologies: detected.technologies,
+        });
+    }
+    return components;
+}
+async function detectFromBuildConfigs(tk, dir, fileNames) {
+    const info = {
+        type: null,
+        description: "",
+        technologies: [],
+        language: null,
+    };
+    // package.json — richest source of info
+    if (fileNames.includes("package.json")) {
+        const pkg = await tk.readJSON(`${dir}/package.json`);
+        if (pkg) {
+            info.description = pkg.description ?? "";
+            info.type = detectTypeFromDeps(pkg);
+            info.technologies = extractTechStack(pkg);
+            info.language = "TypeScript/JavaScript";
+        }
+    }
+    // Cargo.toml — Rust
+    if (fileNames.includes("Cargo.toml")) {
+        const cargo = await tk.readFileSafe(`${dir}/Cargo.toml`);
+        if (cargo) {
+            info.language = "Rust";
+            info.technologies.push("Rust");
+            // Detect type from Cargo deps
+            if (cargo.includes("actix") || cargo.includes("axum") || cargo.includes("rocket") || cargo.includes("warp")) {
+                info.type = info.type ?? "api";
+                if (cargo.includes("axum"))
+                    info.technologies.push("Axum");
+                if (cargo.includes("actix"))
+                    info.technologies.push("Actix");
+            }
+            if (cargo.includes("wasm") || cargo.includes("wasm-bindgen")) {
+                info.type = info.type ?? "frontend";
+                info.technologies.push("WebAssembly");
+            }
+            if (cargo.includes("clap") || cargo.includes("structopt")) {
+                info.type = info.type ?? "service";
+            }
+            // Extract description
+            const descMatch = cargo.match(/description\s*=\s*"([^"]+)"/);
+            if (descMatch && !info.description)
+                info.description = descMatch[1];
+        }
+    }
+    // wrangler.toml — Cloudflare Workers
+    if (fileNames.includes("wrangler.toml")) {
+        info.technologies.push("Cloudflare Workers");
+        info.type = info.type ?? "service";
+    }
+    // requirements.txt or pyproject.toml — Python
+    if (fileNames.includes("requirements.txt") || fileNames.includes("pyproject.toml")) {
+        info.language = "Python";
+        info.technologies.push("Python");
+        const reqs = await tk.readFileSafe(`${dir}/requirements.txt`);
+        if (reqs) {
+            if (reqs.includes("django")) {
+                info.type = info.type ?? "api";
+                info.technologies.push("Django");
+            }
+            if (reqs.includes("fastapi")) {
+                info.type = info.type ?? "api";
+                info.technologies.push("FastAPI");
+            }
+            if (reqs.includes("flask")) {
+                info.type = info.type ?? "api";
+                info.technologies.push("Flask");
+            }
+            if (reqs.includes("celery")) {
+                info.type = info.type ?? "worker";
+                info.technologies.push("Celery");
+            }
+            if (reqs.includes("streamlit")) {
+                info.type = info.type ?? "frontend";
+                info.technologies.push("Streamlit");
+            }
+        }
+    }
+    // pubspec.yaml — Dart/Flutter
+    if (fileNames.includes("pubspec.yaml")) {
+        const pubspec = await tk.readYAML(`${dir}/pubspec.yaml`);
+        info.language = "Dart";
+        info.technologies.push("Flutter");
+        info.type = info.type ?? "frontend";
+        if (pubspec?.description) {
+            info.description = info.description || pubspec.description;
+        }
+    }
+    // go.mod — Go
+    if (fileNames.includes("go.mod")) {
+        info.language = "Go";
+        info.technologies.push("Go");
+        const goMod = await tk.readFileSafe(`${dir}/go.mod`);
+        if (goMod) {
+            if (goMod.includes("gin-gonic")) {
+                info.type = info.type ?? "api";
+                info.technologies.push("Gin");
+            }
+            if (goMod.includes("labstack/echo")) {
+                info.type = info.type ?? "api";
+                info.technologies.push("Echo");
+            }
+        }
+    }
+    // Dockerfile — any language, suggests deployable service
+    if (fileNames.includes("Dockerfile")) {
+        info.technologies.push("Docker");
+    }
+    // docker-compose.yml — infrastructure component
+    if (fileNames.includes("docker-compose.yml") || fileNames.includes("docker-compose.yaml")) {
+        info.technologies.push("Docker Compose");
+    }
+    // K8s manifests
+    if (fileNames.some((f) => f.endsWith(".yaml") || f.endsWith(".yml"))) {
+        const entries = await tk.listDir(dir);
+        const yamlDirs = entries.filter((e) => e.type === "directory").map((e) => e.name);
+        if (yamlDirs.some((d) => ["base", "overlays", "local"].includes(d)) ||
+            fileNames.includes("kustomization.yaml")) {
+            info.type = info.type ?? "service";
+            info.technologies.push("Kubernetes");
+        }
+    }
+    // Playwright / test config
+    if (fileNames.includes("playwright.config.ts") || fileNames.includes("playwright.config.js")) {
+        info.type = info.type ?? "service";
+        info.technologies.push("Playwright");
+    }
+    // Keep top 5 techs
+    info.technologies = [...new Set(info.technologies)].slice(0, 5);
+    return info;
+}
+function buildSingleAppComponent(structure) {
+    return {
+        id: slugify(structure.projectName) ?? "app",
+        name: structure.projectName || "Application",
+        type: structure.framework
+            ? (["React", "Vue", "Svelte", "Angular", "Next.js", "Nuxt"].includes(structure.framework)
+                ? "frontend"
+                : "api")
+            : "service",
+        layer: "application",
+        path: ".",
+        description: "",
+        technologies: [structure.language, structure.framework].filter(Boolean),
+    };
+}
+function detectTypeFromDeps(pkg) {
+    const deps = Object.keys({
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+    });
+    // Frontend indicators
+    if (deps.some((d) => ["react", "react-dom", "vue", "svelte", "@angular/core", "next", "nuxt"].includes(d))) {
+        return "frontend";
+    }
+    // API indicators
+    if (deps.some((d) => ["express", "fastify", "@nestjs/core", "hono", "koa"].includes(d))) {
+        return "api";
+    }
+    // Worker indicators
+    if (deps.some((d) => ["bullmq", "bull", "bee-queue"].includes(d))) {
+        return "worker";
+    }
+    // Test indicators
+    if (deps.some((d) => ["@playwright/test", "playwright", "cypress"].includes(d))) {
+        return "service";
+    }
+    return "service";
+}
+function extractTechStack(pkg) {
+    const deps = Object.keys({
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+    });
+    const techs = [];
+    for (const dep of deps) {
+        if (TECH_MAP[dep] && !techs.includes(TECH_MAP[dep])) {
+            techs.push(TECH_MAP[dep]);
+        }
+    }
+    return techs.slice(0, 5);
+}
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function extractFirstParagraph(readme) {
+    const lines = readme.split("\n");
+    let capturing = false;
+    const descLines = [];
+    for (const line of lines) {
+        if (!capturing && /^#\s+/.test(line)) {
+            capturing = true;
+            continue;
+        }
+        if (capturing && /^##\s+/.test(line))
+            break;
+        if (capturing)
+            descLines.push(line);
+    }
+    return descLines.join("\n").trim().replace(/\n{3,}/g, "\n\n").slice(0, 300);
+}

package/dist/agents/static/connection-mapper.d.ts

@@ -0,0 +1,3 @@
+import type { ConnectionResult, StaticComponent, InfraResult, EventResult } from "./types.js";
+import type { StaticToolkit } from "./utils.js";
+export declare function mapConnections(tk: StaticToolkit, components: StaticComponent[], infra: InfraResult, events: EventResult): Promise<ConnectionResult>;

package/dist/agents/static/connection-mapper.js

@@ -0,0 +1,280 @@
+// Static Analysis — Connection Mapper
+// Maps connections between components via imports, Docker, K8s, env vars, known SDKs
+// Only deterministic matches — ambiguous mappings are left as gaps for the LLM
+import { slugify } from "./utils.js";
+export async function mapConnections(tk, components, infra, events) {
+    const connections = [];
+    const componentIds = new Set(components.map((c) => c.id));
+    // Run all detection methods in parallel
+    await Promise.all([
+        detectDockerDependencies(infra, components, connections),
+        detectK8sIngress(infra, components, connections),
+        detectImportConnections(tk, components, connections),
+        detectDatabaseConnections(tk, components, connections),
+        detectServerServesUI(tk, components, connections),
+        detectKnownSDKConnections(components, connections),
+    ]);
+    // Deduplicate and filter
+    const seen = new Set();
+    const filtered = connections.filter((c) => {
+        // Filter self-connections
+        if (c.from === c.to)
+            return false;
+        // Filter connections to/from unknown components
+        if (!componentIds.has(c.from) && !componentIds.has(c.to))
+            return false;
+        // Dedup
+        const key = `${c.from}::${c.to}::${c.type}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    return { connections: filtered, flows: [] };
+}
+async function detectDockerDependencies(infra, components, connections) {
+    if (!infra.docker.composeFile)
+        return;
+    // Build a map from docker service names to component IDs
+    // Only uses deterministic matching: build context path resolution + exact name match
+    const dockerToComponent = new Map();
+    const composeDir = infra.docker.composeFilePath ?? "";
+    for (const svc of infra.docker.services) {
+        let id = null;
+        // 1. Try build context resolved relative to compose file directory (deterministic)
+        if (svc.buildContext) {
+            const resolvedPath = resolveBuildContext(composeDir, svc.buildContext);
+            if (resolvedPath) {
+                id = findComponentByPath(resolvedPath, components);
+            }
+        }
+        // 2. Exact match on service name → component id/path/name
+        if (!id) {
+            id = findComponentExact(svc.name, components);
+        }
+        if (id)
+            dockerToComponent.set(svc.name, id);
+        // If no match found → gap collector will flag this as "unresolved_docker_service"
+    }
+    for (const svc of infra.docker.services) {
+        const fromId = dockerToComponent.get(svc.name);
+        if (!fromId)
+            continue;
+        // depends_on connections
+        for (const dep of svc.dependsOn ?? []) {
+            const toId = dockerToComponent.get(dep);
+            if (toId && fromId !== toId) {
+                const depSvc = infra.docker.services.find((s) => s.name === dep);
+                const type = inferDockerConnectionType(depSvc?.image);
+                connections.push({
+                    from: fromId,
+                    to: toId,
+                    type,
+                    description: `Docker depends_on: ${svc.name} → ${dep}`,
+                    confidence: 100,
+                    async: false,
+                });
+            }
+        }
+        // Environment variable connections (e.g. SERVICE_BASE_URL: http://other-service:8000)
+        if (svc.environment) {
+            for (const [, value] of Object.entries(svc.environment)) {
+                if (!value)
+                    continue;
+                const urlMatch = value.match(/https?:\/\/([a-z0-9_-]+):\d+/i);
+                if (urlMatch) {
+                    const targetName = urlMatch[1];
+                    const toId = dockerToComponent.get(targetName) ?? findComponentExact(targetName, components);
+                    if (toId && fromId !== toId) {
+                        connections.push({
+                            from: fromId,
+                            to: toId,
+                            type: "http",
+                            description: `Docker env: ${svc.name} → ${targetName} (${value})`,
+                            confidence: 100,
+                            async: false,
+                        });
+                    }
+                }
+            }
+        }
+    }
+}
+async function detectK8sIngress(infra, components, connections) {
+    const ingresses = infra.kubernetes.resources.filter((r) => r.kind === "Ingress");
+    const services = infra.kubernetes.resources.filter((r) => r.kind === "Service");
+    for (const ingress of ingresses) {
+        for (const svc of services) {
+            const toId = findComponentExact(svc.name, components);
+            if (toId) {
+                connections.push({
+                    from: ingress.name,
+                    to: toId,
+                    type: "http",
+                    description: `K8s ingress → ${svc.name}`,
+                    confidence: 100,
+                    async: false,
+                });
+            }
+        }
+    }
+}
+async function detectImportConnections(tk, components, connections) {
+    for (const source of components) {
+        if (source.path === ".")
+            continue;
+        const connectedTargets = new Set();
+        for (const target of components) {
+            if (target.id === source.id)
+                continue;
+            if (target.path === ".")
+                continue;
+            const results = await tk.grepFiles(`from .*\\.\\./${target.path}/`, source.path);
+            if (results.length > 0 && !connectedTargets.has(target.id)) {
+                connectedTargets.add(target.id);
+                connections.push({
+                    from: source.id,
+                    to: target.id,
+                    type: "import",
+                    description: `Import: ${source.name} → ${target.name}`,
+                    confidence: 90,
+                    async: false,
+                });
+            }
+        }
+    }
+}
+async function detectDatabaseConnections(tk, components, connections) {
+    const dbComp = components.find((c) => c.type === "database" || c.layer === "data");
+    for (const comp of components) {
+        if (comp.path === ".")
+            continue;
+        if (comp.id === dbComp?.id)
+            continue;
+        const dbResults = await tk.grepFiles("DATABASE_URL|DB_HOST|MONGO_URI|REDIS_URL", comp.path);
+        if (dbResults.length > 0 && dbComp) {
+            connections.push({
+                from: comp.id,
+                to: dbComp.id,
+                type: "database",
+                description: `Database connection from ${comp.name}`,
+                confidence: 95,
+                async: false,
+            });
+        }
+    }
+}
+async function detectServerServesUI(tk, components, connections) {
+    const serverComp = components.find((c) => c.type === "api");
+    const uiComp = components.find((c) => c.type === "frontend");
+    if (!serverComp || !uiComp)
+        return;
+    const staticResults = await tk.grepFiles("ui/dist|express\\.static|serveStatic|sendFile", serverComp.path);
+    if (staticResults.length > 0) {
+        connections.push({
+            from: serverComp.id,
+            to: uiComp.id,
+            type: "http",
+            description: `${serverComp.name} serves ${uiComp.name} static files`,
+            confidence: 85,
+            async: false,
+        });
+    }
+    const apiResults = await tk.grepFiles("fetch\\(|axios|useQuery|EventSource", uiComp.path);
+    if (apiResults.length > 0) {
+        connections.push({
+            from: uiComp.id,
+            to: serverComp.id,
+            type: "http",
+            description: `${uiComp.name} calls ${serverComp.name} API`,
+            confidence: 80,
+            async: false,
+        });
+    }
+}
+async function detectKnownSDKConnections(components, connections) {
+    const externalTechs = {
+        Stripe: "stripe-api",
+        Firebase: "firebase",
+        Supabase: "supabase",
+        Redis: "redis",
+        Kafka: "kafka",
+        RabbitMQ: "rabbitmq",
+        "Socket.IO": "websocket",
+        PostgreSQL: "database",
+        MySQL: "database",
+        MongoDB: "database",
+    };
+    for (const comp of components) {
+        for (const tech of comp.technologies) {
+            const externalId = externalTechs[tech];
+            if (externalId) {
+                const target = components.find((c) => c.id !== comp.id && (c.technologies.includes(tech) ||
+                    c.type === "database" && (externalId === "database")));
+                if (target) {
+                    connections.push({
+                        from: comp.id,
+                        to: target.id,
+                        type: externalId === "database" ? "database" : "http",
+                        description: `${comp.name} uses ${tech}`,
+                        confidence: 95,
+                        async: false,
+                    });
+                }
+            }
+        }
+    }
+}
+/**
+ * Exact match only: id, slug, path, or name must match exactly.
+ * No fuzzy matching, synonyms, or partial matches — those are for the LLM.
+ */
+function findComponentExact(name, components) {
+    const lower = name.toLowerCase();
+    const slug = slugify(name);
+    const match = components.find((c) => c.id === slug ||
+        c.id === lower ||
+        c.path.toLowerCase() === lower ||
+        c.name.toLowerCase() === lower);
+    return match?.id ?? null;
+}
+/**
+ * Resolve a docker build context path relative to the compose file directory.
+ * Pure path arithmetic — deterministic.
+ */
+function resolveBuildContext(composeDir, context) {
+    const ctx = context.replace(/\/$/, "");
+    if (ctx === "." || ctx === "./") {
+        return composeDir || null;
+    }
+    if (ctx.startsWith("../")) {
+        const remaining = ctx.replace(/^\.\.\//, "");
+        return remaining || null;
+    }
+    if (ctx.startsWith("./")) {
+        const remaining = ctx.replace(/^\.\//, "");
+        return composeDir ? `${composeDir}/${remaining}` : remaining;
+    }
+    return composeDir ? `${composeDir}/${ctx}` : ctx;
+}
+/**
+ * Find a component by its directory path (exact match).
+ */
+function findComponentByPath(dirPath, components) {
+    const lower = dirPath.toLowerCase();
+    const comp = components.find((c) => c.path.toLowerCase() === lower);
+    return comp?.id ?? null;
+}
+function inferDockerConnectionType(image) {
+    if (!image)
+        return "docker";
+    const img = image.toLowerCase();
+    if (img.includes("postgres") || img.includes("mysql") || img.includes("mongo") || img.includes("mariadb")) {
+        return "database";
+    }
+    if (img.includes("redis") || img.includes("memcached"))
+        return "cache";
+    if (img.includes("rabbit") || img.includes("kafka") || img.includes("nats"))
+        return "queue";
+    return "docker";
+}

package/dist/agents/static/doc-parser.d.ts

@@ -0,0 +1,3 @@
+import type { DocResult } from "./types.js";
+import type { StaticToolkit } from "./utils.js";
+export declare function parseDocs(tk: StaticToolkit): Promise<DocResult>;