cmdop-coder 0.1.1__py3-none-any.whl

cmdop_coder/__init__.py

@@ -0,0 +1,28 @@
+"""cmdop-coder — code analysis skill using tree-sitter AST parsing."""
+
+from cmdop_coder._analysis import analyze_file, extract_functions, find_symbol, get_outline
+from cmdop_coder._models import (
+    AnalyzeResult,
+    FunctionInfo,
+    FunctionsResult,
+    OutlineItem,
+    OutlineResult,
+    SymbolMatch,
+    SymbolsResult,
+)
+from cmdop_coder._skill import skill
+
+__all__ = [
+    "AnalyzeResult",
+    "FunctionInfo",
+    "FunctionsResult",
+    "OutlineItem",
+    "OutlineResult",
+    "SymbolMatch",
+    "SymbolsResult",
+    "analyze_file",
+    "extract_functions",
+    "find_symbol",
+    "get_outline",
+    "skill",
+]

cmdop_coder/_analysis.py

@@ -0,0 +1,191 @@
+"""Code analysis functions using tree-sitter AST."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ._models import (
+    AnalyzeResult,
+    FunctionInfo,
+    FunctionsResult,
+    OutlineItem,
+    OutlineResult,
+    SymbolMatch,
+    SymbolsResult,
+)
+from ._parser import detect_language, parse_file
+
+# Node types that represent function/method definitions per language
+_FUNCTION_NODES: dict[str, list[str]] = {
+    "python":     ["function_definition", "async_function_definition"],
+    "javascript": ["function_declaration", "arrow_function", "method_definition", "function_expression"],
+    "typescript": ["function_declaration", "arrow_function", "method_definition", "function_expression"],
+    "tsx":        ["function_declaration", "arrow_function", "method_definition", "function_expression"],
+    "go":         ["function_declaration", "method_declaration"],
+    "rust":       ["function_item"],
+    "java":       ["method_declaration", "constructor_declaration"],
+    "c":          ["function_definition"],
+    "cpp":        ["function_definition"],
+    "ruby":       ["method", "singleton_method"],
+    "php":        ["function_definition", "method_declaration"],
+    "swift":      ["function_declaration"],
+    "kotlin":     ["function_declaration"],
+    "c_sharp":    ["method_declaration", "constructor_declaration"],
+    "lua":        ["function_definition", "local_function"],
+    "scala":      ["function_definition"],
+    "elixir":     ["def", "defp"],
+}
+
+# Node types for outline (structural elements) per language
+_OUTLINE_NODES: dict[str, list[str]] = {
+    "python":     ["import_statement", "import_from_statement", "class_definition",
+                   "function_definition", "async_function_definition"],
+    "javascript": ["import_declaration", "class_declaration", "function_declaration",
+                   "lexical_declaration", "variable_declaration"],
+    "typescript": ["import_declaration", "class_declaration", "function_declaration",
+                   "interface_declaration", "type_alias_declaration", "enum_declaration"],
+    "tsx":        ["import_declaration", "class_declaration", "function_declaration",
+                   "interface_declaration", "type_alias_declaration"],
+    "go":         ["import_declaration", "type_declaration", "function_declaration",
+                   "method_declaration", "var_declaration", "const_declaration"],
+    "rust":       ["use_declaration", "struct_item", "enum_item", "function_item",
+                   "impl_item", "trait_item", "mod_item"],
+    "java":       ["import_declaration", "class_declaration", "interface_declaration",
+                   "method_declaration"],
+    "c":          ["preproc_include", "struct_specifier", "function_definition", "type_definition"],
+    "cpp":        ["preproc_include", "class_specifier", "struct_specifier",
+                   "function_definition", "namespace_definition"],
+}
+
+_IDENTIFIER_TYPES = frozenset({
+    "identifier", "name", "property_identifier",
+    "type_identifier", "field_identifier",
+})
+
+
+def _node_name(node: object, source: bytes) -> str:
+    """Extract the name identifier text from an AST node."""
+    for child in node.children:  # type: ignore[union-attr]
+        if child.type in _IDENTIFIER_TYPES:
+            return source[child.start_byte:child.end_byte].decode(errors="replace")
+    raw = source[node.start_byte:node.start_byte + 60]  # type: ignore[union-attr]
+    return raw.decode(errors="replace").split("\n")[0]
+
+
+def _collect_nodes(node: object, types: frozenset[str], depth: int = 0, max_depth: int = 20) -> list[object]:
+    """Walk AST and collect nodes matching the given types."""
+    if depth > max_depth:
+        return []
+    results: list[object] = []
+    if node.type in types:  # type: ignore[union-attr]
+        results.append(node)
+    for child in node.children:  # type: ignore[union-attr]
+        results.extend(_collect_nodes(child, types, depth + 1, max_depth))
+    return results
+
+
+def _first_line(node: object, source: bytes) -> str:
+    """Return the first line of a node's source text, truncated to 120 chars."""
+    raw = source[node.start_byte:node.end_byte]  # type: ignore[union-attr]
+    return raw.decode(errors="replace").split("\n")[0][:120]
+
+
+def extract_functions(path: str | Path) -> FunctionsResult:
+    """Extract function/method signatures with line numbers from a source file."""
+    tree, source, lang = parse_file(path)
+    types = frozenset(_FUNCTION_NODES.get(lang, ["function_definition", "function_declaration"]))
+    nodes = _collect_nodes(tree.root_node, types)  # type: ignore[union-attr]
+
+    functions = [
+        FunctionInfo(
+            line=node.start_point[0] + 1,  # type: ignore[union-attr]
+            name=_node_name(node, source),
+            signature=_first_line(node, source),
+        )
+        for node in nodes
+    ]
+    return FunctionsResult(file=str(path), language=lang, count=len(functions), functions=functions)
+
+
+def find_symbol(symbol: str, path: str | Path = ".") -> SymbolsResult:
+    """Find all occurrences of a symbol across source files."""
+    p = Path(path)
+    candidates = [p] if p.is_file() else list(p.rglob("*"))
+    matches: list[SymbolMatch] = []
+
+    for f in candidates:
+        if not f.is_file() or detect_language(f) is None:
+            continue
+        try:
+            lines = f.read_bytes().decode(errors="replace").splitlines()
+        except OSError:
+            continue
+        for i, line in enumerate(lines, 1):
+            if symbol in line:
+                matches.append(SymbolMatch(file=str(f), line=i, text=line.strip()))
+
+    return SymbolsResult(symbol=symbol, count=len(matches), matches=matches)
+
+
+def get_outline(path: str | Path) -> OutlineResult:
+    """Get structural outline of a source file (imports, classes, functions, types)."""
+    tree, source, lang = parse_file(path)
+    types = frozenset(_OUTLINE_NODES.get(lang, []))
+
+    if not types:
+        items = _fallback_outline(tree.root_node, source)  # type: ignore[union-attr]
+        return OutlineResult(file=str(path), language=lang, count=len(items), outline=items)
+
+    nodes = _collect_nodes(tree.root_node, types, max_depth=3)  # type: ignore[union-attr]
+    items = [
+        OutlineItem(
+            line=node.start_point[0] + 1,  # type: ignore[union-attr]
+            type=node.type,  # type: ignore[union-attr]
+            name=_node_name(node, source),
+        )
+        for node in nodes
+    ]
+    return OutlineResult(file=str(path), language=lang, count=len(items), outline=items)
+
+
+def _fallback_outline(root: object, source: bytes) -> list[OutlineItem]:
+    """Return top-level nodes as outline when language has no specific config."""
+    return [
+        OutlineItem(
+            line=child.start_point[0] + 1,  # type: ignore[union-attr]
+            type=child.type,  # type: ignore[union-attr]
+            name=_first_line(child, source)[:60],
+        )
+        for child in root.children  # type: ignore[union-attr]
+    ]
+
+
+def analyze_file(path: str | Path) -> AnalyzeResult:
+    """Analyze a source file: language detection, line counts, function count."""
+    p = Path(path)
+    source = p.read_bytes()
+    lang = detect_language(p)
+    lines = source.decode(errors="replace").splitlines()
+
+    blank = sum(1 for ln in lines if not ln.strip())
+    comment = sum(1 for ln in lines if ln.strip().startswith(("#", "//", "/*", "*")))
+    code = len(lines) - blank - comment
+
+    function_count: int | None = None
+    if lang and lang in _FUNCTION_NODES:
+        try:
+            function_count = extract_functions(p).count
+        except Exception:
+            pass
+
+    return AnalyzeResult(
+        file=str(p),
+        language=lang or "unknown",
+        extension=p.suffix,
+        size_bytes=len(source),
+        total_lines=len(lines),
+        code_lines=code,
+        blank_lines=blank,
+        comment_lines=comment,
+        function_count=function_count,
+    )

