archbyte 0.1.0

package/dist/agents/tools/claude-code.js

@@ -0,0 +1,129 @@
+import { readFile, readdir, stat } from "node:fs/promises";
+import { resolve, join } from "node:path";
+/**
+ * ClaudeCodeBackend — uses the same local FS operations as LocalFSBackend
+ * but is designed to be instantiated when running inside Claude Code.
+ *
+ * In practice, when archbyte is invoked via a Claude Code skill,
+ * Claude Code's Task agents run the archbyte agent pipeline.
+ * The agents use tool_use calls which are executed by the orchestrator
+ * against this backend — which reads the local filesystem that
+ * Claude Code also has access to.
+ *
+ * The key difference from LocalFSBackend:
+ * - Optimized for the files Claude Code has already discovered
+ * - Can accept a pre-scanned file list to avoid redundant discovery
+ * - Respects .gitignore and Claude Code's file filtering
+ */
+export class ClaudeCodeBackend {
+    root;
+    preScannedFiles;
+    constructor(projectRoot, preScannedFiles) {
+        this.root = resolve(projectRoot);
+        this.preScannedFiles = preScannedFiles;
+    }
+    async readFile(filePath) {
+        const resolved = this.resolvePath(filePath);
+        return readFile(resolved, "utf-8");
+    }
+    async glob(pattern) {
+        // If we have pre-scanned files, filter against the pattern
+        if (this.preScannedFiles) {
+            const regex = this.globToRegex(pattern);
+            return this.preScannedFiles.filter((f) => regex.test(f)).sort();
+        }
+        // Fallback to filesystem walk
+        const matches = [];
+        const regex = this.globToRegex(pattern);
+        await this.walk(this.root, "", regex, matches);
+        return matches.sort();
+    }
+    async grep(pattern, searchPath) {
+        const regex = new RegExp(pattern, "i");
+        const results = [];
+        const files = await this.glob("**/*");
+        for (const file of files.slice(0, 300)) {
+            try {
+                const content = await readFile(this.resolvePath(file), "utf-8");
+                const lines = content.split("\n");
+                for (let i = 0; i < lines.length; i++) {
+                    if (regex.test(lines[i])) {
+                        results.push({ file, line: i + 1, content: lines[i].trim() });
+                    }
+                }
+            }
+            catch {
+                // Skip
+            }
+            if (results.length >= 150)
+                break;
+        }
+        return results;
+    }
+    async listDir(dirPath) {
+        const resolved = this.resolvePath(dirPath);
+        const entries = await readdir(resolved, { withFileTypes: true });
+        const results = [];
+        for (const entry of entries) {
+            if (entry.name.startsWith(".") || entry.name === "node_modules")
+                continue;
+            const entryPath = join(resolved, entry.name);
+            const s = await stat(entryPath).catch(() => null);
+            results.push({
+                name: entry.name,
+                type: entry.isDirectory() ? "directory" : "file",
+                size: s?.size,
+            });
+        }
+        return results.sort((a, b) => {
+            if (a.type !== b.type)
+                return a.type === "directory" ? -1 : 1;
+            return a.name.localeCompare(b.name);
+        });
+    }
+    resolvePath(p) {
+        const resolved = resolve(this.root, p);
+        if (!resolved.startsWith(this.root)) {
+            throw new Error(`Path traversal attempt: ${p}`);
+        }
+        return resolved;
+    }
+    async walk(base, prefix, regex, matches) {
+        if (matches.length >= 3000)
+            return;
+        const dir = prefix ? join(base, prefix) : base;
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith(".") ||
+                entry.name === "node_modules" ||
+                entry.name === "dist" ||
+                entry.name === "__pycache__" ||
+                entry.name === ".git" ||
+                entry.name === ".archbyte") {
+                continue;
+            }
+            const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                await this.walk(base, relPath, regex, matches);
+            }
+            else if (entry.isFile() && regex.test(relPath)) {
+                matches.push(relPath);
+            }
+        }
+    }
+    globToRegex(pattern) {
+        let regex = pattern
+            .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+            .replace(/\*\*/g, "___DOUBLESTAR___")
+            .replace(/\*/g, "[^/]*")
+            .replace(/___DOUBLESTAR___/g, ".*")
+            .replace(/\?/g, "[^/]");
+        return new RegExp(`^${regex}$`);
+    }
+}

