archbyte 0.1.0

package/dist/agents/core/doc-parser.js

@@ -0,0 +1,64 @@
+import { executeToolLoop } from "../runtime/orchestrator.js";
+export const docParser = {
+    id: "doc-parser",
+    name: "Documentation Parser",
+    description: "Parses README, OpenAPI specs, and Mermaid diagrams for architectural insights.",
+    tier: "free",
+    phase: "parallel",
+    modelTier: "standard",
+    requiredTools: ["glob", "read_file"],
+    systemPrompt: `You are a documentation analysis agent. Your job is to extract architectural information from project documentation.
+
+Analyze documentation files and return a JSON object with this structure:
+{
+  "projectDescription": "string",
+  "architectureNotes": ["key architectural decisions or patterns mentioned in docs"],
+  "apiEndpoints": [
+    {
+      "method": "GET | POST | PUT | DELETE",
+      "path": "/api/...",
+      "description": "what it does"
+    }
+  ],
+  "diagrams": [
+    {
+      "type": "mermaid | plantuml | ascii",
+      "description": "what the diagram shows",
+      "components": ["components referenced in diagram"]
+    }
+  ],
+  "externalDependencies": [
+    {
+      "name": "service or API name",
+      "type": "api | database | queue | storage | auth",
+      "description": "what it's used for"
+    }
+  ]
+}
+
+Instructions:
+1. Search for documentation files: README*, ARCHITECTURE*, DESIGN*, docs/**, *.md
+2. Look for OpenAPI/Swagger specs: openapi.*, swagger.*, **/api-spec.*
+3. Extract Mermaid or PlantUML diagrams from markdown files
+4. Identify external service dependencies mentioned in docs
+5. Extract API endpoint documentation
+6. Return ONLY the JSON object, no other text`,
+    async run(context) {
+        const start = Date.now();
+        const output = await executeToolLoop(context, this.systemPrompt, "Parse project documentation for architectural insights. Search for README, docs, API specs, and architecture diagrams.");
+        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" && "projectDescription" in data ? 0.8 : 0.5,
+            duration: Date.now() - start,
+        };
+    },
+};

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

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

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

@@ -0,0 +1,51 @@
+import { executeToolLoop } from "../runtime/orchestrator.js";
+export const envDetector = {
+    id: "env-detector",
+    name: "Environment Detector",
+    description: "Detects environments, configuration, and deployment stages.",
+    tier: "free",
+    phase: "parallel",
+    modelTier: "fast",
+    requiredTools: ["glob", "read_file"],
+    systemPrompt: `You are an environment detection agent. Your job is to identify the deployment environments and configuration patterns in a project.
+
+Analyze the project and return a JSON object with this structure:
+{
+  "environments": [
+    {
+      "name": "development | staging | production | test",
+      "configFiles": ["list of config files for this env"],
+      "variables": ["key env variable names (NOT values)"]
+    }
+  ],
+  "configPattern": "env-files | yaml | json | toml | vault | aws-ssm | none",
+  "hasSecrets": boolean,
+  "secretsManagement": "vault | aws-secrets | gcp-secrets | env-files | none"
+}
+
+Instructions:
+1. Search for .env files (.env, .env.*, .env.example)
+2. Look for config directories (config/, environments/)
+3. Check for environment-specific configs (config.production.ts, settings.staging.yaml)
+4. Identify secret management patterns (vault, AWS SSM, sealed-secrets)
+5. List environment variable NAMES only, never values
+6. Return ONLY the JSON object, no other text`,
+    async run(context) {
+        const start = Date.now();
+        const output = await executeToolLoop(context, this.systemPrompt, "Detect environments and configuration patterns. Search for .env files, config directories, and environment-specific settings.");
+        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" && "environments" in data ? 0.85 : 0.5,
+            duration: Date.now() - start,
+        };
+    },
+};

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

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

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