cmdop_coder/_models.py

@@ -0,0 +1,67 @@
+"""Data models for cmdop-coder results."""
+
+from pydantic import BaseModel
+
+
+class FunctionInfo(BaseModel):
+    """A single function or method extracted from source code."""
+
+    line: int
+    name: str
+    signature: str
+
+
+class FunctionsResult(BaseModel):
+    """Result of extracting functions from a file."""
+
+    file: str
+    language: str
+    count: int
+    functions: list[FunctionInfo]
+
+
+class SymbolMatch(BaseModel):
+    """A single occurrence of a symbol in source code."""
+
+    file: str
+    line: int
+    text: str
+
+
+class SymbolsResult(BaseModel):
+    """Result of searching for a symbol across files."""
+
+    symbol: str
+    count: int
+    matches: list[SymbolMatch]
+
+
+class OutlineItem(BaseModel):
+    """A structural element in a source file outline."""
+
+    line: int
+    type: str
+    name: str
+
+
+class OutlineResult(BaseModel):
+    """Result of generating a structural outline for a file."""
+
+    file: str
+    language: str
+    count: int
+    outline: list[OutlineItem]
+
+
+class AnalyzeResult(BaseModel):
+    """Statistics for a source file."""
+
+    file: str
+    language: str
+    extension: str
+    size_bytes: int
+    total_lines: int
+    code_lines: int
+    blank_lines: int
+    comment_lines: int
+    function_count: int | None = None

