archbyte 0.1.0

package/README.md

@@ -0,0 +1,282 @@
+# Archbyte
+
+AI-powered architecture visualization for your codebase. Analyzes code, generates interactive diagrams, enforces architectural fitness rules, and monitors for drift — all from Claude Code.
+
+## Quick Start
+
+```bash
+# Install
+npm install -g archbyte
+# or from source
+git clone https://github.com/diabhey/archbyte.git && cd archbyte && npm install && npm run build && npm link
+```
+
+### Setup with Claude Code
+
+Slash commands are installed globally so they work in any project:
+
+```bash
+mkdir -p ~/.claude/commands
+cp commands/archbyte-*.md ~/.claude/commands/
+```
+
+Run `/archbyte-help` in Claude Code to see all commands. Every command shows its flags and examples when run without arguments (e.g. `/archbyte-export -h`).
+
+## Usage (Claude Code slash commands)
+
+| Command | What it does |
+|---------|-------------|
+| `/archbyte-analyze` | Scans your codebase and generates `.archbyte/analysis.json` |
+| `/archbyte-generate` | Converts analysis into `.archbyte/architecture.json` with positioned nodes |
+| `/archbyte-serve` | Opens interactive diagram UI at http://localhost:3847 |
+| `/archbyte-validate` | Runs fitness rules against your architecture |
+| `/archbyte-stats` | Shows architecture health dashboard |
+| `/archbyte-export` | Exports diagram to Mermaid, Markdown, or other formats |
+| `/archbyte-diff` | Compares architecture snapshots to detect drift |
+| `/archbyte-patrol` | Starts continuous architecture health monitoring |
+| `/archbyte-workflow` | Runs composable multi-step architecture pipelines |
+| `/archbyte-init` | Initializes `archbyte.yaml` config for your project |
+| `/archbyte-help` | Shows this command reference |
+
+### Typical workflow
+
+```
+/archbyte-init        # one-time: create config
+/archbyte-analyze     # AI scans your code
+/archbyte-serve       # view the diagram
+```
+
+## CLI Commands
+
+### `archbyte init`
+
+Scaffold an `archbyte.yaml` config and `.archbyte/` directory.
+
+```bash
+archbyte init
+archbyte init --force    # overwrite existing
+```
+
+> **Why this matters:** Without a config, every team member picks their own rules and thresholds. `init` gives your project a single source of truth for architecture governance from day one.
+>
+> *Example:* You join a new monorepo and want to enforce "no direct DB calls from the frontend." Run `archbyte init`, edit the generated `archbyte.yaml` to add that custom rule, and commit it — now every contributor shares the same guardrails.
+
+### `archbyte generate`
+
+Convert analysis JSON into an architecture diagram.
+
+```bash
+archbyte generate
+archbyte generate --input path/to/analysis.json --output path/to/arch.json
+archbyte generate --verbose
+```
+
+Merges with existing diagram to preserve user-adjusted node positions.
+
+> **Why this matters:** Raw analysis JSON is data — a positioned architecture diagram is *understanding*. Generate turns a flat list of components and dependencies into a spatial map you can actually reason about.
+>
+> *Example:* After an AI analysis finds 40 components and 120 dependencies, `archbyte generate` lays them out by layer so you instantly see that your "AuthService" sits in the wrong tier. Re-running after code changes merges new nodes in without losing the positions you manually adjusted last sprint.
+
+### `archbyte serve`
+
+Start the HTTP server with the interactive visualization UI.
+
+```bash
+archbyte serve                    # default port 3847
+archbyte serve --port 8080
+archbyte serve --diagram path/to/architecture.json
+```
+
+Features: real-time SSE updates, drag-and-drop nodes, environment filtering, flow animation, dependency highlighting, export to PNG/SVG.
+
+> **Why this matters:** Architecture diagrams on a wiki go stale the moment they're drawn. A live, interactive diagram that updates in real-time means you're always looking at the truth, not a six-month-old Confluence page.
+>
+> *Example:* During an incident review, run `archbyte serve` and drag the failing service to the center. Click it to highlight all upstream dependencies — now the whole team can see which services are affected and trace the blast radius visually instead of grep-ing through YAML manifests.
+
+### `archbyte validate`
+
+Run architecture fitness function rules.
+
+```bash
+archbyte validate
+archbyte validate --ci       # JSON output, exit code 1 on errors
+archbyte validate --watch    # re-validate on file changes
+```
+
+**Built-in rules:**
+
+| Rule | Default | Description |
+|------|---------|-------------|
+| `no-layer-bypass` | error | Connections that skip layers (e.g. presentation -> data) |
+| `max-connections` | warn (6) | Nodes exceeding connection threshold |
+| `no-orphans` | warn | Nodes with zero connections |
+| `no-circular-deps` | error | Cycles in the dependency graph |
+
+Configure in `archbyte.yaml`:
+
+```yaml
+rules:
+  no-layer-bypass: error
+  max-connections:
+    level: warn
+    threshold: 8
+  no-orphans: off
+  no-circular-deps: error
+  custom:
+    - name: "no-direct-db-from-frontend"
+      from: { layer: "presentation" }
+      to: { type: "database" }
+      level: error
+```
+
+> **Why this matters:** Code review catches syntax and logic bugs, but architectural violations slip through because no human reviewer holds the entire dependency graph in their head. Validate acts as an automated architect that never misses a rule.
+>
+> *Example:* A junior developer adds a direct import from a React component to a Postgres client library. `archbyte validate --ci` in your GitHub Actions pipeline catches the layer bypass (`presentation -> data`) and fails the build *before* the PR is merged — no manual review needed.
+
+### `archbyte stats`
+
+Architecture health dashboard.
+
+```bash
+archbyte stats
+archbyte stats --diagram path/to/architecture.json
+```
+
+Shows: component counts, layer distribution, connection density, hub detection, orphan detection, layer violations.
+
+> **Why this matters:** "How healthy is our architecture?" is usually answered with gut feelings. Stats turns that into numbers you can track over time and discuss objectively in sprint retros.
+>
+> *Example:* You run `archbyte stats` and discover your `ApiGateway` has 14 connections — more than double the threshold. That's a hub risk: if it goes down, 14 services are affected. You bring this to the team meeting with hard data instead of a hunch, and the team agrees to split it into domain-specific gateways.
+
+### `archbyte export`
+
+Export to various formats.
+
+```bash
+archbyte export                              # mermaid to stdout
+archbyte export --format plantuml
+archbyte export --format dot                 # Graphviz
+archbyte export --format markdown
+archbyte export --format json
+archbyte export --output docs/architecture.mmd
+```
+
+> **Why this matters:** Your architecture diagram shouldn't be locked inside one tool. Export lets you embed it in PRs, design docs, ADRs, or any toolchain your team already uses.
+>
+> *Example:* Before each release, you run `archbyte export --format mermaid --output docs/architecture.mmd` and commit it. GitHub renders the Mermaid diagram inline in your repo — anyone browsing the codebase sees an always-current architecture map without installing anything.
+
+### `archbyte diff`
+
+Compare architecture snapshots and detect drift.
+
+```bash
+archbyte diff --baseline .archbyte/baseline.json
+archbyte diff --baseline old.json --current new.json
+```
+
+Reports added/removed components, added/removed connections, density change, new/resolved violations. Exit code 1 on new errors.
+
+> **Why this matters:** Architecture erosion happens one commit at a time. By the time someone notices, the codebase has drifted far from its intended design. Diff catches drift early by comparing snapshots and surfacing exactly what changed.
+>
+> *Example:* You save a baseline after your v2.0 release with `cp .archbyte/architecture.json .archbyte/baseline.json`. Two months later, run `archbyte diff --baseline .archbyte/baseline.json` and discover 3 new circular dependencies and a removed service boundary. You can now decide whether to accept the drift or fix it — before it compounds further.
+
+### `archbyte patrol`
+
+Continuous architecture health monitoring — runs the validation pipeline on a repeating interval, diffs each cycle to detect new and resolved violations, and maintains a persistent health history.
+
+Inspired by [Gastown's](https://github.com/steveyegge/gastown) patrol loop pattern.
+
+```bash
+archbyte patrol                       # default 5m interval
+archbyte patrol --interval 30s        # 30 second cycles
+archbyte patrol --interval 1h         # hourly
+archbyte patrol --on-violation json   # JSON output for piping
+archbyte patrol --history             # view patrol history dashboard
+```
+
+**Options:**
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--interval <duration>` | `5m` | Cycle interval: `30s`, `5m`, `1h` |
+| `--on-violation <action>` | `log` | Action on new violations: `log` or `json` |
+| `--history` | — | Show health sparkline, history table, health rate |
+
+The patrol daemon:
+- Reports **new** violations and **resolved** ones each cycle
+- Persists history to `.archbyte/patrols/history.jsonl`
+- `--history` shows a sparkline health chart and stats
+
+> **Why this matters:** Validate catches violations at a point in time; Patrol catches them *over time*. Running continuously, it detects the moment a violation appears and tells you when violations get resolved — giving you a living health timeline for your architecture.
+>
+> *Example:* You start `archbyte patrol --interval 5m` in a tmux session during a refactoring sprint. Mid-afternoon, it flags a new circular dependency introduced in the latest commit. You fix it immediately instead of discovering it three weeks later in a failing CI pipeline. At the end of the sprint, `archbyte patrol --history` shows the team a sparkline proving architecture health improved from 72% to 95%.
+
+### `archbyte workflow`
+
+Composable multi-step architecture pipelines with dependency tracking and resume-on-failure. Inspired by Gastown's MEOW (Molecular Expression of Work) system.
+
+```bash
+archbyte workflow --list                  # list available workflows
+archbyte workflow --run full-analysis     # run a workflow
+archbyte workflow --show ci-check         # show step details
+archbyte workflow --status                # show progress bars
+archbyte workflow --create "my-pipeline"  # scaffold a custom workflow
+archbyte workflow --reset                 # clear all state
+```
+
+**Built-in workflows:**
+
+| Workflow | Steps | Description |
+|----------|-------|-------------|
+| `full-analysis` | generate -> validate -> stats -> export | Complete pipeline |
+| `ci-check` | validate (CI mode) | Lightweight CI gate |
+| `drift-check` | snapshot -> generate -> diff | Detect drift |
+
+**Custom workflows** — YAML files in `.archbyte/workflows/`:
+
+```yaml
+id: my-pipeline
+name: "My Custom Pipeline"
+description: "Custom architecture workflow"
+
+steps:
+  - id: generate
+    name: "Generate Diagram"
+    command: "archbyte generate"
+    needs: []
+
+  - id: validate
+    name: "Validate"
+    command: "archbyte validate --ci"
+    needs: [generate]
+
+  - id: export
+    name: "Export"
+    command: "archbyte export --format mermaid --output docs/arch.mmd"
+    needs: [generate]
+```
+
+Workflows **resume on failure** — completed steps are skipped when you re-run. State persists in `.archbyte/workflows/.state/`.
+
+> **Why this matters:** Running `generate`, then `validate`, then `stats`, then `export` manually is tedious and error-prone. Workflows chain them into a single reproducible pipeline — and if step 3 fails, you re-run and it skips the already-completed steps instead of starting from scratch.
+>
+> *Example:* You add a `ci-check` workflow to your GitHub Actions. On every PR, it runs `archbyte workflow --run ci-check`, which validates architecture rules in CI mode and exits non-zero on violations. No manual steps, no forgotten checks. For bigger releases, `archbyte workflow --run full-analysis` runs the entire generate-validate-stats-export pipeline in one command and produces a Mermaid diagram committed to `docs/`.
+
+## Keyboard Shortcuts (UI)
+
+| Key | Action |
+|-----|--------|
+| `Ctrl/Cmd + F` | Search |
+| `Ctrl/Cmd + S` | Save positions |
+| `Ctrl/Cmd + E` | Export PNG |
+| `Escape` | Clear search / close panel |
+| `Delete` | Hide selected node |
+
+## Requirements
+
+- Node.js >= 18
+- Claude Code (for `/archbyte-analyze`)
+
+## License
+
+MIT

package/bin/archbyte.js

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { handleServe } from '../dist/cli/serve.js';
+import { handleGenerate } from '../dist/cli/generate.js';
+import { handleStats } from '../dist/cli/stats.js';
+import { handleValidate } from '../dist/cli/validate.js';
+import { handleExport } from '../dist/cli/export.js';
+import { handleDiff } from '../dist/cli/diff.js';
+import { handlePatrol } from '../dist/cli/patrol.js';
+import { handleWorkflow } from '../dist/cli/workflow.js';
+import { handleAnalyze } from '../dist/cli/analyze.js';
+import { handleConfig } from '../dist/cli/config.js';
+import { handleLogin, handleLoginWithToken, handleLogout, handleStatus } from '../dist/cli/auth.js';
+import { handleRun } from '../dist/cli/run.js';
+import { handleSetup } from '../dist/cli/setup.js';
+import { requireLicense } from '../dist/cli/license-gate.js';
+
+const program = new Command();
+
+program
+  .name('archbyte')
+  .description('ArchByte - See what agents build. As they build it.')
+  .version('0.1.0')
+  .addHelpText('after', '\nFor more details visit https://archbyte.heartbyte.io');
+
+// — Getting started —
+
+program
+  .command('login')
+  .description('Sign in to ArchByte (required for scan/analyze/generate)')
+  .option('--token <jwt>', 'Login with a pre-existing JWT token')
+  .option('--github', 'Sign in with GitHub')
+  .option('--google', 'Sign in with Google')
+  .action(async (options) => {
+    if (options.token) {
+      await handleLoginWithToken(options.token);
+    } else {
+      const provider = options.google ? 'google' : 'github';
+      await handleLogin(provider);
+    }
+  });
+
+program
+  .command('logout')
+  .description('Sign out of ArchByte')
+  .action(async () => {
+    await handleLogout();
+  });
+
+program
+  .command('init')
+  .description('Configure model provider, API key, and project rules')
+  .action(async () => {
+    await handleSetup();
+  });
+
+// — Core workflow —
+
+program
+  .command('run')
+  .description('Analyze, generate, and serve - full pipeline in one shot')
+  .option('--static', 'Static-only analysis (no model, free)')
+  .option('--skip-llm', 'Alias for --static')
+  .option('--provider <name>', 'Model provider: anthropic, openai, google, ollama')
+  .option('--api-key <key>', 'Model API key (overrides config)')
+  .option('-p, --port <number>', 'UI server port (default: 3847)', parseInt)
+  .option('-v, --verbose', 'Show detailed output')
+  .option('--dry-run', 'Preview without running')
+  .action(async (options) => {
+    await requireLicense('analyze');
+    await handleRun(options);
+  });
+
+program
+  .command('analyze')
+  .description('Run AI-powered architecture analysis (BYOK - uses your model API key)')
+  .option('-o, --output <path>', 'Output analysis path (default: .archbyte/analysis.json)')
+  .option('-v, --verbose', 'Show detailed output')
+  .option('--provider <name>', 'Model provider: anthropic, openai, google, ollama')
+  .option('--api-key <key>', 'Model API key (overrides config)')
+  .option('--premium-only', 'Run only premium agents (requires existing analysis)')
+  .option('--static', 'Static-only analysis (no model, free)')
+  .option('--skip-llm', 'Alias for --static')
+  .option('--dry-run', 'Preview without running')
+  .action(async (options) => {
+    await requireLicense('analyze');
+    await handleAnalyze(options);
+  });
+
+program
+  .command('generate')
+  .description('Generate diagram from analysis JSON')
+  .option('-i, --input <path>', 'Input analysis JSON (default: .archbyte/analysis.json)')
+  .option('-o, --output <path>', 'Output diagram (default: .archbyte/architecture.json)')
+  .option('-v, --verbose', 'Show detailed output')
+  .action(async (options) => {
+    await requireLicense('generate');
+    await handleGenerate(options);
+  });
+
+program
+  .command('serve')
+  .description('Start the visualization UI server')
+  .option('-p, --port <number>', 'Server port (default: 3847)', parseInt)
+  .option('-d, --diagram <path>', 'Path to architecture JSON (default: .archbyte/architecture.json)')
+  .action(async (options) => {
+    await handleServe(options);
+  });
+
+// — Inspect & export —
+
+program
+  .command('stats')
+  .description('Show architecture health dashboard')
+  .option('-d, --diagram <path>', 'Path to architecture JSON (default: .archbyte/architecture.json)')
+  .option('-c, --config <path>', 'Path to archbyte.yaml config')
+  .action(async (options) => {
+    await handleStats(options);
+  });
+
+program
+  .command('validate')
+  .description('Run architecture fitness function rules')
+  .option('-d, --diagram <path>', 'Path to architecture JSON (default: .archbyte/architecture.json)')
+  .option('-c, --config <path>', 'Path to archbyte.yaml config')
+  .option('--ci', 'Machine-readable JSON output for CI pipelines')
+  .option('-w, --watch', 'Watch for changes and re-validate')
+  .action(async (options) => {
+    await requireLicense('analyze');
+    await handleValidate(options);
+  });
+
+program
+  .command('diff')
+  .description('Compare architecture snapshots and detect drift')
+  .requiredOption('-b, --baseline <path>', 'Path to baseline architecture JSON')
+  .option('-c, --current <path>', 'Path to current architecture JSON (default: .archbyte/architecture.json)')
+  .option('--config <path>', 'Path to archbyte.yaml config')
+  .action(async (options) => {
+    await handleDiff(options);
+  });
+
+program
+  .command('export')
+  .description('Export architecture to various formats')
+  .option('-d, --diagram <path>', 'Path to architecture JSON (default: .archbyte/architecture.json)')
+  .option('-f, --format <format>', 'Output format: mermaid, markdown, json, plantuml, dot (default: mermaid)')
+  .option('-o, --output <path>', 'Write to file instead of stdout')
+  .action(async (options) => {
+    await handleExport(options);
+  });
+
+// — Advanced (Pro) —
+
+program
+  .command('patrol')
+  .description('Run continuous architecture health monitoring (Gastown-inspired patrol loop)')
+  .option('-d, --diagram <path>', 'Path to architecture JSON (default: .archbyte/architecture.json)')
+  .option('-c, --config <path>', 'Path to archbyte.yaml config')
+  .option('-i, --interval <duration>', 'Patrol interval: 30s, 5m, 1h (default: 5m)')
+  .option('--on-violation <action>', 'Action on new violations: log, json (default: log)')
+  .option('--history', 'Show patrol history dashboard')
+  .action(async (options) => {
+    await requireLicense('analyze');
+    await handlePatrol(options);
+  });
+
+program
+  .command('workflow')
+  .description('Run composable architecture workflows (MEOW-inspired pipeline system)')
+  .option('-r, --run <id>', 'Run a workflow by ID')
+  .option('-l, --list', 'List available workflows')
+  .option('-s, --show <id>', 'Show workflow details and step status')
+  .option('--status', 'Show status of active workflows')
+  .option('--reset', 'Reset all workflow state')
+  .option('--create <name>', 'Create a new custom workflow file')
+  .action(async (options) => {
+    await requireLicense('analyze');
+    await handleWorkflow(options);
+  });
+
+// — Account —
+
+program
+  .command('status')
+  .description('Show account status, tier, and usage')
+  .action(async () => {
+    await handleStatus();
+  });
+
+program
+  .command('config')
+  .description('Manage ArchByte configuration (provider, API key)')
+  .argument('[action]', 'show, set, get, or path')
+  .argument('[key]', 'config key (provider, api-key, ollama-url)')
+  .argument('[value]', 'config value')
+  .action(async (action, key, value) => {
+    await handleConfig({ args: [action, key, value].filter(Boolean) });
+  });
+
+// Default: show help
+program
+  .action(() => {
+    program.help();
+  });
+
+// Unknown commands: show help
+program.on('command:*', () => {
+  program.help();
+});
+
+program.parse();

package/dist/agents/core/component-detector.d.ts

@@ -0,0 +1,2 @@
+import type { ArchByteAgent } from "../runtime/types.js";
+export declare const componentDetector: ArchByteAgent;

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

@@ -0,0 +1,57 @@
+import { executeToolLoop } from "../runtime/orchestrator.js";
+export const componentDetector = {
+    id: "component-detector",
+    name: "Component Detector",
+    description: "Detects architectural components, services, and DDD bounded contexts.",
+    tier: "free",
+    phase: "parallel",
+    modelTier: "standard",
+    requiredTools: ["glob", "read_file", "grep", "list_dir"],
+    systemPrompt: `You are an architectural component detection agent. Your job is to identify the major components, services, and modules in a software project.
+
+Analyze the project and return a JSON object with this structure:
+{
+  "components": [
+    {
+      "name": "string",
+      "type": "service | library | api | frontend | worker | database | gateway | queue | cache",
+      "layer": "presentation | application | data | external | deployment",
+      "path": "relative path to component root",
+      "description": "what this component does",
+      "technologies": ["list of key technologies"],
+      "boundedContext": "string or null (DDD bounded context name)"
+    }
+  ]
+}
+
+Instructions:
+1. Start by listing the root directory and key subdirectories
+2. Look for services, packages, apps, or modules
+3. Read key files (index.ts, main.py, app.go, etc.) to understand purpose
+4. Assign each component to an architectural layer:
+   - presentation: UI, frontend, CLI, API gateway
+   - application: business logic, services, controllers
+   - data: databases, repositories, ORMs, data access
+   - external: third-party integrations, external APIs
+   - deployment: Docker, K8s, CI/CD, infrastructure
+5. Identify DDD bounded contexts where applicable
+6. Return ONLY the JSON object, no other text`,
+    async run(context) {
+        const start = Date.now();
+        const output = await executeToolLoop(context, this.systemPrompt, "Detect all architectural components in this project. Start by exploring the directory structure, then read key files to understand each component's purpose.");
+        let data;
+        try {
+            const jsonMatch = output.match(/\{[\s\S]*\}/);
+            data = jsonMatch ? JSON.parse(jsonMatch[0]) : { raw: output };
+        }
+        catch {
+            data = { raw: output };
+        }
+        return {
+            agentId: this.id,
+            data,
+            confidence: data && typeof data === "object" && "components" in data ? 0.85 : 0.4,
+            duration: Date.now() - start,
+        };
+    },
+};

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

@@ -0,0 +1,2 @@
+import type { ArchByteAgent } from "../runtime/types.js";
+export declare const connectionMapper: ArchByteAgent;

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

@@ -0,0 +1,77 @@
+import { executeToolLoop } from "../runtime/orchestrator.js";
+export const connectionMapper = {
+    id: "connection-mapper",
+    name: "Connection Mapper",
+    description: "Maps connections between components: HTTP calls, DB access, message flows, imports.",
+    tier: "free",
+    phase: "sequential",
+    modelTier: "standard",
+    requiredTools: ["glob", "read_file", "grep"],
+    systemPrompt: `You are an architectural connection mapping agent. Your job is to identify all connections and dependencies between the components discovered in the previous analysis phase.
+
+You will receive prior results from other agents, including the component list. Use this to map connections.
+
+Return a JSON object with this structure:
+{
+  "connections": [
+    {
+      "source": "component name (from)",
+      "target": "component name (to)",
+      "type": "http | grpc | graphql | database | queue | import | file | event | websocket",
+      "label": "short description of the connection",
+      "style": "solid | dashed",
+      "bidirectional": false,
+      "evidence": "file:line where this connection was found"
+    }
+  ],
+  "flows": [
+    {
+      "name": "User Login Flow",
+      "steps": ["component1 → component2", "component2 → component3"]
+    }
+  ]
+}
+
+Instructions:
+1. Review the component list from prior results
+2. For each component, search for imports, HTTP calls, database connections, and message publishing
+3. Look for patterns: fetch/axios calls, DB queries, queue.publish, event.emit, import statements
+4. Map connections between identified components
+5. Identify common user flows (login, checkout, data pipeline, etc.)
+6. Use "dashed" style for event-driven/async connections, "solid" for synchronous
+7. Return ONLY the JSON object, no other text`,
+    async run(context) {
+        const start = Date.now();
+        // Build context from prior results
+        let priorContext = "";
+        if (context.priorResults) {
+            const components = context.priorResults["component-detector"]?.data;
+            if (components) {
+                priorContext += `\n\nPrior analysis - Components found:\n${JSON.stringify(components, null, 2)}`;
+            }
+            const structure = context.priorResults["structure-scanner"]?.data;
+            if (structure) {
+                priorContext += `\n\nPrior analysis - Project structure:\n${JSON.stringify(structure, null, 2)}`;
+            }
+            const infra = context.priorResults["infra-analyzer"]?.data;
+            if (infra) {
+                priorContext += `\n\nPrior analysis - Infrastructure:\n${JSON.stringify(infra, null, 2)}`;
+            }
+        }
+        const output = await executeToolLoop(context, this.systemPrompt, `Map all connections between components in this project. Search for HTTP calls, database connections, imports, message queues, and events.${priorContext}`);
+        let data;
+        try {
+            const jsonMatch = output.match(/\{[\s\S]*\}/);
+            data = jsonMatch ? JSON.parse(jsonMatch[0]) : { raw: output };
+        }
+        catch {
+            data = { raw: output };
+        }
+        return {
+            agentId: this.id,
+            data,
+            confidence: data && typeof data === "object" && "connections" in data ? 0.8 : 0.4,
+            duration: Date.now() - start,
+        };
+    },
+};

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

@@ -0,0 +1,2 @@
+import type { ArchByteAgent } from "../runtime/types.js";
+export declare const docParser: ArchByteAgent;