@@ -0,0 +1,59 @@
+import { executeToolLoop } from "../runtime/orchestrator.js";
+export const eventDetector = {
+    id: "event-detector",
+    name: "Event Detector",
+    description: "Detects event-driven architecture patterns: Kafka, queues, pub/sub, webhooks.",
+    tier: "free",
+    phase: "parallel",
+    modelTier: "standard",
+    requiredTools: ["glob", "read_file", "grep"],
+    systemPrompt: `You are an event-driven architecture detection agent. Your job is to identify async messaging patterns, event buses, and pub/sub systems.
+
+Analyze the project and return a JSON object with this structure:
+{
+  "hasEDA": boolean,
+  "patterns": [
+    {
+      "type": "kafka | rabbitmq | sqs | sns | pubsub | redis-streams | nats | eventbridge | webhooks | websocket | sse | custom-events",
+      "producers": ["component or file that publishes"],
+      "consumers": ["component or file that subscribes"],
+      "topics": ["topic/queue/channel names"],
+      "evidence": "file:line where this was found"
+    }
+  ],
+  "events": [
+    {
+      "name": "event name or type",
+      "producer": "who emits it",
+      "consumers": ["who handles it"],
+      "schema": "brief description of event payload"
+    }
+  ]
+}
+
+Instructions:
+1. Search for message broker clients: kafkajs, amqplib, @aws-sdk/client-sqs, bull, ioredis
+2. Grep for patterns: .publish, .subscribe, .emit, .on(', EventEmitter, @EventHandler
+3. Look for webhook endpoints (POST routes that receive external events)
+4. Check for WebSocket or SSE server implementations
+5. Read relevant files to understand the event flow
+6. Return ONLY the JSON object, no other text`,
+    async run(context) {
+        const start = Date.now();
+        const output = await executeToolLoop(context, this.systemPrompt, "Detect event-driven architecture patterns. Search for message brokers, pub/sub, webhooks, and async communication.");
+        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" && "hasEDA" in data ? 0.8 : 0.5,
+            duration: Date.now() - start,
+        };
+    },
+};

package/dist/agents/core/infra-analyzer.d.ts

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

package/dist/agents/core/infra-analyzer.js

@@ -0,0 +1,72 @@
+import { executeToolLoop } from "../runtime/orchestrator.js";
+export const infraAnalyzer = {
+    id: "infra-analyzer",
+    name: "Infrastructure Analyzer",
+    description: "Analyzes Docker, Kubernetes, cloud infrastructure, and deployment configuration.",
+    tier: "free",
+    phase: "parallel",
+    modelTier: "standard",
+    requiredTools: ["glob", "read_file", "grep"],
+    systemPrompt: `You are an infrastructure analysis agent. Your job is to understand the deployment and infrastructure setup of a software project.
+
+Analyze the project and return a JSON object with this structure:
+{
+  "docker": {
+    "hasDocker": boolean,
+    "services": [
+      {
+        "name": "string",
+        "image": "string",
+        "ports": ["string"],
+        "dependsOn": ["string"]
+      }
+    ],
+    "composeFile": "path or null"
+  },
+  "kubernetes": {
+    "hasK8s": boolean,
+    "resources": [
+      {
+        "kind": "Deployment | Service | Ingress | ConfigMap | etc.",
+        "name": "string",
+        "namespace": "string"
+      }
+    ]
+  },
+  "cloud": {
+    "provider": "aws | gcp | azure | none",
+    "services": ["list of cloud services used (S3, RDS, CloudRun, etc.)"],
+    "iac": "terraform | pulumi | cdk | cloudformation | none"
+  },
+  "ci": {
+    "platform": "github-actions | gitlab-ci | jenkins | circleci | none",
+    "pipelines": ["list of pipeline/workflow names"]
+  }
+}
+
+Instructions:
+1. Search for Dockerfiles, docker-compose files
+2. Search for Kubernetes manifests (*.yaml in k8s/, deploy/, manifests/)
+3. Look for cloud configuration (terraform/, .aws/, gcp/, azure/)
+4. Check CI/CD configs (.github/workflows/, .gitlab-ci.yml, Jenkinsfile)
+5. Read and parse each config file found
+6. Return ONLY the JSON object, no other text`,
+    async run(context) {
+        const start = Date.now();
+        const output = await executeToolLoop(context, this.systemPrompt, "Analyze the infrastructure and deployment configuration. Search for Docker, Kubernetes, cloud config, and CI/CD pipelines.");
+        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" && "docker" in data ? 0.85 : 0.5,
+            duration: Date.now() - start,
+        };
+    },
+};

package/dist/agents/core/structure-scanner.d.ts

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

package/dist/agents/core/structure-scanner.js