package/dist/agents/tools/local-fs.d.ts

@@ -0,0 +1,12 @@
+import type { ToolBackend, GrepResult, DirEntry } from "../runtime/types.js";
+export declare class LocalFSBackend implements ToolBackend {
+    private root;
+    constructor(projectRoot: string);
+    readFile(filePath: string): Promise<string>;
+    glob(pattern: string, cwd?: string): Promise<string[]>;
+    grep(pattern: string, searchPath?: string): Promise<GrepResult[]>;
+    listDir(dirPath: string): Promise<DirEntry[]>;
+    private resolvePath;
+    private walk;
+    private globToRegex;
+}

package/dist/agents/tools/local-fs.js

@@ -0,0 +1,112 @@
+import { readFile, readdir, stat } from "node:fs/promises";
+import { resolve, relative, join } from "node:path";
+export class LocalFSBackend {
+    root;
+    constructor(projectRoot) {
+        this.root = resolve(projectRoot);
+    }
+    async readFile(filePath) {
+        const resolved = this.resolvePath(filePath);
+        return readFile(resolved, "utf-8");
+    }
+    async glob(pattern, cwd) {
+        const searchDir = cwd ? this.resolvePath(cwd) : this.root;
+        // Use Node.js built-in glob (available in Node 22+) or fallback to manual walk
+        // For broad compatibility, do a simple recursive walk with pattern matching
+        const matches = [];
+        const regex = this.globToRegex(pattern);
+        await this.walk(searchDir, "", regex, matches);
+        return matches.sort();
+    }
+    async grep(pattern, searchPath) {
+        const searchDir = searchPath ? this.resolvePath(searchPath) : this.root;
+        const regex = new RegExp(pattern, "i");
+        const results = [];
+        const files = await this.glob("**/*", searchDir === this.root ? undefined : relative(this.root, searchDir));
+        for (const file of files.slice(0, 500)) {
+            try {
+                const content = await readFile(this.resolvePath(file), "utf-8");
+                const lines = content.split("\n");
+                for (let i = 0; i < lines.length; i++) {
+                    if (regex.test(lines[i])) {
+                        results.push({ file, line: i + 1, content: lines[i].trim() });
+                    }
+                }
+            }
+            catch {
+                // Skip unreadable files
+            }
+            if (results.length >= 200)
+                break;
+        }
+        return results;
+    }
+    async listDir(dirPath) {
+        const resolved = this.resolvePath(dirPath);
+        const entries = await readdir(resolved, { withFileTypes: true });
+        const results = [];
+        for (const entry of entries) {
+            if (entry.name.startsWith(".") || entry.name === "node_modules")
+                continue;
+            const entryPath = join(resolved, entry.name);
+            const s = await stat(entryPath).catch(() => null);
+            results.push({
+                name: entry.name,
+                type: entry.isDirectory() ? "directory" : "file",
+                size: s?.size,
+            });
+        }
+        return results.sort((a, b) => {
+            if (a.type !== b.type)
+                return a.type === "directory" ? -1 : 1;
+            return a.name.localeCompare(b.name);
+        });
+    }
+    resolvePath(p) {
+        const resolved = resolve(this.root, p);
+        // Prevent path traversal outside project root
+        if (!resolved.startsWith(this.root)) {
+            throw new Error(`Path traversal attempt: ${p}`);
+        }
+        return resolved;
+    }
+    async walk(base, prefix, regex, matches) {
+        if (matches.length >= 5000)
+            return;
+        const dir = prefix ? join(base, prefix) : base;
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            // Skip hidden dirs, node_modules, dist, .git
+            if (entry.name.startsWith(".") ||
+                entry.name === "node_modules" ||
+                entry.name === "dist" ||
+                entry.name === "__pycache__" ||
+                entry.name === ".git") {
+                continue;
+            }
+            const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                await this.walk(base, relPath, regex, matches);
+            }
+            else if (entry.isFile() && regex.test(relPath)) {
+                matches.push(relPath);
+            }
+        }
+    }
+    globToRegex(pattern) {
+        // Convert glob pattern to regex
+        let regex = pattern
+            .replace(/[.+^${}()|[\]\\]/g, "\\$&") // Escape special regex chars
+            .replace(/\*\*/g, "___DOUBLESTAR___")
+            .replace(/\*/g, "[^/]*")
+            .replace(/___DOUBLESTAR___/g, ".*")
+            .replace(/\?/g, "[^/]");
+        return new RegExp(`^${regex}$`);
+    }
+}

