@compilr-dev/agents-coding-go 0.1.0

package/dist/tools/get-imports.js

@@ -0,0 +1,420 @@
+/**
+ * getImports Tool
+ *
+ * Analyzes imports in Go files.
+ * Categorizes imports into stdlib, third-party, and local.
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { defineTool, createSuccessResult, createErrorResult, } from "@compilr-dev/agents";
+import { parseFile, parseImport, walkTree } from "../parser/go-parser.js";
+// Go standard library packages (Go 1.21+)
+const STDLIB_PACKAGES = new Set([
+    // Core packages
+    "archive/tar",
+    "archive/zip",
+    "bufio",
+    "bytes",
+    "cmp",
+    "compress/bzip2",
+    "compress/flate",
+    "compress/gzip",
+    "compress/lzw",
+    "compress/zlib",
+    "container/heap",
+    "container/list",
+    "container/ring",
+    "context",
+    "crypto",
+    "crypto/aes",
+    "crypto/cipher",
+    "crypto/des",
+    "crypto/dsa",
+    "crypto/ecdh",
+    "crypto/ecdsa",
+    "crypto/ed25519",
+    "crypto/elliptic",
+    "crypto/hmac",
+    "crypto/md5",
+    "crypto/rand",
+    "crypto/rc4",
+    "crypto/rsa",
+    "crypto/sha1",
+    "crypto/sha256",
+    "crypto/sha512",
+    "crypto/subtle",
+    "crypto/tls",
+    "crypto/x509",
+    "crypto/x509/pkix",
+    "database/sql",
+    "database/sql/driver",
+    "debug/buildinfo",
+    "debug/dwarf",
+    "debug/elf",
+    "debug/gosym",
+    "debug/macho",
+    "debug/pe",
+    "debug/plan9obj",
+    "embed",
+    "encoding",
+    "encoding/ascii85",
+    "encoding/asn1",
+    "encoding/base32",
+    "encoding/base64",
+    "encoding/binary",
+    "encoding/csv",
+    "encoding/gob",
+    "encoding/hex",
+    "encoding/json",
+    "encoding/pem",
+    "encoding/xml",
+    "errors",
+    "expvar",
+    "flag",
+    "fmt",
+    "go/ast",
+    "go/build",
+    "go/build/constraint",
+    "go/constant",
+    "go/doc",
+    "go/doc/comment",
+    "go/format",
+    "go/importer",
+    "go/parser",
+    "go/printer",
+    "go/scanner",
+    "go/token",
+    "go/types",
+    "hash",
+    "hash/adler32",
+    "hash/crc32",
+    "hash/crc64",
+    "hash/fnv",
+    "hash/maphash",
+    "html",
+    "html/template",
+    "image",
+    "image/color",
+    "image/color/palette",
+    "image/draw",
+    "image/gif",
+    "image/jpeg",
+    "image/png",
+    "index/suffixarray",
+    "io",
+    "io/fs",
+    "io/ioutil",
+    "iter",
+    "log",
+    "log/slog",
+    "log/syslog",
+    "maps",
+    "math",
+    "math/big",
+    "math/bits",
+    "math/cmplx",
+    "math/rand",
+    "math/rand/v2",
+    "mime",
+    "mime/multipart",
+    "mime/quotedprintable",
+    "net",
+    "net/http",
+    "net/http/cgi",
+    "net/http/cookiejar",
+    "net/http/fcgi",
+    "net/http/httptest",
+    "net/http/httptrace",
+    "net/http/httputil",
+    "net/http/pprof",
+    "net/mail",
+    "net/netip",
+    "net/rpc",
+    "net/rpc/jsonrpc",
+    "net/smtp",
+    "net/textproto",
+    "net/url",
+    "os",
+    "os/exec",
+    "os/signal",
+    "os/user",
+    "path",
+    "path/filepath",
+    "plugin",
+    "reflect",
+    "regexp",
+    "regexp/syntax",
+    "runtime",
+    "runtime/cgo",
+    "runtime/coverage",
+    "runtime/debug",
+    "runtime/metrics",
+    "runtime/pprof",
+    "runtime/race",
+    "runtime/trace",
+    "slices",
+    "sort",
+    "strconv",
+    "strings",
+    "structs",
+    "sync",
+    "sync/atomic",
+    "syscall",
+    "testing",
+    "testing/fstest",
+    "testing/iotest",
+    "testing/quick",
+    "testing/slogtest",
+    "text/scanner",
+    "text/tabwriter",
+    "text/template",
+    "text/template/parse",
+    "time",
+    "time/tzdata",
+    "unicode",
+    "unicode/utf16",
+    "unicode/utf8",
+    "unique",
+    "unsafe",
+]);
+// Tool description
+const TOOL_DESCRIPTION = `Analyze imports in Go files.
+Returns categorized imports (stdlib, third_party, local) with statistics.
+Helps understand dependencies and import organization.`;
+// Tool input schema
+const TOOL_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        path: {
+            type: "string",
+            description: "Path to Go file or directory",
+        },
+        filterModule: {
+            type: "string",
+            description: "Filter to show only imports matching this prefix",
+        },
+        recursive: {
+            type: "boolean",
+            description: "Recursively scan directories (default: false)",
+            default: false,
+        },
+    },
+    required: ["path"],
+};
+/**
+ * getImports tool - Analyze Go imports
+ */
+export const getImportsTool = defineTool({
+    name: "get_imports_go",
+    description: TOOL_DESCRIPTION,
+    inputSchema: TOOL_INPUT_SCHEMA,
+    execute: executeGetImports,
+});
+/**
+ * Execute the getImports tool
+ */
+async function executeGetImports(input) {
+    const { path: inputPath, filterModule, recursive = false } = input;
+    // Validate input
+    if (!inputPath) {
+        return createErrorResult("Path is required");
+    }
+    try {
+        // Check if path exists
+        const stats = await fs.stat(inputPath);
+        if (stats.isFile()) {
+            // Analyze single file
+            const result = await analyzeFileImports(inputPath, filterModule);
+            return createSuccessResult(result);
+        }
+        else if (stats.isDirectory()) {
+            // Analyze directory
+            if (recursive) {
+                const results = await analyzeDirectoryImports(inputPath, filterModule);
+                return createSuccessResult(results);
+            }
+            else {
+                // Just analyze .go files in this directory
+                const entries = await fs.readdir(inputPath, { withFileTypes: true });
+                const goFiles = entries
+                    .filter((e) => e.isFile() && e.name.endsWith(".go"))
+                    .map((e) => path.join(inputPath, e.name));
+                if (goFiles.length === 0) {
+                    return createErrorResult(`No Go files found in: ${inputPath}`);
+                }
+                // Combine results from all files
+                const allImports = [];
+                let stdlibCount = 0;
+                let thirdPartyCount = 0;
+                let localCount = 0;
+                for (const filePath of goFiles) {
+                    const result = await analyzeFileImports(filePath, filterModule);
+                    allImports.push(...result.imports);
+                    stdlibCount += result.stats.stdlib;
+                    thirdPartyCount += result.stats.thirdParty;
+                    localCount += result.stats.local;
+                }
+                // Deduplicate imports
+                const uniqueImports = deduplicateImports(allImports);
+                return createSuccessResult({
+                    path: inputPath,
+                    imports: uniqueImports,
+                    stats: {
+                        total: uniqueImports.length,
+                        stdlib: stdlibCount,
+                        thirdParty: thirdPartyCount,
+                        local: localCount,
+                    },
+                });
+            }
+        }
+        else {
+            return createErrorResult(`Path is neither a file nor directory: ${inputPath}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return createErrorResult(`Failed to analyze imports: ${message}`);
+    }
+}
+/**
+ * Analyze imports in a single Go file
+ */
+async function analyzeFileImports(filePath, filterModule) {
+    const parseResult = await parseFile(filePath);
+    const { tree, source } = parseResult;
+    const rootNode = tree.rootNode;
+    const imports = [];
+    let stdlibCount = 0;
+    let thirdPartyCount = 0;
+    let localCount = 0;
+    // Look for import declarations
+    for (const node of walkTree(rootNode, ["import_declaration"])) {
+        const importInfos = parseImport(node, source);
+        for (const importInfo of importInfos) {
+            const category = categorizeImport(importInfo.module);
+            // Apply filter if specified
+            if (filterModule && !importInfo.module.startsWith(filterModule)) {
+                continue;
+            }
+            const categorizedImport = {
+                ...importInfo,
+                category,
+            };
+            imports.push(categorizedImport);
+            switch (category) {
+                case "stdlib":
+                    stdlibCount++;
+                    break;
+                case "third_party":
+                    thirdPartyCount++;
+                    break;
+                case "local":
+                    localCount++;
+                    break;
+            }
+        }
+    }
+    return {
+        path: filePath,
+        imports,
+        stats: {
+            total: imports.length,
+            stdlib: stdlibCount,
+            thirdParty: thirdPartyCount,
+            local: localCount,
+        },
+    };
+}
+/**
+ * Analyze imports in a directory recursively
+ */
+async function analyzeDirectoryImports(dir, filterModule) {
+    const allImports = [];
+    let stdlibCount = 0;
+    let thirdPartyCount = 0;
+    let localCount = 0;
+    async function walk(currentDir) {
+        const entries = await fs.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                // Skip vendor, testdata, and hidden directories
+                if (entry.name === "vendor" ||
+                    entry.name === "testdata" ||
+                    entry.name.startsWith(".")) {
+                    continue;
+                }
+                await walk(fullPath);
+            }
+            else if (entry.isFile() && entry.name.endsWith(".go")) {
+                const result = await analyzeFileImports(fullPath, filterModule);
+                allImports.push(...result.imports);
+                stdlibCount += result.stats.stdlib;
+                thirdPartyCount += result.stats.thirdParty;
+                localCount += result.stats.local;
+            }
+        }
+    }
+    await walk(dir);
+    // Deduplicate imports
+    const uniqueImports = deduplicateImports(allImports);
+    return {
+        path: dir,
+        imports: uniqueImports,
+        stats: {
+            total: uniqueImports.length,
+            stdlib: stdlibCount,
+            thirdParty: thirdPartyCount,
+            local: localCount,
+        },
+    };
+}
+/**
+ * Categorize an import path
+ */
+function categorizeImport(importPath) {
+    // Standard library doesn't have dots in the first segment
+    const firstSegment = importPath.split("/")[0];
+    // Check if it's a known stdlib package
+    if (STDLIB_PACKAGES.has(importPath)) {
+        return "stdlib";
+    }
+    // Standard library packages don't have dots (no domain)
+    if (!firstSegment.includes(".")) {
+        return "stdlib";
+    }
+    // If it starts with the current module path, it's local
+    // (This would require parsing go.mod, simplified here)
+    // Everything else is third-party
+    return "third_party";
+}
+/**
+ * Deduplicate imports by module path
+ */
+function deduplicateImports(imports) {
+    const seen = new Map();
+    for (const imp of imports) {
+        if (!seen.has(imp.module)) {
+            seen.set(imp.module, imp);
+        }
+    }
+    return Array.from(seen.values());
+}
+/**
+ * Factory function to create a customized getImports tool
+ */
+export function createGetImportsTool(options) {
+    const { defaultRecursive = false } = options ?? {};
+    return defineTool({
+        name: "get_imports_go",
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_INPUT_SCHEMA,
+        execute: async (input) => {
+            return executeGetImports({
+                ...input,
+                recursive: input.recursive ?? defaultRecursive,
+            });
+        },
+    });
+}

package/dist/tools/get-signature.d.ts

@@ -0,0 +1,100 @@
+/**
+ * getSignature Tool
+ *
+ * Get detailed signature information for a function, method, or class in Go code.
+ * Includes parameters, type hints, decorators, and docstrings.
+ */
+import type { Tool } from "@compilr-dev/agents";
+/**
+ * Python symbol kinds
+ */
+export type PythonSymbolKind = "function" | "async_function" | "method" | "class" | "variable";
+/**
+ * Parameter detail
+ */
+export interface ParameterDetail {
+    name: string;
+    type?: string;
+    optional: boolean;
+    defaultValue?: string;
+    description?: string;
+    isKwOnly?: boolean;
+    isPosOnly?: boolean;
+    isVarArgs?: boolean;
+    isKwArgs?: boolean;
+}
+/**
+ * Return type detail
+ */
+export interface ReturnTypeDetail {
+    type: string;
+    isCoroutine?: boolean;
+    nullable?: boolean;
+}
+/**
+ * Member signature (for class members)
+ */
+export interface MemberSignature {
+    name: string;
+    kind: "method" | "property" | "class_variable";
+    signature: string;
+    async?: boolean;
+    static?: boolean;
+    classmethod?: boolean;
+    decorators?: string[];
+}
+/**
+ * Documentation extracted from docstrings
+ */
+export interface Documentation {
+    summary: string;
+    description?: string;
+    params?: Record<string, string>;
+    returns?: string;
+    raises?: string[];
+    examples?: string[];
+    notes?: string;
+    deprecated?: string;
+}
+/**
+ * Input for getSignature tool
+ */
+export interface GetSignatureInput {
+    /** File containing the symbol */
+    path: string;
+    /** Symbol name to get signature for */
+    name: string;
+    /** Line number for disambiguation (optional) */
+    line?: number;
+    /** Include full documentation (default: true) */
+    includeDoc?: boolean;
+}
+/**
+ * Result of getSignature
+ */
+export interface GetSignatureResult {
+    name: string;
+    path: string;
+    kind: PythonSymbolKind;
+    line: number;
+    signature: string;
+    formattedSignature: string;
+    parameters?: ParameterDetail[];
+    returnType?: ReturnTypeDetail;
+    decorators?: string[];
+    documentation?: Documentation;
+    bases?: string[];
+    members?: MemberSignature[];
+    async?: boolean;
+}
+/**
+ * getSignature tool
+ */
+export declare const getSignatureTool: Tool<GetSignatureInput>;
+/**
+ * Factory function to create a customized getSignature tool
+ */
+export declare function createGetSignatureTool(options?: {
+    defaultIncludeDoc?: boolean;
+}): Tool<GetSignatureInput>;
+//# sourceMappingURL=get-signature.d.ts.map

package/dist/tools/get-signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-signature.d.ts","sourceRoot":"","sources":["../../src/tools/get-signature.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,OAAO,KAAK,EAAE,IAAI,EAAuB,MAAM,qBAAqB,CAAC;AAIrE;;GAEG;AACH,MAAM,MAAM,gBAAgB,GACxB,UAAU,GACV,gBAAgB,GAChB,QAAQ,GACR,OAAO,GACP,UAAU,CAAC;AAEf;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,gBAAgB,CAAC;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,gBAAgB,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,UAAU,CAAC,EAAE,eAAe,EAAE,CAAC;IAC/B,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,CAAC,EAAE,eAAe,EAAE,CAAC;IAC5B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAgCD;;GAEG;AACH,eAAO,MAAM,gBAAgB,yBAK3B,CAAC;AAu3BH;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE;IAC/C,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,GAAG,IAAI,CAAC,iBAAiB,CAAC,CAY1B"}