@@ -0,0 +1,55 @@
+import { executeToolLoop } from "../runtime/orchestrator.js";
+export const structureScanner = {
+    id: "structure-scanner",
+    name: "Structure Scanner",
+    description: "Scans project structure, package managers, monorepo detection, and build systems.",
+    tier: "free",
+    phase: "parallel",
+    modelTier: "fast",
+    requiredTools: ["glob", "read_file", "list_dir"],
+    systemPrompt: `You are a project structure analysis agent. Your job is to understand the layout and build system of a software project.
+
+Analyze the project and return a JSON object with this structure:
+{
+  "projectName": "string",
+  "language": "string (primary language)",
+  "languages": ["list of all languages found"],
+  "framework": "string or null",
+  "packageManager": "npm | yarn | pnpm | pip | poetry | cargo | go | maven | gradle | other",
+  "isMonorepo": boolean,
+  "monorepoTool": "string or null (nx, turborepo, lerna, workspaces, etc.)",
+  "entryPoints": ["list of main entry files"],
+  "buildSystem": "string (tsc, vite, webpack, esbuild, etc.)",
+  "testFramework": "string or null",
+  "directories": {
+    "src": "description of what's in src/",
+    "...": "other significant directories"
+  }
+}
+
+Instructions:
+1. Start by listing the root directory to understand the project layout
+2. Read package.json, Cargo.toml, go.mod, pyproject.toml, or equivalent
+3. Look for monorepo indicators (workspaces, nx.json, turbo.json, lerna.json)
+4. Identify the primary language and framework
+5. Return ONLY the JSON object, no other text`,
+    async run(context) {
+        const start = Date.now();
+        const output = await executeToolLoop(context, this.systemPrompt, "Analyze the project structure. Start by listing the root directory, then read the relevant config files.");
+        let data;
+        try {
+            // Extract JSON from the response
+            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" && "projectName" in data ? 0.9 : 0.5,
+            duration: Date.now() - start,
+        };
+    },
+};

package/dist/agents/core/validator.d.ts

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

package/dist/agents/core/validator.js

