codebatch 0.1.0__py3-none-any.whl

codebatch/tasks/symbols.py

@@ -0,0 +1,223 @@
+"""Symbols task executor - extracts symbol tables and edges from AST.
+
+Emits:
+- kind=symbol: Per-file symbol definitions (functions, classes, variables)
+- kind=edge: Import/reference relationships
+
+Inputs:
+- Parse outputs (kind=ast) via iter_prior_outputs
+
+This task consumes AST from 01_parse and produces a compact symbol table.
+Files without AST are skipped (no symbols emitted).
+"""
+
+import json
+from typing import Iterable, Optional
+
+from ..runner import ShardRunner
+
+
+def extract_python_symbols(ast_data: dict, path: str) -> tuple[list[dict], list[dict]]:
+    """Extract symbols and edges from Python AST data.
+
+    Args:
+        ast_data: Parsed AST dict from parse task.
+        path: Source file path.
+
+    Returns:
+        Tuple of (symbols, edges).
+    """
+    symbols = []
+    edges = []
+
+    # Get body nodes from summary AST
+    body = ast_data.get("body", [])
+
+    for node in body:
+        node_type = node.get("type", "")
+        lineno = node.get("lineno")
+        col = node.get("col_offset", 0)
+
+        # Function definitions
+        if node_type == "FunctionDef" or node_type == "AsyncFunctionDef":
+            symbols.append({
+                "kind": "symbol",
+                "path": path,
+                "name": f"function_{lineno}",  # Name not in summary AST
+                "symbol_type": "function",
+                "line": lineno,
+                "col": col,
+                "scope": "module",
+            })
+
+        # Class definitions
+        elif node_type == "ClassDef":
+            symbols.append({
+                "kind": "symbol",
+                "path": path,
+                "name": f"class_{lineno}",
+                "symbol_type": "class",
+                "line": lineno,
+                "col": col,
+                "scope": "module",
+            })
+
+        # Import statements -> edges
+        elif node_type == "Import":
+            edges.append({
+                "kind": "edge",
+                "path": path,
+                "edge_type": "imports",
+                "target": f"module_{lineno}",
+                "line": lineno,
+            })
+
+        elif node_type == "ImportFrom":
+            edges.append({
+                "kind": "edge",
+                "path": path,
+                "edge_type": "imports",
+                "target": f"from_module_{lineno}",
+                "line": lineno,
+            })
+
+        # Assignments at module level (potential exports/constants)
+        elif node_type == "Assign" or node_type == "AnnAssign":
+            symbols.append({
+                "kind": "symbol",
+                "path": path,
+                "name": f"variable_{lineno}",
+                "symbol_type": "variable",
+                "line": lineno,
+                "col": col,
+                "scope": "module",
+            })
+
+    return symbols, edges
+
+
+def extract_js_symbols(ast_data: dict, path: str) -> tuple[list[dict], list[dict]]:
+    """Extract symbols from JavaScript/TypeScript token data.
+
+    Since we only have token counts (not full AST), we provide basic counts.
+
+    Args:
+        ast_data: Token info dict from parse task.
+        path: Source file path.
+
+    Returns:
+        Tuple of (symbols, edges).
+    """
+    symbols = []
+    edges = []
+
+    tokens = ast_data.get("tokens", {})
+
+    # If we have functions, emit a summary symbol
+    if tokens.get("keyword", 0) > 0:
+        symbols.append({
+            "kind": "symbol",
+            "path": path,
+            "name": "js_module",
+            "symbol_type": "module",
+            "line": 1,
+            "col": 0,
+            "scope": "file",
+        })
+
+    return symbols, edges
+
+
+def extract_text_symbols(ast_data: dict, path: str) -> tuple[list[dict], list[dict]]:
+    """Extract minimal info from text files.
+
+    Text files don't have symbols in the traditional sense.
+
+    Args:
+        ast_data: Text info dict from parse task.
+        path: Source file path.
+
+    Returns:
+        Empty lists (no symbols for text files).
+    """
+    return [], []
+
+
+def symbols_executor(config: dict, files: Iterable[dict], runner: ShardRunner) -> list[dict]:
+    """Execute the symbols task.
+
+    Consumes AST outputs from 01_parse and produces symbol tables and edges.
+
+    Args:
+        config: Task configuration.
+        files: Iterable of file records (used to get batch/task context).
+        runner: ShardRunner for CAS and prior output access.
+
+    Returns:
+        List of symbol and edge output records.
+    """
+    outputs = []
+
+    # Get context from config (set by runner during execution)
+    batch_id = config.get("_batch_id")
+    shard_id = config.get("_shard_id")
+
+    if not batch_id or not shard_id:
+        # Fallback: consume files to establish context
+        file_list = list(files)
+        if not file_list:
+            return []
+        # Can't get prior outputs without batch context
+        # Return empty - this shouldn't happen in normal execution
+        return []
+
+    # Iterate over parse AST outputs for this shard
+    for ast_output in runner.iter_prior_outputs(batch_id, "01_parse", shard_id, kind="ast"):
+        path = ast_output.get("path")
+        object_ref = ast_output.get("object")
+        fmt = ast_output.get("format", "json")
+
+        if not path or not object_ref:
+            continue
+
+        # Skip chunked ASTs for simplicity (Phase 2)
+        if fmt == "json+chunks":
+            continue
+
+        try:
+            # Load AST from CAS
+            ast_bytes = runner.object_store.get_bytes(object_ref)
+            ast_data = json.loads(ast_bytes.decode("utf-8"))
+
+            # Extract based on AST type
+            ast_type = ast_data.get("type", "")
+            ast_mode = ast_data.get("ast_mode", "")
+
+            symbols = []
+            edges = []
+
+            if ast_type == "Module" and ast_mode == "summary":
+                # Python summary AST
+                symbols, edges = extract_python_symbols(ast_data, path)
+            elif ast_type == "TokenInfo":
+                # JavaScript/TypeScript tokens
+                symbols, edges = extract_js_symbols(ast_data, path)
+            elif ast_type == "TextInfo":
+                # Text file stats
+                symbols, edges = extract_text_symbols(ast_data, path)
+
+            outputs.extend(symbols)
+            outputs.extend(edges)
+
+        except Exception as e:
+            # Emit diagnostic for failures
+            outputs.append({
+                "kind": "diagnostic",
+                "path": path,
+                "severity": "warning",
+                "code": "SYMBOLS_EXTRACT_ERROR",
+                "message": f"Failed to extract symbols: {e}",
+                "line": 1,
+            })
+
+    return outputs

