cmdop-coder 0.1.1__tar.gz

cmdop_coder-0.1.1/.gitignore

@@ -0,0 +1,43 @@
+# Logs
+.benchmarks
+
+# Dependencies
+node_modules/
+.pnpm-store/
+**/node_modules/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+.venv/
+venv/
+.pytest_cache/
+
+# Go
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Build outputs
+dist/
+build/
+*.egg-info/
+
+# Temporary files
+*.log
+*.tmp
+.env.local

cmdop_coder-0.1.1/Makefile

@@ -0,0 +1,32 @@
+PYTHON := uv run --python .venv python
+
+.PHONY: help install test lint install-skill publish release
+
+help:
+	@echo "cmdop-coder"
+	@echo ""
+	@echo "  make install        Create venv and install in development mode"
+	@echo "  make test           Run tests"
+	@echo "  make lint           Run linter"
+	@echo "  make install-skill  Register skill via cmdop-skill install"
+	@echo "  make publish        Publish skill to CMDOP marketplace"
+	@echo "  make release        Bump + build + upload to PyPI"
+
+install:
+	uv venv
+	uv pip install --python .venv -e '.[dev]'
+
+test:
+	$(PYTHON) -m pytest tests/ -v
+
+lint:
+	$(PYTHON) -m ruff check src/
+
+install-skill:
+	cmdop-skill install .
+
+publish:
+	cmdop-skill publish --path .
+
+release:
+	cmdop-skill release .

cmdop_coder-0.1.1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,89 @@
+# 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/pyproject.toml

@@ -0,0 +1,61 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "cmdop-coder"
+version = "0.1.1"
+description = "CMDOP skill — code analysis with tree-sitter AST parsing"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "CMDOP Team", email = "team@cmdop.com" }
+]
+keywords = ["cmdop", "skill", "code", "ast", "tree-sitter"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+dependencies = [
+    "cmdop",
+    "cmdop-skill",
+    "pydantic>=2.0",
+    "tree-sitter>=0.21",
+    "tree-sitter-language-pack>=0.1",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "pytest-cov>=4.0.0",
+    "ruff>=0.1.0",
+]
+
+[project.scripts]
+cmdop-coder = "cmdop_coder._skill:main"
+
+[project.urls]
+Homepage = "https://cmdop.com/skills/cmdop-coder/"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/cmdop_coder"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W", "UP", "B", "C4", "SIM"]
+ignore = ["E501"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

cmdop_coder-0.1.1/skill/config.py

@@ -0,0 +1,6 @@
+from cmdop_skill import SkillCategory, SkillConfig
+
+config = SkillConfig(
+    category=SkillCategory.DEVELOPMENT,
+    visibility="public",
+)

cmdop_coder-0.1.1/skill/readme.md

@@ -0,0 +1,24 @@
+# cmdop-coder
+
+Code analysis skill using tree-sitter AST parsing. Supports 40+ languages.
+
+## Commands
+
+- `functions --path <FILE>` — extract function/method signatures with line numbers
+- `symbols --symbol <NAME> [--path <DIR>]` — find all occurrences of a symbol
+- `outline --path <FILE>` — structural outline (imports, classes, functions, types)
+- `analyze --path <FILE>` — file statistics (lines, complexity, language)
+
+## Usage
+
+```
+cmdop-coder functions --path src/main.py
+cmdop-coder symbols --symbol MyClass --path ./src
+cmdop-coder outline --path internal/agent/core/agent.go
+cmdop-coder analyze --path package.json
+```
+
+## Supported Languages
+
+Go, Python, JavaScript, TypeScript, Rust, Java, C, C++, Ruby, PHP, Swift,
+Kotlin, C#, CSS, HTML, JSON, YAML, TOML, Bash, SQL, and more.

cmdop_coder-0.1.1/src/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-0.1.1/src/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-0.1.1/src/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