cmdop_coder/_parser.py

@@ -0,0 +1,76 @@
+"""Tree-sitter parser utilities."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+# Language detection by file extension
+_EXT_TO_LANG: dict[str, str] = {
+    ".py": "python",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".ts": "typescript",
+    ".tsx": "tsx",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".c": "c",
+    ".h": "c",
+    ".cpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".hpp": "cpp",
+    ".rb": "ruby",
+    ".php": "php",
+    ".swift": "swift",
+    ".kt": "kotlin",
+    ".cs": "c_sharp",
+    ".css": "css",
+    ".html": "html",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".toml": "toml",
+    ".sh": "bash",
+    ".bash": "bash",
+    ".sql": "sql",
+    ".lua": "lua",
+    ".r": "r",
+    ".scala": "scala",
+    ".ex": "elixir",
+    ".exs": "elixir",
+    ".elm": "elm",
+    ".hs": "haskell",
+    ".ml": "ocaml",
+    ".tf": "hcl",
+}
+
+
+def detect_language(path: str | Path) -> str | None:
+    """Detect tree-sitter language name from file path."""
+    p = Path(path)
+    name = p.name.lower()
+    if name == "dockerfile" or name.startswith("dockerfile."):
+        return "dockerfile"
+    return _EXT_TO_LANG.get(p.suffix.lower())
+
+
+def get_parser(language: str) -> object:
+    """Return a tree-sitter parser for the given language name."""
+    try:
+        from tree_sitter_language_pack import get_parser as _get_parser  # type: ignore[import]
+        return _get_parser(language)
+    except Exception as e:
+        raise RuntimeError(f"Cannot load tree-sitter parser for {language!r}: {e}") from e
+
+
+def parse_file(path: str | Path) -> tuple[object, bytes, str]:
+    """Parse a source file, returning (tree, source_bytes, language)."""
+    p = Path(path)
+    lang = detect_language(p)
+    if lang is None:
+        raise ValueError(f"Unsupported file type: {p.suffix!r}")
+    source = p.read_bytes()
+    parser = get_parser(lang)
+    tree = parser.parse(source)  # type: ignore[union-attr]
+    return tree, source, lang

cmdop_coder/_skill.py

@@ -0,0 +1,45 @@
+"""cmdop-coder CMDOP skill — code analysis with tree-sitter AST."""
+
+from cmdop_skill import Arg, Skill
+
+from cmdop_coder._analysis import analyze_file, extract_functions, find_symbol, get_outline
+
+skill = Skill()
+
+
+@skill.command
+def functions(
+    path: str = Arg(help="Path to source file", required=True),
+) -> dict:
+    """Extract function/method signatures with line numbers."""
+    return extract_functions(path).model_dump()
+
+
+@skill.command
+def symbols(
+    symbol: str = Arg(help="Symbol name to find", required=True),
+    path: str = Arg("--path", default=".", help="File or directory to search (default: current dir)"),
+) -> dict:
+    """Find all occurrences of a symbol across source files."""
+    return find_symbol(symbol, path).model_dump()
+
+
+@skill.command
+def outline(
+    path: str = Arg(help="Path to source file", required=True),
+) -> dict:
+    """Get structural outline: imports, classes, functions, types."""
+    return get_outline(path).model_dump()
+
+
+@skill.command
+def analyze(
+    path: str = Arg(help="Path to source file", required=True),
+) -> dict:
+    """Analyze a file: language, line counts, function count."""
+    return analyze_file(path).model_dump()
+
+
+def main() -> None:
+    """CLI entry point."""
+    skill.run()

cmdop_coder-0.1.1.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: cmdop-coder
+Version: 0.1.1
+Summary: CMDOP skill — code analysis with tree-sitter AST parsing
+Project-URL: Homepage, https://cmdop.com/skills/cmdop-coder/
+Author-email: CMDOP Team <team@cmdop.com>
+License-Expression: MIT
+Keywords: ast,cmdop,code,skill,tree-sitter
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: cmdop
+Requires-Dist: cmdop-skill
+Requires-Dist: pydantic>=2.0
+Requires-Dist: tree-sitter-language-pack>=0.1
+Requires-Dist: tree-sitter>=0.21
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# cmdop-coder
+
+> **[CMDOP Skill](https://cmdop.com/skills/cmdop-coder/)** — install and use via [CMDOP agent](https://cmdop.com):
+> ```
+> cmdop-skill install cmdop-coder
+> ```
+
+Code analysis using tree-sitter AST parsing. Extract functions, find symbols, get structural outlines. Supports 40+ languages.
+
+## Install
+
+```bash
+pip install cmdop-coder
+```
+
+Or as a CMDOP skill:
+
+```bash
+cmdop-skill install path/to/cmdop-coder
+```
+
+## CLI
+
+### Extract functions
+
+```bash
+cmdop-coder functions --path src/main.py
+```
+
+```json
+{
+  "file": "src/main.py",
+  "language": "python",
+  "count": 3,
+  "functions": [
+    {"line": 5, "name": "hello", "signature": "def hello(name: str) -> str:"},
+    {"line": 9, "name": "fetch", "signature": "async def fetch(url: str) -> bytes:"}
+  ]
+}
+```
+
+### Find symbol
+
+```bash
+cmdop-coder symbols --symbol MyClass --path ./src
+```
+
+### Structural outline
+
+```bash
+cmdop-coder outline --path internal/agent/core/agent.go
+```
+
+### File statistics
+
+```bash
+cmdop-coder analyze --path service.py
+```
+
+## Python API
+
+```python
+from cmdop_coder import extract_functions, find_symbol, get_outline, analyze_file
+
+# Extract all functions from a file
+result = extract_functions("src/main.py")
+for fn in result.functions:
+    print(fn.line, fn.name, fn.signature)
+
+# Find symbol across a directory
+matches = find_symbol("MyClass", "./src")
+for m in matches.matches:
+    print(m.file, m.line, m.text)
+
+# Structural outline
+outline = get_outline("main.go")
+for item in outline.outline:
+    print(item.line, item.type, item.name)
+
+# File statistics
+stats = analyze_file("service.py")
+print(stats.language, stats.total_lines, stats.function_count)
+```
+
+## Supported Languages
+
+Go, Python, JavaScript, TypeScript, TSX, Rust, Java, C, C++, Ruby, PHP,
+Swift, Kotlin, C#, CSS, HTML, JSON, YAML, TOML, Bash, SQL, Lua, Scala,
+Elixir, Elm, Haskell, OCaml, HCL, Dockerfile and more.

cmdop_coder-0.1.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+cmdop_coder/__init__.py,sha256=HuOe8Snmf-KFnBlZ4SYAUQDHJF27yHWm6q2AXQau6gQ,624
+cmdop_coder/_analysis.py,sha256=dB3TFUTFhe-p6ZseGdFW7o1c_Eu-S82Br4PK6FCmPiY,7943
+cmdop_coder/_models.py,sha256=sA0fBTEfm9-64KB6Qn17jX1rjGI5MIwvWNehI6pisO8,1259
+cmdop_coder/_parser.py,sha256=lm0JOsZMaAAldA3S38An2d6RYI-ZaC_eC2EwjwXAXqo,2003
+cmdop_coder/_skill.py,sha256=oL2KCj3z6e5Wrd3u5cHKHDHburSTInd5nuWzWpwNk7c,1254
+cmdop_coder-0.1.1.dist-info/METADATA,sha256=u3zXfQLP4N1AjFrcbLslpVsenNS8nsJWrPx25mYccBo,2954
+cmdop_coder-0.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+cmdop_coder-0.1.1.dist-info/entry_points.txt,sha256=ikr1Pfh1IWXbvxPXhkICjAZ2DLWx4VFqkf6EJPX-ZAI,56
+cmdop_coder-0.1.1.dist-info/RECORD,,

cmdop_coder-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cmdop_coder-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cmdop-coder = cmdop_coder._skill:main