codebatch-0.1.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: codebatch
+Version: 0.1.0
+Summary: Content-addressed batch execution engine
+Author-email: mcp-tool-shop <64996768+mcp-tool-shop@users.noreply.github.com>
+License-Expression: MIT
+Keywords: batch,content-addressed,deterministic,execution
+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
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# CodeBatch
+
+Content-addressed batch execution engine with deterministic sharding and queryable outputs.
+
+## Overview
+
+CodeBatch provides a filesystem-based execution substrate for running deterministic transformations over codebases. It captures inputs as immutable snapshots, executes work in isolated shards, and indexes all semantic outputs for efficient querying—without requiring a database.
+
+## Documentation
+
+- **[SPEC.md](./SPEC.md)** — Full storage and execution specification
+- **[CHANGELOG.md](./CHANGELOG.md)** — Version history
+
+## Spec Versioning
+
+The specification uses semantic versioning with draft/stable markers. Each version is tagged in git (e.g., `spec-v1.0-draft`). Breaking changes increment the major version. Implementations should declare which spec version they target and tolerate unknown fields for forward compatibility.
+
+## Project Structure
+
+```
+schemas/      JSON Schema definitions for all record types
+src/          Core implementation
+tests/        Test suites and fixtures
+examples/     Usage examples
+.github/      CI/CD workflows
+```
+
+## Quick Start
+
+```bash
+# Create a snapshot of a directory
+codebatch snapshot ./my-project --store ./store
+
+# Initialize a batch with a pipeline
+codebatch batch init --snapshot <id> --pipeline parse
+
+# Run a shard
+codebatch run-shard --batch <id> --task 01_parse --shard ab
+
+# Query results
+codebatch query diagnostics --batch <id> --task 01_parse
+```
+
+## License
+
+MIT

codebatch-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+codebatch/__init__.py,sha256=AoGhdmUvKco4xE6vVKChJFFKGX4G_j3mOo5U_KeXBgE,86
+codebatch/batch.py,sha256=tzk4-M4Z3FaSCiB_o6s_7a-hAdqnetNbrXsVeksA47Q,11419
+codebatch/cas.py,sha256=a6Y12q2Ao2wcunqnm7_lHSLTQV3MlT8nPONZ4zXZZsw,5370
+codebatch/cli.py,sha256=YZdMZxgV1arBavEj1SArPyE_DERKVG7WbIqDpm0C9P8,15850
+codebatch/common.py,sha256=n1FaDlmwEYKRUwZ0v3rsLO6GM6PJWf1QnohLJ7W_erc,2986
+codebatch/paths.py,sha256=5LT2nc3OFJEzOgoq670asZhnu3MnUrKos1m-VL9D60I,5802
+codebatch/query.py,sha256=-3Ydmxz_Ox8zeTEOJXhbljeIO2EeTmgrcBKKknymeRI,7280
+codebatch/runner.py,sha256=LZH9FS5L0afcStVN-LRj7iWrLTtPEnwiEmTFqNUY6v4,17951
+codebatch/snapshot.py,sha256=AZP7DvkJrunUitfWZkqZInc3EZf4qap8GPGOztyjEBc,10912
+codebatch/store.py,sha256=S3nQ2dVtfsEcU5p_rAzF752B7D1toeFShW2-OB3aclE,4854
+codebatch/tasks/__init__.py,sha256=H1B4ylnN-OSEXpX6YNKutJWgg4ic51Ro3eFL8SM4iEk,1022
+codebatch/tasks/analyze.py,sha256=S2yCcri_Ni0N5Q2I7WuSx1kh4TLwdIIs--rB7Bf9bGw,3295
+codebatch/tasks/lint.py,sha256=XrpN3opPjmV6sF7XQi7YhMh-MDjyefJCaZXw0t3xJWE,7901
+codebatch/tasks/parse.py,sha256=Tlye03PIMFLSgwAE8DW3N4F3wQy7WiWSdnsNikZHoiU,9791
+codebatch/tasks/symbols.py,sha256=9ZjoOnQMg_DPtFo7tliRh14P-01IjQgeaPW6w3hsV24,6880
+codebatch-0.1.0.dist-info/METADATA,sha256=Ukd9d8ifWvWKdH2b88pcS7bmlon9rzW_X5xeqPcLnXo,2229
+codebatch-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+codebatch-0.1.0.dist-info/entry_points.txt,sha256=U3k5DUUyCyyueiyJwttLMGZ99YSRDdWrUijFj7yQH6w,49
+codebatch-0.1.0.dist-info/RECORD,,

codebatch-0.1.0.dist-info/WHEEL

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

codebatch-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codebatch = codebatch.cli:main