plans and docs

conductor/tracks/gencpp_python_bindings_20260308/metadata.json

@@ -0,0 +1,17 @@
+{
+  "track_id": "gencpp_python_bindings_20260308",
+  "title": "Bootstrap gencpp Python Bindings Project",
+  "status": "pending",
+  "created": "2026-03-08",
+  "priority": "medium",
+  "owner": "tier2-tech-lead",
+  "description": "Create standalone Python project with CFFI bindings for gencpp C library to enable richer C++ AST parsing in the future",
+  "dependencies": [],
+  "out_of_scope": [
+    "Full AST traversal",
+    "Expression parsing",
+    "Integration into manual_slop",
+    "macOS/Linux support"
+  ],
+  "notes": "Long-term effort. Track 1 (tree-sitter) provides immediate C/C++ support. This is for future richer functionality."
+}

conductor/tracks/gencpp_python_bindings_20260308/plan.md

@@ -0,0 +1,95 @@
+# Plan: Bootstrap gencpp Python Bindings Project
+
+## Overview
+Create standalone Python project with CFFI bindings for gencpp C library.
+
+## Phase 1: Project Setup
+Focus: Create repository structure and CFFI configuration
+
+- [ ] Task 1.1: Create new project directory `gencpp-python-bindings/`
+  - WHERE: New directory outside manual_slop
+  - WHAT: Initialize as Python package with pyproject.toml
+  - HOW: Standard Python package structure
+  - SAFETY: New project, no impact on manual_slop
+
+- [ ] Task 1.2: Set up CFFI in pyproject.toml
+  - WHERE: gencpp-python-bindings/pyproject.toml
+  - WHAT: Add cffi dependency and build requirements
+  - HOW: Standard CFFI setup
+  - SAFETY: New file
+
+- [ ] Task 1.3: Obtain gencpp C library
+  - WHERE: gencpp-python-bindings/lib/
+  - WHAT: Download or reference gencpp_c11.lib from gencpp releases
+  - HOW: Clone gencpp or add as git submodule
+  - SAFETY: External dependency
+
+## Phase 2: CFFI Binding Skeleton
+Focus: Set up FFI and basic type mappings
+
+- [ ] Task 2.1: Create CFFI wrapper module
+  - WHERE: gencpp-python-bindings/src/gencpp/_cffi.py
+  - WHAT: Set up FFI with gencpp C header declarations
+  - HOW: Map basic types from gencpp C API
+  - SAFETY: New module
+
+- [ ] Task 2.2: Define Python Declaration dataclasses
+  - WHERE: gencpp-python-bindings/src/gencpp/models.py
+  - WHAT: Create Declaration, FunctionDecl, StructDecl, EnumDecl, etc.
+  - HOW: Dataclasses matching gencpp AST types
+  - SAFETY: New module
+
+- [ ] Task 2.3: Build minimal CFFI bindings for top-level declarations
+  - WHERE: gencpp-python-bindings/src/gencpp/bindings.py
+  - WHAT: Bind gencpp C functions for parsing and AST traversal
+  - HOW: Focus on Code_Function, Code_Struct, Code_Enum, Code_Typedef
+  - SAFETY: New module
+
+## Phase 3: Python API Implementation
+Focus: Create Python-friendly API
+
+- [ ] Task 3.1: Implement parse_c_file()
+  - WHERE: gencpp-python-bindings/src/gencpp/parser.py
+  - WHAT: Parse C file, return list of Declaration objects
+  - HOW: Call gencpp C library, convert to Python dataclasses
+  - SAFETY: New function
+
+- [ ] Task 3.2: Implement parse_cpp_file()
+  - WHERE: gencpp-python-bindings/src/gencpp/parser.py
+  - WHAT: Parse C++ file, return list of Declaration objects (includes classes)
+  - HOW: Similar to C with additional C++ types
+  - SAFETY: New function
+
+- [ ] Task 3.3: Add skeleton generation helpers
+  - WHERE: gencpp-python-bindings/src/gencpp/skeleton.py
+  - WHAT: Convert Declaration list to skeleton string (matching mcp_client format)
+  - HOW: Format function signatures, struct fields, etc.
+  - SAFETY: New module
+
+## Phase 4: Testing & Documentation
+Focus: Verify bindings work and document
+
+- [ ] Task 4.1: Write basic parse tests
+  - WHERE: gencpp-python-bindings/tests/
+  - WHAT: Test parsing sample C and C++ files
+  - HOW: Use pytest with fixture sample files
+  - SAFETY: New test files
+
+- [ ] Task 4.2: Document API and future expansion
+  - WHERE: gencpp-python-bindings/README.md
+  - WHAT: Document current capabilities, what's missing, how to extend
+  - HOW: Markdown documentation
+  - SAFETY: New documentation
+
+- [ ] Task 4.3: Verify Windows build works
+  - WHERE: Local Windows environment
+  - WHAT: Ensure CFFI can load gencpp_c11.lib
+  - HOW: Run tests on Windows
+  - SAFETY: Validation only
+
+## Future Work (Not This Track)
+- Full AST traversal (beyond top-level)
+- Integration into manual_slop mcp_client as `gencpp_*` tools
+- macOS/Linux support
+- Template parameter parsing
+- Operator overloading resolution