package/dist/agents/tools/tool-definitions.d.ts

@@ -0,0 +1,6 @@
+import type { ToolDefinition } from "../runtime/types.js";
+/**
+ * Tool definitions exposed to LLM agents.
+ * These match the ToolBackend interface methods.
+ */
+export declare const AGENT_TOOLS: ToolDefinition[];

package/dist/agents/tools/tool-definitions.js

@@ -0,0 +1,66 @@
+/**
+ * Tool definitions exposed to LLM agents.
+ * These match the ToolBackend interface methods.
+ */
+export const AGENT_TOOLS = [
+    {
+        name: "read_file",
+        description: "Read the contents of a file. Returns the full text content of the file.",
+        input_schema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Relative path to the file from the project root (e.g. 'src/index.ts', 'package.json')",
+                },
+            },
+            required: ["path"],
+        },
+    },
+    {
+        name: "glob",
+        description: "Find files matching a glob pattern. Returns a list of matching file paths relative to the project root. Supports ** for recursive matching.",
+        input_schema: {
+            type: "object",
+            properties: {
+                pattern: {
+                    type: "string",
+                    description: "Glob pattern (e.g. '**/*.ts', 'src/**/*.py', 'Dockerfile*', '*.yaml')",
+                },
+            },
+            required: ["pattern"],
+        },
+    },
+    {
+        name: "grep",
+        description: "Search file contents for a regex pattern. Returns matching lines with file paths and line numbers. Searches all text files in the project.",
+        input_schema: {
+            type: "object",
+            properties: {
+                pattern: {
+                    type: "string",
+                    description: "Regular expression pattern to search for (e.g. 'import.*express', 'class\\s+\\w+Controller')",
+                },
+                path: {
+                    type: "string",
+                    description: "Optional: restrict search to this directory (relative to project root)",
+                },
+            },
+            required: ["pattern"],
+        },
+    },
+    {
+        name: "list_dir",
+        description: "List contents of a directory. Returns file and directory names with types and sizes. Hidden files and node_modules are excluded.",
+        input_schema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Relative path to the directory from the project root (e.g. 'src', 'lib/utils'). Use '.' for root.",
+                },
+            },
+            required: ["path"],
+        },
+    },
+];

package/dist/cli/analyze.d.ts

@@ -0,0 +1,27 @@
+import type { StaticAnalysisResult } from "../agents/static/types.js";
+interface AnalyzeOptions {
+    output?: string;
+    verbose?: boolean;
+    provider?: string;
+    apiKey?: string;
+    premiumOnly?: boolean;
+    static?: boolean;
+    skipLlm?: boolean;
+    dryRun?: boolean;
+}
+export declare function handleAnalyze(options: AnalyzeOptions): Promise<void>;
+/**
+ * Convert a StaticAnalysisResult (from pipeline or static-only) into the
+ * flat analysis.json format expected by generate.ts.
+ */
+export declare function buildAnalysisFromStatic(result: StaticAnalysisResult, projectRoot: string): Record<string, unknown>;
+/**
+ * Aggregate agent results into the analysis.json format expected by the generator.
+ * Used by legacy mode (--legacy flag) only.
+ */
+export declare function buildAnalysis(agents: Array<{
+    agentId: string;
+    data: unknown;
+    confidence: number;
+}>, projectRoot: string): Record<string, unknown>;
+export {};