@compilr-dev/agents-coding-go 0.1.0

package/dist/parser/go-parser.js

@@ -0,0 +1,492 @@
+/**
+ * Go Parser using Tree-sitter
+ *
+ * Provides AST parsing and traversal for Go source files.
+ */
+import Parser from "tree-sitter";
+import Go from "tree-sitter-go";
+import { readFile } from "node:fs/promises";
+// Initialize parser
+const parser = new Parser();
+// Cast to any to work around tree-sitter type mismatches between versions
+parser.setLanguage(Go);
+/**
+ * Parse Go source code
+ */
+export function parseSource(source) {
+    const tree = parser.parse(source);
+    const errors = [];
+    // Find error nodes
+    const findErrors = (node) => {
+        if (node.type === "ERROR" || node.isMissing) {
+            errors.push({
+                message: node.isMissing ? `Missing: ${node.type}` : "Syntax error",
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column,
+            });
+        }
+        for (const child of node.children) {
+            findErrors(child);
+        }
+    };
+    findErrors(tree.rootNode);
+    return {
+        tree,
+        source,
+        hasErrors: errors.length > 0,
+        errors,
+    };
+}
+/**
+ * Parse Go file
+ */
+export async function parseFile(path) {
+    const source = await readFile(path, "utf-8");
+    return parseSource(source);
+}
+/**
+ * Get text from a node
+ */
+export function getNodeText(node, source) {
+    return source.slice(node.startIndex, node.endIndex);
+}
+/**
+ * Extract doc comment from above a declaration
+ * Go uses line comments (//) or block comments before declarations
+ */
+export function extractDocComment(node, source) {
+    // Look for comment nodes immediately before this node
+    const parent = node.parent;
+    if (!parent)
+        return undefined;
+    const nodeIndex = parent.children.indexOf(node);
+    if (nodeIndex <= 0)
+        return undefined;
+    const comments = [];
+    // Collect consecutive comment nodes before this declaration
+    for (let i = nodeIndex - 1; i >= 0; i--) {
+        const sibling = parent.children[i];
+        if (sibling.type === "comment") {
+            const text = getNodeText(sibling, source);
+            // Remove comment markers
+            const cleaned = text
+                .replace(/^\/\/\s?/, "") // Line comment
+                .replace(/^\/\*\s?|\s?\*\/$/g, "") // Block comment
+                .trim();
+            comments.unshift(cleaned);
+        }
+        else {
+            break;
+        }
+    }
+    return comments.length > 0 ? comments.join("\n") : undefined;
+}
+/**
+ * Check if a name is exported (starts with uppercase)
+ */
+export function isExported(name) {
+    return (name.length > 0 &&
+        name[0] === name[0].toUpperCase() &&
+        /[A-Z]/.test(name[0]));
+}
+/**
+ * Parse function parameters
+ */
+export function parseParameters(node, source) {
+    const params = [];
+    // Look for parameter_list
+    const paramList = node.childForFieldName("parameters");
+    if (!paramList)
+        return params;
+    for (const child of paramList.children) {
+        if (child.type === "parameter_declaration") {
+            // Can have multiple names with same type: a, b int
+            const names = [];
+            let typeNode = null;
+            let isVariadic = false;
+            for (const c of child.children) {
+                if (c.type === "identifier") {
+                    names.push(getNodeText(c, source));
+                }
+                else if (c.type === "variadic_parameter_declaration") {
+                    isVariadic = true;
+                    const variadicName = c.children.find((n) => n.type === "identifier");
+                    if (variadicName) {
+                        names.push(getNodeText(variadicName, source));
+                    }
+                    typeNode =
+                        c.children.find((n) => n.type !== "identifier" && n.type !== "," && n.type !== "...") ?? null;
+                }
+                else if (c.type !== "," && c.type !== "(" && c.type !== ")") {
+                    // This is likely the type
+                    typeNode = c;
+                }
+            }
+            const typeName = typeNode ? getNodeText(typeNode, source) : undefined;
+            for (const name of names) {
+                params.push({
+                    name,
+                    type: typeName,
+                    isArgs: isVariadic,
+                    isKwargs: false,
+                    isPositionalOnly: false,
+                    isKeywordOnly: false,
+                });
+            }
+        }
+        else if (child.type === "variadic_parameter_declaration") {
+            const nameNode = child.children.find((c) => c.type === "identifier");
+            const typeNode = child.children.find((c) => c.type !== "identifier" && c.type !== "...");
+            if (nameNode) {
+                params.push({
+                    name: getNodeText(nameNode, source),
+                    type: typeNode ? getNodeText(typeNode, source) : undefined,
+                    isArgs: true,
+                    isKwargs: false,
+                    isPositionalOnly: false,
+                    isKeywordOnly: false,
+                });
+            }
+        }
+    }
+    return params;
+}
+/**
+ * Parse return types (Go supports multiple return values)
+ */
+export function parseReturnTypes(node, source) {
+    const resultNode = node.childForFieldName("result");
+    if (!resultNode)
+        return undefined;
+    return getNodeText(resultNode, source);
+}
+/**
+ * Parse a function declaration
+ */
+export function parseFunction(node, source) {
+    const nameNode = node.childForFieldName("name");
+    const name = nameNode ? getNodeText(nameNode, source) : "";
+    return {
+        name,
+        line: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1,
+        column: node.startPosition.column,
+        parameters: parseParameters(node, source),
+        returnType: parseReturnTypes(node, source),
+        decorators: [], // Go doesn't have decorators
+        isAsync: false, // Go uses goroutines, not async/await
+        isGenerator: false, // Go doesn't have generators
+        docstring: extractDocComment(node, source),
+        isExported: isExported(name),
+    };
+}
+/**
+ * Parse a method declaration (function with receiver)
+ */
+export function parseMethod(node, source) {
+    const func = parseFunction(node, source);
+    // Get receiver info
+    const receiverNode = node.childForFieldName("receiver");
+    let receiverType;
+    let isPointerReceiver = false;
+    if (receiverNode) {
+        // receiver is parameter_list with one param
+        for (const child of receiverNode.children) {
+            if (child.type === "parameter_declaration") {
+                const typeNode = child.children.find((c) => c.type === "pointer_type" ||
+                    c.type === "type_identifier" ||
+                    c.type === "qualified_type");
+                if (typeNode) {
+                    if (typeNode.type === "pointer_type") {
+                        isPointerReceiver = true;
+                        const innerType = typeNode.children.find((c) => c.type === "type_identifier");
+                        receiverType = innerType
+                            ? getNodeText(innerType, source)
+                            : getNodeText(typeNode, source);
+                    }
+                    else {
+                        receiverType = getNodeText(typeNode, source);
+                    }
+                }
+            }
+        }
+    }
+    return {
+        ...func,
+        isClassMethod: false,
+        isStaticMethod: false,
+        isProperty: false,
+        isAbstract: false,
+        receiverType,
+        isPointerReceiver,
+    };
+}
+/**
+ * Parse a type declaration (struct or interface)
+ * We treat these as "classes" for compatibility with the tool interface
+ */
+export function parseClass(node, source) {
+    // node is type_declaration, which contains type_spec
+    const typeSpec = node.children.find((c) => c.type === "type_spec");
+    if (!typeSpec) {
+        return {
+            name: "",
+            line: node.startPosition.row + 1,
+            endLine: node.endPosition.row + 1,
+            column: node.startPosition.column,
+            bases: [],
+            decorators: [],
+            methods: [],
+            attributes: [],
+            isAbstract: false,
+            isDataclass: false,
+        };
+    }
+    const nameNode = typeSpec.childForFieldName("name");
+    const name = nameNode ? getNodeText(nameNode, source) : "";
+    const typeNode = typeSpec.childForFieldName("type");
+    const isInterface = typeNode?.type === "interface_type";
+    const isStruct = typeNode?.type === "struct_type";
+    const methods = [];
+    const attributes = [];
+    const bases = []; // embedded types
+    if (typeNode && isStruct) {
+        // Parse struct fields
+        const fieldList = typeNode.children.find((c) => c.type === "field_declaration_list");
+        if (fieldList) {
+            for (const field of fieldList.children) {
+                if (field.type === "field_declaration") {
+                    const fieldNames = [];
+                    let fieldType;
+                    let tag;
+                    for (const c of field.children) {
+                        if (c.type === "field_identifier") {
+                            fieldNames.push(getNodeText(c, source));
+                        }
+                        else if (c.type === "raw_string_literal" ||
+                            c.type === "interpreted_string_literal") {
+                            tag = getNodeText(c, source);
+                        }
+                        else if (c.type !== "," &&
+                            c.type !== "(" &&
+                            c.type !== ")" &&
+                            fieldNames.length > 0) {
+                            fieldType = getNodeText(c, source);
+                        }
+                        else if (c.type === "type_identifier" ||
+                            c.type === "qualified_type") {
+                            // Embedded type (anonymous field)
+                            bases.push(getNodeText(c, source));
+                        }
+                    }
+                    for (const fieldName of fieldNames) {
+                        attributes.push({
+                            name: fieldName,
+                            type: fieldType,
+                            line: field.startPosition.row + 1,
+                            isClassAttribute: true,
+                            isExported: isExported(fieldName),
+                            tag,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    else if (typeNode && isInterface) {
+        // Parse interface methods
+        const methodSpecs = typeNode.children.find((c) => c.type === "method_spec_list" || c.type === "interface_type");
+        if (methodSpecs) {
+            for (const spec of methodSpecs.children) {
+                if (spec.type === "method_spec") {
+                    const methodName = spec.childForFieldName("name");
+                    if (methodName) {
+                        methods.push({
+                            name: getNodeText(methodName, source),
+                            line: spec.startPosition.row + 1,
+                            endLine: spec.endPosition.row + 1,
+                            column: spec.startPosition.column,
+                            parameters: [],
+                            decorators: [],
+                            isAsync: false,
+                            isGenerator: false,
+                            isClassMethod: false,
+                            isStaticMethod: false,
+                            isProperty: false,
+                            isAbstract: true, // Interface methods are abstract
+                        });
+                    }
+                }
+                else if (spec.type === "type_identifier" ||
+                    spec.type === "qualified_type") {
+                    // Embedded interface
+                    bases.push(getNodeText(spec, source));
+                }
+            }
+        }
+    }
+    return {
+        name,
+        line: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1,
+        column: node.startPosition.column,
+        bases,
+        decorators: [],
+        methods,
+        attributes,
+        docstring: extractDocComment(node, source),
+        isAbstract: isInterface,
+        isDataclass: false,
+        isInterface,
+        isStruct,
+        isExported: isExported(name),
+    };
+}
+/**
+ * Parse import declaration
+ */
+export function parseImport(node, source) {
+    const imports = [];
+    // import "fmt" or import ( "fmt" ... )
+    const importSpecs = findNodes(node, (n) => n.type === "import_spec");
+    for (const spec of importSpecs) {
+        const pathNode = spec.children.find((c) => c.type === "interpreted_string_literal");
+        const aliasNode = spec.childForFieldName("name");
+        if (pathNode) {
+            const path = getNodeText(pathNode, source).replace(/"/g, "");
+            const alias = aliasNode ? getNodeText(aliasNode, source) : undefined;
+            // Determine import type
+            const isBlank = alias === "_";
+            const isDot = alias === ".";
+            imports.push({
+                module: path,
+                names: [{ name: path, alias: isBlank || isDot ? undefined : alias }],
+                line: spec.startPosition.row + 1,
+                isFromImport: false,
+                isRelative: false,
+                relativeDots: 0,
+                isBlankImport: isBlank,
+                isDotImport: isDot,
+            });
+        }
+    }
+    return imports;
+}
+/**
+ * Parse variable/constant declaration
+ */
+export function parseVariable(node, source) {
+    const vars = [];
+    // Look for var_spec or const_spec
+    const specs = findNodes(node, (n) => n.type === "var_spec" || n.type === "const_spec");
+    for (const spec of specs) {
+        const names = [];
+        let typeNode = null;
+        let valueNode = null;
+        const isConst = spec.type === "const_spec";
+        for (const child of spec.children) {
+            if (child.type === "identifier") {
+                names.push(getNodeText(child, source));
+            }
+            else if (child.type === "expression_list") {
+                valueNode = child;
+            }
+            else if (child.type !== "," &&
+                child.type !== "=" &&
+                !names.includes(getNodeText(child, source))) {
+                // Likely type
+                typeNode = child;
+            }
+        }
+        const typeName = typeNode ? getNodeText(typeNode, source) : undefined;
+        const value = valueNode ? getNodeText(valueNode, source) : undefined;
+        for (const name of names) {
+            vars.push({
+                name,
+                type: typeName,
+                value,
+                line: spec.startPosition.row + 1,
+                column: spec.startPosition.column,
+                isConstant: isConst,
+                isExported: isExported(name),
+            });
+        }
+    }
+    return vars;
+}
+/**
+ * Get package name from source file
+ */
+export function getPackageName(tree, source) {
+    const packageClause = tree.rootNode.children.find((c) => c.type === "package_clause");
+    if (!packageClause)
+        return undefined;
+    const nameNode = packageClause.children.find((c) => c.type === "package_identifier");
+    return nameNode ? getNodeText(nameNode, source) : undefined;
+}
+/**
+ * Walk the AST and collect all nodes of given types
+ */
+export function* walkTree(node, types) {
+    if (!types || types.includes(node.type)) {
+        yield node;
+    }
+    for (const child of node.children) {
+        yield* walkTree(child, types);
+    }
+}
+/**
+ * Find all nodes matching a predicate
+ */
+export function findNodes(node, predicate) {
+    const results = [];
+    const walk = (n) => {
+        if (predicate(n)) {
+            results.push(n);
+        }
+        for (const child of n.children) {
+            walk(child);
+        }
+    };
+    walk(node);
+    return results;
+}
+/**
+ * Get the containing scope for a node (function or type)
+ */
+export function getContainingScope(node) {
+    let current = node.parent;
+    while (current) {
+        if (current.type === "function_declaration" ||
+            current.type === "method_declaration") {
+            const nameNode = current.childForFieldName("name");
+            return {
+                type: "function",
+                name: nameNode?.text ?? "",
+                node: current,
+            };
+        }
+        if (current.type === "type_declaration") {
+            const typeSpec = current.children.find((c) => c.type === "type_spec");
+            const nameNode = typeSpec?.childForFieldName("name");
+            return {
+                type: "class",
+                name: nameNode?.text ?? "",
+                node: current,
+            };
+        }
+        current = current.parent;
+    }
+    return null;
+}
+/**
+ * Parse decorators - Go doesn't have decorators, returns empty array
+ * This is a compatibility function for tools that expect this export
+ */
+export function parseDecorators(_node, _source) {
+    return [];
+}
+/**
+ * Alias for extractDocComment for compatibility with tools expecting Python-style docstring extraction
+ */
+export const extractDocstring = extractDocComment;

package/dist/parser/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Go Parser exports
+ */
+export * from "./go-parser.js";
+export * from "./node-types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/parser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/parser/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC"}

package/dist/parser/index.js

@@ -0,0 +1,5 @@
+/**
+ * Go Parser exports
+ */
+export * from "./go-parser.js";
+export * from "./node-types.js";

package/dist/parser/node-types.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Go AST node type definitions for Tree-sitter
+ */
+/**
+ * Go AST node types from tree-sitter-go
+ */
+export type GoNodeType = "source_file" | "package_clause" | "import_declaration" | "import_spec" | "import_spec_list" | "function_declaration" | "method_declaration" | "type_declaration" | "type_spec" | "const_declaration" | "var_declaration" | "const_spec" | "var_spec" | "struct_type" | "interface_type" | "map_type" | "slice_type" | "array_type" | "channel_type" | "pointer_type" | "function_type" | "type_identifier" | "qualified_type" | "block" | "expression_statement" | "return_statement" | "if_statement" | "for_statement" | "switch_statement" | "type_switch_statement" | "select_statement" | "defer_statement" | "go_statement" | "assignment_statement" | "short_var_declaration" | "identifier" | "int_literal" | "float_literal" | "imaginary_literal" | "rune_literal" | "interpreted_string_literal" | "raw_string_literal" | "true" | "false" | "nil" | "binary_expression" | "unary_expression" | "call_expression" | "selector_expression" | "index_expression" | "slice_expression" | "type_assertion_expression" | "type_conversion_expression" | "composite_literal" | "func_literal" | "parameter_list" | "parameter_declaration" | "variadic_parameter_declaration" | "field_declaration" | "field_declaration_list" | "method_spec" | "method_spec_list" | "comment" | "blank_identifier";
+/**
+ * Decorator information (Go doesn't have decorators, kept for interface compatibility)
+ */
+export interface DecoratorInfo {
+    name: string;
+    arguments?: string[];
+    line: number;
+}
+/**
+ * Parameter information
+ */
+export interface ParameterInfo {
+    name: string;
+    type?: string;
+    default?: string;
+    isArgs: boolean;
+    isKwargs: boolean;
+    isPositionalOnly: boolean;
+    isKeywordOnly: boolean;
+}
+/**
+ * Function/method information
+ */
+export interface FunctionInfo {
+    name: string;
+    line: number;
+    endLine: number;
+    column: number;
+    parameters: ParameterInfo[];
+    returnType?: string;
+    decorators: DecoratorInfo[];
+    isAsync: boolean;
+    isGenerator: boolean;
+    docstring?: string;
+    body?: string;
+    isExported?: boolean;
+}
+/**
+ * Method information (function with receiver)
+ */
+export interface MethodInfo extends FunctionInfo {
+    isClassMethod: boolean;
+    isStaticMethod: boolean;
+    isProperty: boolean;
+    isAbstract: boolean;
+    receiverType?: string;
+    isPointerReceiver?: boolean;
+}
+/**
+ * Attribute/field information
+ */
+export interface AttributeInfo {
+    name: string;
+    type?: string;
+    default?: string;
+    line: number;
+    isClassAttribute: boolean;
+    isExported?: boolean;
+    tag?: string;
+}
+/**
+ * Type information (struct or interface)
+ */
+export interface ClassInfo {
+    name: string;
+    line: number;
+    endLine: number;
+    column: number;
+    bases: string[];
+    decorators: DecoratorInfo[];
+    methods: MethodInfo[];
+    attributes: AttributeInfo[];
+    docstring?: string;
+    isAbstract: boolean;
+    isDataclass: boolean;
+    isInterface?: boolean;
+    isStruct?: boolean;
+    isExported?: boolean;
+}
+/**
+ * Variable/constant information
+ */
+export interface VariableInfo {
+    name: string;
+    type?: string;
+    value?: string;
+    line: number;
+    column: number;
+    isConstant: boolean;
+    isExported?: boolean;
+}
+/**
+ * Import information
+ */
+export interface ImportInfo {
+    module: string;
+    names: Array<{
+        name: string;
+        alias?: string;
+    }>;
+    alias?: string;
+    line: number;
+    isFromImport: boolean;
+    isRelative: boolean;
+    relativeDots: number;
+    isBlankImport?: boolean;
+    isDotImport?: boolean;
+}
+/**
+ * Position in source code
+ */
+export interface Position {
+    line: number;
+    column: number;
+}
+/**
+ * Range in source code
+ */
+export interface Range {
+    start: Position;
+    end: Position;
+}
+//# sourceMappingURL=node-types.d.ts.map

package/dist/parser/node-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-types.d.ts","sourceRoot":"","sources":["../../src/parser/node-types.ts"],"names":[],"mappings":"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"}

package/dist/parser/node-types.js

@@ -0,0 +1,4 @@
+/**
+ * Go AST node type definitions for Tree-sitter
+ */
+export {};

package/dist/skills/go-best-practices.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Go Best Practices Skill
+ *
+ * Provides guidance for Go-specific coding patterns and analysis.
+ */
+export declare const goBestPracticesSkill: import("@compilr-dev/agents").Skill;
+//# sourceMappingURL=go-best-practices.d.ts.map

package/dist/skills/go-best-practices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"go-best-practices.d.ts","sourceRoot":"","sources":["../../src/skills/go-best-practices.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,eAAO,MAAM,oBAAoB,qCAuE/B,CAAC"}