@@ -0,0 +1,74 @@
+import { executeToolLoop } from "../runtime/orchestrator.js";
+export const validator = {
+    id: "validator",
+    name: "Architecture Validator",
+    description: "Validates analysis results: checks for orphans, broken references, and confidence scoring.",
+    tier: "free",
+    phase: "sequential",
+    modelTier: "standard",
+    requiredTools: ["read_file", "glob", "grep"],
+    systemPrompt: `You are an architecture validation agent. Your job is to review the results from all prior analysis agents and validate the findings.
+
+You will receive prior results from: structure-scanner, doc-parser, infra-analyzer, component-detector, event-detector, env-detector, and connection-mapper.
+
+Review all findings and return a JSON object with this structure:
+{
+  "valid": boolean,
+  "overallConfidence": 0.0-1.0,
+  "issues": [
+    {
+      "type": "orphan-component | missing-connection | broken-reference | inconsistency | incomplete-analysis",
+      "severity": "error | warning | info",
+      "message": "description of the issue",
+      "component": "affected component name or null"
+    }
+  ],
+  "suggestions": [
+    "list of improvement suggestions for the architecture"
+  ],
+  "componentCount": number,
+  "connectionCount": number,
+  "layerDistribution": {
+    "presentation": number,
+    "application": number,
+    "data": number,
+    "external": number,
+    "deployment": number
+  }
+}
+
+Instructions:
+1. Review all prior agent results for consistency
+2. Check for orphan components (no connections)
+3. Check for broken references (connections to non-existent components)
+4. Verify layer assignments make sense
+5. Score overall confidence based on agent results
+6. Spot-check 2-3 findings by reading actual source files
+7. Return ONLY the JSON object, no other text`,
+    async run(context) {
+        const start = Date.now();
+        let priorContext = "Prior analysis results:\n\n";
+        if (context.priorResults) {
+            for (const [agentId, result] of Object.entries(context.priorResults)) {
+                priorContext += `--- ${agentId} (confidence: ${result.confidence}) ---\n`;
+                priorContext += JSON.stringify(result.data, null, 2);
+                priorContext += "\n\n";
+            }
+        }
+        const output = await executeToolLoop(context, this.systemPrompt, `Validate the architecture analysis results. Check for orphans, broken references, and inconsistencies. Spot-check a few findings against actual source code.\n\n${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" && "valid" in data ? 0.9 : 0.5,
+            duration: Date.now() - start,
+        };
+    },
+};

package/dist/agents/index.d.ts

@@ -0,0 +1,24 @@
+export { Orchestrator, executeToolLoop } from "./runtime/orchestrator.js";
+export { AgentRegistry, getRegistry } from "./runtime/registry.js";
+export type { ArchByteAgent, AgentContext, AgentResult, LLMProvider, ToolBackend, License, ArchByteConfig, ProviderName, ModelTier, AgentTier, PipelineResult, } from "./runtime/types.js";
+export { MODEL_MAP, resolveModel } from "./runtime/types.js";
+export { createProvider, detectConfig } from "./providers/router.js";
+export { AnthropicProvider } from "./providers/anthropic.js";
+export { OpenAIProvider } from "./providers/openai.js";
+export { GoogleProvider } from "./providers/google.js";
+export { OllamaProvider } from "./providers/ollama.js";
+export { LocalFSBackend } from "./tools/local-fs.js";
+export { ClaudeCodeBackend } from "./tools/claude-code.js";
+export { AGENT_TOOLS } from "./tools/tool-definitions.js";
+export { structureScanner } from "./core/structure-scanner.js";
+export { componentDetector } from "./core/component-detector.js";
+export { connectionMapper } from "./core/connection-mapper.js";
+export { docParser } from "./core/doc-parser.js";
+export { infraAnalyzer } from "./core/infra-analyzer.js";
+export { eventDetector } from "./core/event-detector.js";
+export { envDetector } from "./core/env-detector.js";
+export { validator } from "./core/validator.js";
+export declare const CORE_AGENTS: import("./runtime/types.js").ArchByteAgent[];
+export declare function loadPremiumAgents(): Promise<typeof CORE_AGENTS>;
+export declare const PREMIUM_AGENTS: typeof CORE_AGENTS;
+export declare const ALL_AGENTS: import("./runtime/types.js").ArchByteAgent[];

package/dist/agents/index.js

@@ -0,0 +1,73 @@
+// ArchByte Agent Framework — Main Entry Point
+// Runtime
+export { Orchestrator, executeToolLoop } from "./runtime/orchestrator.js";
+export { AgentRegistry, getRegistry } from "./runtime/registry.js";
+export { MODEL_MAP, resolveModel } from "./runtime/types.js";
+// Providers
+export { createProvider, detectConfig } from "./providers/router.js";
+export { AnthropicProvider } from "./providers/anthropic.js";
+export { OpenAIProvider } from "./providers/openai.js";
+export { GoogleProvider } from "./providers/google.js";
+export { OllamaProvider } from "./providers/ollama.js";
+// Tools
+export { LocalFSBackend } from "./tools/local-fs.js";
+export { ClaudeCodeBackend } from "./tools/claude-code.js";
+export { AGENT_TOOLS } from "./tools/tool-definitions.js";
+// Core Agents
+export { structureScanner } from "./core/structure-scanner.js";
+export { componentDetector } from "./core/component-detector.js";
+export { connectionMapper } from "./core/connection-mapper.js";
+export { docParser } from "./core/doc-parser.js";
+export { infraAnalyzer } from "./core/infra-analyzer.js";
+export { eventDetector } from "./core/event-detector.js";
+export { envDetector } from "./core/env-detector.js";
+export { validator } from "./core/validator.js";
+// Premium agents are not shipped in the npm package.
+// They are loaded dynamically at runtime for licensed users.
+// All core agents as a list for easy registration
+import { structureScanner } from "./core/structure-scanner.js";
+import { componentDetector } from "./core/component-detector.js";
+import { connectionMapper } from "./core/connection-mapper.js";
+import { docParser } from "./core/doc-parser.js";
+import { infraAnalyzer } from "./core/infra-analyzer.js";
+import { eventDetector } from "./core/event-detector.js";
+import { envDetector } from "./core/env-detector.js";
+import { validator } from "./core/validator.js";
+export const CORE_AGENTS = [
+    structureScanner,
+    docParser,
+    infraAnalyzer,
+    componentDetector,
+    eventDetector,
+    envDetector,
+    connectionMapper,
+    validator,
+];
+// Dynamic loader for premium agents (not bundled in npm package)
+export async function loadPremiumAgents() {
+    try {
+        const mods = await Promise.all([
+            import("./premium/security-auditor.js"),
+            import("./premium/compliance-checker.js"),
+            import("./premium/performance-analyzer.js"),
+            import("./premium/dependency-risk-scorer.js"),
+            import("./premium/migration-planner.js"),
+            import("./premium/api-contract-verifier.js"),
+            import("./premium/drift-detector.js"),
+        ]);
+        return [
+            mods[0].securityAuditor,
+            mods[1].complianceChecker,
+            mods[2].performanceAnalyzer,
+            mods[3].dependencyRiskScorer,
+            mods[4].migrationPlanner,
+            mods[5].apiContractVerifier,
+            mods[6].driftDetector,
+        ];
+    }
+    catch {
+        return [];
+    }
+}
+export const PREMIUM_AGENTS = [];
+export const ALL_AGENTS = [...CORE_AGENTS];

package/dist/agents/llm/index.d.ts

@@ -0,0 +1,8 @@
+import type { StaticAnalysisResult } from "../static/types.js";
+import type { LLMProvider, ArchByteConfig } from "../runtime/types.js";
+export type { LLMEnhancement } from "./types.js";
+/**
+ * Enhance static analysis with a single LLM call.
+ * Returns the merged analysis. On any failure, returns the original unchanged.
+ */
+export declare function enhanceWithLLM(analysis: StaticAnalysisResult, provider: LLMProvider, config: ArchByteConfig, projectRoot: string, onProgress?: (msg: string) => void): Promise<StaticAnalysisResult>;