conductor/tracks/gencpp_python_bindings_20260308/spec.md

@@ -0,0 +1,99 @@
+# Track Specification: Bootstrap gencpp Python Bindings Project
+
+## Overview
+
+Create a new standalone Python project to build CFFI bindings for gencpp (C/C++ staged metaprogramming library). This will eventually provide richer C++ AST understanding than tree-sitter (full type information, operators, specifiers) but is a longer-term effort. This track bootstraps the project structure and initial bindings.
+
+## Current State Audit
+
+### gencpp Analysis (from research)
+- **gencpp**: C++ library for staged metaprogramming with built-in C/C++ parser
+- **Parser**: Non-standards-compliant single-pass parser for declarations/definitions
+- **NOT execution-aware**: Does NOT parse expressions or statements (only declarations)
+- **AST Types**: Code_Class, Code_Struct, Code_Function, Code_Enum, Code_Typedef, etc.
+- **Available bindings**: Odin (82KB binding file demonstrates scope)
+- **Repository**: https://github.com/Ed94/gencpp
+
+### What gencpp Can Extract
+- Function declarations and definitions (signatures only)
+- Class/struct/enum/union definitions
+- Type aliases (typedef)
+- Template declarations (partial)
+- Access specifiers
+- Operators (overload resolution)
+- Preprocessor includes/defines
+
+### What gencpp CANNOT Do
+- Parse function bodies/implementations
+- Expression evaluation
+- Template instantiation
+
+## Goals
+
+1. Create new Python project structure for gencpp bindings
+2. Set up CFFI to interface with gencpp C library
+3. Build minimal viable bindings for declaration extraction
+4. Create Python API matching existing mcp_client patterns
+5. Document future expansion path
+
+## Functional Requirements
+
+### Project Setup
+- Create new repository/project: `gencpp-python-bindings` (or `pygencpp`)
+- Use CFFI for C library binding (pure Python, no C extension compilation required for basic use)
+- Structure: Python package with CFFI-based wrapper
+
+### Core API (Phase 1)
+| Function | Description |
+|----------|-------------|
+| `parse_c_file(path) -> List[Declaration]` | Parse C file, return declarations |
+| `parse_cpp_file(path) -> List[Declaration]` | Parse C++ file, return declarations |
+| `Declaration` dataclass | name, type, line_number, node_type |
+
+### Declaration Types to Bind
+- `Code_Function` / `Code_Function_Fwd`
+- `Code_Struct` / `Code_Struct_Fwd`
+- `Code_Enum` / `Code_Enum_Fwd`
+- `Code_Union` / `Code_Union_Fwd`
+- `Code_Typedef`
+- `Code_Class` (C++)
+- `Code_Namespace` (C++)
+
+### Integration Points (Future)
+- Design Python API to match mcp_client patterns for easy integration
+- Allow language parameter: `parse_file(path, language: str)`
+- Return structured data suitable for skeleton generation
+
+## Non-Functional Requirements
+
+- Pure Python with CFFI (no compiled extensions required at install time)
+- Must work on Windows (gencpp provides win64 precompiled library)
+- Follow existing 1-space indentation code style
+- Include type hints for all public APIs
+
+## Architecture Reference
+
+- **gencpp C library**: Precompiled `gencpp_c11.lib` (Windows) or source compilation
+- **CFFI pattern**: Use `cffi.FFI().set_source()` to wrap C library
+- **Odin bindings reference**: https://github.com/Ed94/gencpp-odin (shows AST type scope)
+- **Existing mcp_client pattern**: `src/mcp_client.py` tool dispatch
+
+## Out of Scope (This Track)
+- Full AST traversal (only top-level declarations)
+- Expression parsing
+- Template instantiation analysis
+- Integration into Manual Slop (future track)
+- macOS/Linux support (Windows first)
+
+## Relationship to Tree-Sitter Track
+
+This is a SEPARATE long-term effort. The tree-sitter track provides immediate C/C++ support. The gencpp bindings track is for future richer functionality:
+
+| Aspect | tree-sitter (Track 1) | gencpp (This Track) |
+|--------|---------------------|---------------------|
+| Scope | Per-file syntax | Per-file declarations |
+| Types | Syntax nodes only | Named types, operators |
+| Timeline | Immediate | Months |
+| Effort | 1-2 weeks | Ongoing |
+
+The tools will be named `ts_c_*` / `ts_cpp_*` for tree-sitter to leave namespace open for `gencpp_*` tools in the future.