Timmy_Foundation/timmy-home
15
0
Fork 0
Code Issues 231 Pull Requests 39 Actions Packages Projects Releases Wiki Activity

Merge PR #701

Browse Source
This commit is contained in:
Alexander Whitestone
2026-04-15 23:59:15 -04:00
parent 612b8ac068 8d1f9ed375
commit 2b48cd0e42
5 changed files with 1197 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

275
codebase_genome.py Normal file
View File

@@ -0,0 +1,275 @@
#!/usr/bin/env python3
"""
codebase_genome.py — Analyze a repo and generate test stubs for uncovered functions.
Scans Python files, extracts function/class/method signatures via AST,
and generates pytest test cases with edge cases.
Usage:
python3 codebase_genome.py /path/to/repo
python3 codebase_genome.py /path/to/repo --output tests/test_genome_generated.py
"""
import ast
import os
import sys
import argparse
from pathlib import Path
class FunctionInfo:
def __init__(self, name, filepath, lineno, args, returns, decorators, is_method=False, class_name=None):
self.name = name
self.filepath = filepath
self.lineno = lineno
self.args = args # list of arg names
self.returns = returns # return annotation or None
self.decorators = decorators
self.is_method = is_method
self.class_name = class_name
@property
def qualified_name(self):
if self.class_name:
return f"{self.class_name}.{self.name}"
return self.name
@property
def import_path(self):
"""Module path for import (e.g., 'mymodule.sub.Class.method')."""
rel = Path(self.filepath).with_suffix('')
parts = list(rel.parts)
# Remove common prefixes
if parts and parts[0] in ('src', 'lib'):
parts = parts[1:]
module = '.'.join(parts)
if self.class_name:
return f"{module}.{self.class_name}.{self.name}"
return f"{module}.{self.name}"
@property
def module_path(self):
rel = Path(self.filepath).with_suffix('')
parts = list(rel.parts)
if parts and parts[0] in ('src', 'lib'):
parts = parts[1:]
return '.'.join(parts)
def extract_functions(filepath: str) -> list:
"""Extract all function definitions from a Python file via AST."""
try:
source = open(filepath).read()
tree = ast.parse(source, filename=filepath)
except (SyntaxError, UnicodeDecodeError):
return []
functions = []
class FuncVisitor(ast.NodeVisitor):
def __init__(self):
self.current_class = None
def visit_ClassDef(self, node):
old_class = self.current_class
self.current_class = node.name
self.generic_visit(node)
self.current_class = old_class
def visit_FunctionDef(self, node):
args = [a.arg for a in node.args.args]
if args and args[0] == 'self':
args = args[1:]
returns = None
if node.returns:
if isinstance(node.returns, ast.Name):
returns = node.returns.id
elif isinstance(node.returns, ast.Constant):
returns = str(node.returns.value)
decorators = []
for d in node.decorator_list:
if isinstance(d, ast.Name):
decorators.append(d.id)
elif isinstance(d, ast.Attribute):
decorators.append(d.attr)
functions.append(FunctionInfo(
name=node.name,
filepath=filepath,
lineno=node.lineno,
args=args,
returns=returns,
decorators=decorators,
is_method=self.current_class is not None,
class_name=self.current_class,
))
self.generic_visit(node)
visit_AsyncFunctionDef = visit_FunctionDef
visitor = FuncVisitor()
visitor.visit(tree)
return functions
def generate_test(func: FunctionInfo, existing_tests: set) -> str:
"""Generate a pytest test function for a given function."""
if func.name in existing_tests:
return ''
# Skip private/dunder methods
if func.name.startswith('_') and not func.name.startswith('__'):
return ''
if func.name.startswith('__') and func.name.endswith('__'):
return ''
lines = []
# Generate imports
module = func.module_path.replace('/', '.').lstrip('.')
if func.class_name:
lines.append(f"from {module} import {func.class_name}")
else:
lines.append(f"from {module} import {func.name}")
lines.append('')
lines.append('')
# Test function name
test_name = f"test_{func.qualified_name.replace('.', '_')}"
# Determine args for the test call
args_str = ', '.join(func.args)
lines.append(f"def {test_name}():")
lines.append(f' """Test {func.qualified_name} (line {func.lineno} in {func.filepath})."""')
if func.is_method:
lines.append(f" # TODO: instantiate {func.class_name} with valid args")
lines.append(f" obj = {func.class_name}()")
lines.append(f" result = obj.{func.name}({', '.join('None' for _ in func.args) if func.args else ''})")
else:
if func.args:
lines.append(f" # TODO: provide valid arguments for: {args_str}")
lines.append(f" result = {func.name}({', '.join('None' for _ in func.args)})")
else:
lines.append(f" result = {func.name}()")
lines.append(f" assert result is not None or result is None # TODO: real assertion")
lines.append('')
lines.append('')
# Edge cases
lines.append(f"def {test_name}_edge_cases():")
lines.append(f' """Edge cases for {func.qualified_name}."""')
if func.args:
lines.append(f" # Test with empty/zero/None args")
if func.is_method:
lines.append(f" obj = {func.class_name}()")
for arg in func.args:
lines.append(f" # obj.{func.name}({arg}=...) # TODO: test with invalid {arg}")
else:
for arg in func.args:
lines.append(f" # {func.name}({arg}=...) # TODO: test with invalid {arg}")
else:
lines.append(f" # {func.qualified_name} takes no args — test idempotency")
if func.is_method:
lines.append(f" obj = {func.class_name}()")
lines.append(f" r1 = obj.{func.name}()")
lines.append(f" r2 = obj.{func.name}()")
lines.append(f" # assert r1 == r2 # TODO: uncomment if deterministic")
else:
lines.append(f" r1 = {func.name}()")
lines.append(f" r2 = {func.name}()")
lines.append(f" # assert r1 == r2 # TODO: uncomment if deterministic")
lines.append('')
lines.append('')
return '\n'.join(lines)
def scan_repo(repo_path: str) -> list:
"""Scan all Python files in a repo and extract functions."""
all_functions = []
for root, dirs, files in os.walk(repo_path):
# Skip hidden dirs, __pycache__, .git, venv, node_modules
dirs[:] = [d for d in dirs if not d.startswith('.') and d not in ('__pycache__', 'venv', 'node_modules', 'env')]
for f in files:
if f.endswith('.py') and not f.startswith('_'):
filepath = os.path.join(root, f)
relpath = os.path.relpath(filepath, repo_path)
funcs = extract_functions(filepath)
# Update filepath to relative
for func in funcs:
func.filepath = relpath
all_functions.extend(funcs)
return all_functions
def find_existing_tests(repo_path: str) -> set:
"""Find function names that already have tests."""
tested = set()
tests_dir = os.path.join(repo_path, 'tests')
if not os.path.isdir(tests_dir):
return tested
for root, dirs, files in os.walk(tests_dir):
for f in files:
if f.startswith('test_') and f.endswith('.py'):
try:
source = open(os.path.join(root, f)).read()
tree = ast.parse(source)
for node in ast.walk(tree):
if isinstance(node, ast.FunctionDef) and node.name.startswith('test_'):
# Extract function name from test name
name = node.name[5:] # strip 'test_'
tested.add(name)
except (SyntaxError, UnicodeDecodeError):
pass
return tested
def main():
parser = argparse.ArgumentParser(description='Generate test stubs for uncovered functions')
parser.add_argument('repo', help='Path to repository')
parser.add_argument('--output', '-o', default=None, help='Output file (default: stdout)')
parser.add_argument('--limit', '-n', type=int, default=50, help='Max tests to generate')
args = parser.parse_args()
repo = os.path.abspath(args.repo)
if not os.path.isdir(repo):
print(f"Error: {repo} is not a directory", file=sys.stderr)
sys.exit(1)
functions = scan_repo(repo)
existing = find_existing_tests(repo)
# Filter to untested functions
untested = [f for f in functions if f.name not in existing and not f.name.startswith('_')]
print(f"Found {len(functions)} functions, {len(untested)} untested", file=sys.stderr)
# Generate tests
output = []
output.append('"""Auto-generated test stubs from codebase_genome.py.\n')
output.append('These are starting points — fill in real assertions and args.\n"""')
output.append('import pytest')
output.append('')
generated = 0
for func in untested[:args.limit]:
test = generate_test(func, set())
if test:
output.append(test)
generated += 1
content = '\n'.join(output)
if args.output:
with open(args.output, 'w') as f:
f.write(content)
print(f"Generated {generated} test stubs → {args.output}", file=sys.stderr)
else:
print(content)
if __name__ == '__main__':
main()

142
infrastructure/emacs-control-plane/README.md Normal file
View File

@@ -0,0 +1,142 @@
# Emacs Sovereign Control Plane
Real-time, programmable orchestration hub for the Timmy Foundation fleet.
## Architecture
```
┌─────────────────────────────────────────────────────────────┐
│ Emacs Control Plane │
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ dispatch.org│ │ shared │ │ org-babel │ │
│ │ (Task Queue)│ │ buffers │ │ notebooks │ │
│ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │
│ │ │ │ │
│ └────────────────┼────────────────┘ │
│ │ │
│ ┌─────▼─────┐ │
│ │ Emacs │ │
│ │ Daemon │ │
│ │ (bezalel)│ │
│ └─────┬─────┘ │
└──────────────────────────┼──────────────────────────────────┘
│
┌──────────────────┼──────────────────┐
│ │ │
┌────▼────┐ ┌────▼────┐ ┌────▼────┐
│ Ezra │ │ Allegro │ │ Timmy │
│ (VPS) │ │ (VPS) │ │ (Mac) │
└─────────┘ └─────────┘ └─────────┘
```
## Infrastructure
| Component | Location | Details |
|-----------|----------|---------|
| Daemon Host | Bezalel (`159.203.146.185`) | Shared Emacs daemon |
| Socket Path | `/root/.emacs.d/server/bezalel` | emacsclient socket |
| Dispatch Hub | `/srv/fleet/workspace/dispatch.org` | Central task queue |
| Wrapper | `/usr/local/bin/fleet-append` | Quick message append |
## Quick Start
### From Local Machine (Timmy)
```bash
# Append a message to the fleet log
scripts/fleet_dispatch.sh append "Status: all systems nominal"
# Check for pending tasks assigned to Timmy
scripts/fleet_dispatch.sh poll timmy
# Claim a task
scripts/fleet_dispatch.sh claim 42 timmy
# Report task completion
scripts/emacs_fleet_bridge.py complete 42 "PR merged: #123"
```
### From Other VPS Agents (Ezra, Allegro, etc.)
```bash
# Direct emacsclient via SSH
ssh root@bezalel 'emacsclient -s /root/.emacs.d/server/bezalel -e "(your-elisp-here)"'
# Or use the wrapper
ssh root@bezalel '/usr/local/bin/fleet-append "Ezra: task #42 complete"'
```
## dispatch.org Structure
The central dispatch hub uses Org mode format:
```org
* TODO [timmy] Review PR #123 from gitea
SCHEDULED: <2026-04-13 Sun>
:PROPERTIES:
:PRIORITY: A
:ASSIGNEE: timmy
:GITEA_PR: https://forge.alexanderwhitestone.com/...
:END:
* IN_PROGRESS [ezra] Deploy monitoring to VPS
SCHEDULED: <2026-04-13 Sun>
:PROPERTIES:
:PRIORITY: B
:ASSIGNEE: ezra
:STARTED: 2026-04-13T15:30:00Z
:END:
* DONE [allegro] Fix cron reliability
CLOSED: [2026-04-13 Sun 14:00]
:PROPERTIES:
:ASSIGNEE: allegro
:RESULT: PR #456 merged
:END:
```
### Status Keywords
- `TODO` — Available for claiming
- `IN_PROGRESS` — Being worked on
- `WAITING` — Blocked on external dependency
- `DONE` — Completed
- `CANCELLED` — No longer needed
### Priority Levels
- `[#A]` — Critical / P0
- `[#B]` — Important / P1
- `[#C]` — Normal / P2
## Agent Workflow
1. **Poll:** Check `dispatch.org` for `TODO` items matching your agent name
2. **Claim:** Update status from `TODO` to `IN_PROGRESS`, add `:STARTED:` timestamp
3. **Execute:** Do the work (implement, deploy, test, etc.)
4. **Report:** Update status to `DONE`, add `:RESULT:` property with outcome
## Integration with Existing Systems
### Gitea Issues
- `dispatch.org` tasks can reference Gitea issues via `:GITEA_PR:` or `:GITEA_ISSUE:` properties
- Completion can auto-close Gitea issues via API
### Hermes Cron
- Hermes cron jobs can check `dispatch.org` before running
- Tasks in `dispatch.org` take priority over ambient issue burning
### Nostr Protocol
- Heartbeats still go through Nostr (kind 1)
- `dispatch.org` is for tactical coordination, Nostr is for strategic announcements
## Files
```
infrastructure/emacs-control-plane/
├── README.md # This file
├── dispatch.org.template # Template dispatch file
└── fleet_bridge.el # Emacs Lisp helpers
scripts/
├── fleet_dispatch.sh # Shell wrapper for fleet operations
├── emacs_fleet_bridge.py # Python bridge for Emacs daemon
└── emacs_task_poller.py # Poll for tasks assigned to an agent
```

50
infrastructure/emacs-control-plane/dispatch.org.template Normal file
View File

@@ -0,0 +1,50 @@
#+TITLE: Fleet Dispatch Hub
#+AUTHOR: Timmy Foundation
#+DATE: 2026-04-13
#+PROPERTY: header-args :tangle no
* Overview
This is the central task queue for the Timmy Foundation fleet.
Agents poll this file for =TODO= items matching their name.
* How to Use
1. Agents: Poll for =TODO= items with your assignee tag
2. Claim: Move to =IN_PROGRESS= with =:STARTED:= timestamp
3. Complete: Move to =DONE= with =:RESULT:= property
* Fleet Status
** Heartbeats
- timmy: LAST_HEARTBEAT <2026-04-13 Sun 15:00>
- ezra: LAST_HEARTBEAT <2026-04-13 Sun 15:00>
- allegro: LAST_HEARTBEAT <2026-04-13 Sun 14:55>
- bezalel: LAST_HEARTBEAT <2026-04-13 Sun 15:00>
* Tasks
** TODO [timmy] Example task — review pending PRs
SCHEDULED: <2026-04-13 Sun>
:PROPERTIES:
:PRIORITY: B
:ASSIGNEE: timmy
:GITEA_ISSUE: https://forge.alexanderwhitestone.com/Timmy_Foundation/timmy-home/issues/590
:END:
Check all open PRs across fleet repos and triage.
** TODO [ezra] Example task — run fleet health check
SCHEDULED: <2026-04-13 Sun>
:PROPERTIES:
:PRIORITY: C
:ASSIGNEE: ezra
:END:
SSH into each VPS and verify services are running.
** TODO [allegro] Example task — update cron job configs
SCHEDULED: <2026-04-13 Sun>
:PROPERTIES:
:PRIORITY: C
:ASSIGNEE: allegro
:END:
Review and update cron job definitions in timmy-config.
* Completed
#+BEGIN: clocktable :scope file :maxlevel 2
#+END:

202
scripts/fleet_dispatch.sh Normal file
View File

@@ -0,0 +1,202 @@
#!/bin/bash
# ============================================================================
# Fleet Dispatch — Shell wrapper for Emacs Control Plane operations
# ============================================================================
#
# Usage:
# scripts/fleet_dispatch.sh append "Message text"
# scripts/fleet_dispatch.sh poll [agent_name]
# scripts/fleet_dispatch.sh claim TASK_ID agent_name
# scripts/fleet_dispatch.sh complete TASK_ID "Result text"
# scripts/fleet_dispatch.sh status
#
# Environment:
# FLEET_DAEMON_HOST — Bezalel host (default: 159.203.146.185)
# FLEET_DAEMON_USER — SSH user (default: root)
# FLEET_DAEMON_SOCKET — Emacs socket path (default: /root/.emacs.d/server/bezalel)
# FLEET_DISPATCH_FILE — Path to dispatch.org on remote (default: /srv/fleet/workspace/dispatch.org)
# ============================================================================
set -euo pipefail
# ── Configuration ──────────────────────────────────────────────────────────
FLEET_DAEMON_HOST="${FLEET_DAEMON_HOST:-159.203.146.185}"
FLEET_DAEMON_USER="${FLEET_DAEMON_USER:-root}"
FLEET_DAEMON_SOCKET="${FLEET_DAEMON_SOCKET:-/root/.emacs.d/server/bezalel}"
FLEET_DISPATCH_FILE="${FLEET_DISPATCH_FILE:-/srv/fleet/workspace/dispatch.org}"
# Colors
GREEN='\033[0;32m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
RED='\033[0;31m'
NC='\033[0m'
# ── Helper: Run emacsclient command on Bezalel ─────────────────────────────
run_emacs() {
local elisp="$1"
ssh "${FLEET_DAEMON_USER}@${FLEET_DAEMON_HOST}" \
"emacsclient -s ${FLEET_DAEMON_SOCKET} -e '${elisp}'" 2>/dev/null
}
# ── Helper: Read dispatch.org via SSH ──────────────────────────────────────
read_dispatch() {
ssh "${FLEET_DAEMON_USER}@${FLEET_DAEMON_HOST}" \
"cat ${FLEET_DISPATCH_FILE}" 2>/dev/null
}
# ── Helper: Write dispatch.org via SSH ─────────────────────────────────────
write_dispatch() {
ssh "${FLEET_DAEMON_USER}@${FLEET_DAEMON_HOST}" \
"cat > ${FLEET_DISPATCH_FILE}" 2>/dev/null
}
# ── Commands ───────────────────────────────────────────────────────────────
cmd_append() {
local message="${1:?Usage: fleet_dispatch.sh append \"message\"}"
local timestamp
timestamp=$(date -u +"%Y-%m-%d %H:%M:%S UTC")
echo -e "${CYAN}Appending to fleet log...${NC}"
# Use the fleet-append wrapper on Bezalel if available, otherwise emacsclient
if ssh "${FLEET_DAEMON_USER}@${FLEET_DAEMON_HOST}" "which fleet-append" &>/dev/null; then
ssh "${FLEET_DAEMON_USER}@${FLEET_DAEMON_HOST}" \
"fleet-append '${timestamp} — ${message}'"
else
run_emacs "(with-current-buffer (find-file-noselect \"${FLEET_DISPATCH_FILE}\") (goto-char (point-max)) (insert \"\\n- ${timestamp} — ${message}\") (save-buffer))"
fi
echo -e "${GREEN}✓ Appended: ${message}${NC}"
}
cmd_poll() {
local agent="${1:-}"
echo -e "${CYAN}Polling dispatch.org for tasks...${NC}"
local content
content=$(read_dispatch)
if [ -z "$content" ]; then
echo -e "${RED}Could not read dispatch.org${NC}"
return 1
fi
# Filter TODO items, optionally by agent
echo -e "${YELLOW}=== Pending Tasks ===${NC}"
if [ -n "$agent" ]; then
echo "$content" | grep -E "^\*\* TODO \[${agent}\]" || echo " No tasks for ${agent}"
else
echo "$content" | grep -E "^\*\* TODO " || echo " No pending tasks"
fi
}
cmd_claim() {
local task_id="${1:?Usage: fleet_dispatch.sh claim TASK_ID agent}"
local agent="${2:?Usage: fleet_dispatch.sh claim TASK_ID agent}"
local timestamp
timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
echo -e "${CYAN}Claiming task #${task_id} for ${agent}...${NC}"
# Use emacsclient to update the Org heading
run_emacs "(progn (with-current-buffer (find-file-noselect \"${FLEET_DISPATCH_FILE}\") (org-mode) (goto-char (point-min)) (if (re-search-forward (format \"^\\\\*\\\\* TODO.*#%s\" \"${task_id}\") nil t) (progn (org-todo \"IN_PROGRESS\") (org-set-property \"STARTED\" \"${timestamp}\") (save-buffer) (message \"Task %s claimed\" \"${task_id}\")) (message \"Task %s not found\" \"${task_id}\"))))"
echo -e "${GREEN}✓ Task #${task_id} claimed by ${agent}${NC}"
}
cmd_complete() {
local task_id="${1:?Usage: fleet_dispatch.sh complete TASK_ID \"result\"}"
local result="${2:-Completed}"
local timestamp
timestamp=$(date -u +"%Y-%m-%d %H:%M")
echo -e "${CYAN}Completing task #${task_id}...${NC}"
run_emacs "(progn (with-current-buffer (find-file-noselect \"${FLEET_DISPATCH_FILE}\") (org-mode) (goto-char (point-min)) (if (re-search-forward (format \"^\\\\*\\\\* IN_PROGRESS.*#%s\" \"${task_id}\") nil t) (progn (org-todo \"DONE\") (org-set-property \"RESULT\" \"${result}\") (org-add-planning-info 'closed (org-current-effective-time)) (save-buffer) (message \"Task %s completed\" \"${task_id}\")) (message \"Task %s not found\" \"${task_id}\"))))"
echo -e "${GREEN}✓ Task #${task_id} completed: ${result}${NC}"
}
cmd_status() {
echo -e "${CYAN}Fleet Control Plane Status${NC}"
echo -e " Host: ${FLEET_DAEMON_HOST}"
echo -e " Socket: ${FLEET_DAEMON_SOCKET}"
echo -e " Dispatch: ${FLEET_DISPATCH_FILE}"
echo ""
# Test connectivity
if ssh -o ConnectTimeout=5 "${FLEET_DAEMON_USER}@${FLEET_DAEMON_HOST}" "echo ok" &>/dev/null; then
echo -e " SSH: ${GREEN}✓ reachable${NC}"
else
echo -e " SSH: ${RED}✗ unreachable${NC}"
return 1
fi
# Test emacs daemon
local daemon_status
daemon_status=$(run_emacs "(if (server-running-p) \"running\" \"stopped\")" 2>/dev/null || echo "error")
if [ "$daemon_status" = "\"running\"" ]; then
echo -e " Daemon: ${GREEN}✓ running${NC}"
else
echo -e " Daemon: ${RED}✗ ${daemon_status}${NC}"
fi
# Count tasks
local content
content=$(read_dispatch 2>/dev/null || echo "")
if [ -n "$content" ]; then
local todo_count in_progress_count done_count
todo_count=$(echo "$content" | grep -c "^\*\* TODO " || echo 0)
in_progress_count=$(echo "$content" | grep -c "^\*\* IN_PROGRESS " || echo 0)
done_count=$(echo "$content" | grep -c "^\*\* DONE " || echo 0)
echo -e " Tasks: ${YELLOW}${todo_count} TODO${NC}, ${CYAN}${in_progress_count} IN_PROGRESS${NC}, ${GREEN}${done_count} DONE${NC}"
fi
}
# ── Main ───────────────────────────────────────────────────────────────────
case "${1:-help}" in
append|log)
shift
cmd_append "$@"
;;
poll|check)
shift
cmd_poll "$@"
;;
claim)
shift
cmd_claim "$@"
;;
complete|done)
shift
cmd_complete "$@"
;;
status)
cmd_status
;;
help|--help|-h)
echo "Fleet Dispatch — Emacs Control Plane wrapper"
echo ""
echo "Usage:"
echo " $0 append \"message\" Append to fleet log"
echo " $0 poll [agent] Check for pending tasks"
echo " $0 claim TASK_ID agent Claim a task"
echo " $0 complete TASK_ID \"result\" Mark task complete"
echo " $0 status Show control plane status"
echo ""
echo "Environment:"
echo " FLEET_DAEMON_HOST Bezalel host (default: 159.203.146.185)"
echo " FLEET_DAEMON_USER SSH user (default: root)"
echo " FLEET_DAEMON_SOCKET Emacs socket (default: /root/.emacs.d/server/bezalel)"
;;
*)
echo -e "${RED}Unknown command: $1${NC}"
echo "Run '$0 help' for usage."
exit 1
;;
esac

528
tests/test_genome_generated.py Normal file
View File

@@ -0,0 +1,528 @@
"""Auto-generated test stubs from codebase_genome.py.
These are starting points — fill in real assertions and args.
"""
import pytest
from codebase_genome import FunctionInfo
def test_FunctionInfo_qualified_name():
"""Test FunctionInfo.qualified_name (line 31 in codebase_genome.py)."""
# TODO: instantiate FunctionInfo with valid args
obj = FunctionInfo()
result = obj.qualified_name()
assert result is not None or result is None # TODO: real assertion
def test_FunctionInfo_qualified_name_edge_cases():
"""Edge cases for FunctionInfo.qualified_name."""
# FunctionInfo.qualified_name takes no args — test idempotency
obj = FunctionInfo()
r1 = obj.qualified_name()
r2 = obj.qualified_name()
# assert r1 == r2 # TODO: uncomment if deterministic
from codebase_genome import FunctionInfo
def test_FunctionInfo_import_path():
"""Test FunctionInfo.import_path (line 37 in codebase_genome.py)."""
# TODO: instantiate FunctionInfo with valid args
obj = FunctionInfo()
result = obj.import_path()
assert result is not None or result is None # TODO: real assertion
def test_FunctionInfo_import_path_edge_cases():
"""Edge cases for FunctionInfo.import_path."""
# FunctionInfo.import_path takes no args — test idempotency
obj = FunctionInfo()
r1 = obj.import_path()
r2 = obj.import_path()
# assert r1 == r2 # TODO: uncomment if deterministic
from codebase_genome import FunctionInfo
def test_FunctionInfo_module_path():
"""Test FunctionInfo.module_path (line 50 in codebase_genome.py)."""
# TODO: instantiate FunctionInfo with valid args
obj = FunctionInfo()
result = obj.module_path()
assert result is not None or result is None # TODO: real assertion
def test_FunctionInfo_module_path_edge_cases():
"""Edge cases for FunctionInfo.module_path."""
# FunctionInfo.module_path takes no args — test idempotency
obj = FunctionInfo()
r1 = obj.module_path()
r2 = obj.module_path()
# assert r1 == r2 # TODO: uncomment if deterministic
from codebase_genome import extract_functions
def test_extract_functions():
"""Test extract_functions (line 58 in codebase_genome.py)."""
# TODO: provide valid arguments for: filepath
result = extract_functions(None)
assert result is not None or result is None # TODO: real assertion
def test_extract_functions_edge_cases():
"""Edge cases for extract_functions."""
# Test with empty/zero/None args
# extract_functions(filepath=...) # TODO: test with invalid filepath
from codebase_genome import FuncVisitor
def test_FuncVisitor_visit_ClassDef():
"""Test FuncVisitor.visit_ClassDef (line 72 in codebase_genome.py)."""
# TODO: instantiate FuncVisitor with valid args
obj = FuncVisitor()
result = obj.visit_ClassDef(None)
assert result is not None or result is None # TODO: real assertion
def test_FuncVisitor_visit_ClassDef_edge_cases():
"""Edge cases for FuncVisitor.visit_ClassDef."""
# Test with empty/zero/None args
obj = FuncVisitor()
# obj.visit_ClassDef(node=...) # TODO: test with invalid node
from codebase_genome import FuncVisitor
def test_FuncVisitor_visit_FunctionDef():
"""Test FuncVisitor.visit_FunctionDef (line 78 in codebase_genome.py)."""
# TODO: instantiate FuncVisitor with valid args
obj = FuncVisitor()
result = obj.visit_FunctionDef(None)
assert result is not None or result is None # TODO: real assertion
def test_FuncVisitor_visit_FunctionDef_edge_cases():
"""Edge cases for FuncVisitor.visit_FunctionDef."""
# Test with empty/zero/None args
obj = FuncVisitor()
# obj.visit_FunctionDef(node=...) # TODO: test with invalid node
from codebase_genome import generate_test
def test_generate_test():
"""Test generate_test (line 116 in codebase_genome.py)."""
# TODO: provide valid arguments for: func, existing_tests
result = generate_test(None, None)
assert result is not None or result is None # TODO: real assertion
def test_generate_test_edge_cases():
"""Edge cases for generate_test."""
# Test with empty/zero/None args
# generate_test(func=...) # TODO: test with invalid func
# generate_test(existing_tests=...) # TODO: test with invalid existing_tests
from codebase_genome import scan_repo
def test_scan_repo():
"""Test scan_repo (line 191 in codebase_genome.py)."""
# TODO: provide valid arguments for: repo_path
result = scan_repo(None)
assert result is not None or result is None # TODO: real assertion
def test_scan_repo_edge_cases():
"""Edge cases for scan_repo."""
# Test with empty/zero/None args
# scan_repo(repo_path=...) # TODO: test with invalid repo_path
from codebase_genome import find_existing_tests
def test_find_existing_tests():
"""Test find_existing_tests (line 209 in codebase_genome.py)."""
# TODO: provide valid arguments for: repo_path
result = find_existing_tests(None)
assert result is not None or result is None # TODO: real assertion
def test_find_existing_tests_edge_cases():
"""Edge cases for find_existing_tests."""
# Test with empty/zero/None args
# find_existing_tests(repo_path=...) # TODO: test with invalid repo_path
from codebase_genome import main
def test_main():
"""Test main (line 231 in codebase_genome.py)."""
result = main()
assert result is not None or result is None # TODO: real assertion
def test_main_edge_cases():
"""Edge cases for main."""
# main takes no args — test idempotency
r1 = main()
r2 = main()
# assert r1 == r2 # TODO: uncomment if deterministic
from evennia_tools.layout import room_keys
def test_room_keys():
"""Test room_keys (line 54 in evennia_tools/layout.py)."""
result = room_keys()
assert result is not None or result is None # TODO: real assertion
def test_room_keys_edge_cases():
"""Edge cases for room_keys."""
# room_keys takes no args — test idempotency
r1 = room_keys()
r2 = room_keys()
# assert r1 == r2 # TODO: uncomment if deterministic
from evennia_tools.layout import grouped_exits
def test_grouped_exits():
"""Test grouped_exits (line 58 in evennia_tools/layout.py)."""
result = grouped_exits()
assert result is not None or result is None # TODO: real assertion
def test_grouped_exits_edge_cases():
"""Edge cases for grouped_exits."""
# grouped_exits takes no args — test idempotency
r1 = grouped_exits()
r2 = grouped_exits()
# assert r1 == r2 # TODO: uncomment if deterministic
from evennia_tools.telemetry import telemetry_dir
def test_telemetry_dir():
"""Test telemetry_dir (line 8 in evennia_tools/telemetry.py)."""
# TODO: provide valid arguments for: base_dir
result = telemetry_dir(None)
assert result is not None or result is None # TODO: real assertion
def test_telemetry_dir_edge_cases():
"""Edge cases for telemetry_dir."""
# Test with empty/zero/None args
# telemetry_dir(base_dir=...) # TODO: test with invalid base_dir
from evennia_tools.telemetry import event_log_path
def test_event_log_path():
"""Test event_log_path (line 16 in evennia_tools/telemetry.py)."""
# TODO: provide valid arguments for: session_id, base_dir
result = event_log_path(None, None)
assert result is not None or result is None # TODO: real assertion
def test_event_log_path_edge_cases():
"""Edge cases for event_log_path."""
# Test with empty/zero/None args
# event_log_path(session_id=...) # TODO: test with invalid session_id
# event_log_path(base_dir=...) # TODO: test with invalid base_dir
from evennia_tools.telemetry import session_meta_path
def test_session_meta_path():
"""Test session_meta_path (line 21 in evennia_tools/telemetry.py)."""
# TODO: provide valid arguments for: session_id, base_dir
result = session_meta_path(None, None)
assert result is not None or result is None # TODO: real assertion
def test_session_meta_path_edge_cases():
"""Edge cases for session_meta_path."""
# Test with empty/zero/None args
# session_meta_path(session_id=...) # TODO: test with invalid session_id
# session_meta_path(base_dir=...) # TODO: test with invalid base_dir
from evennia_tools.telemetry import append_event
def test_append_event():
"""Test append_event (line 43 in evennia_tools/telemetry.py)."""
# TODO: provide valid arguments for: session_id, event, base_dir
result = append_event(None, None, None)
assert result is not None or result is None # TODO: real assertion
def test_append_event_edge_cases():
"""Edge cases for append_event."""
# Test with empty/zero/None args
# append_event(session_id=...) # TODO: test with invalid session_id
# append_event(event=...) # TODO: test with invalid event
# append_event(base_dir=...) # TODO: test with invalid base_dir
from evennia_tools.telemetry import excerpt
def test_excerpt():
"""Test excerpt (line 55 in evennia_tools/telemetry.py)."""
# TODO: provide valid arguments for: text, limit
result = excerpt(None, None)
assert result is not None or result is None # TODO: real assertion
def test_excerpt_edge_cases():
"""Edge cases for excerpt."""
# Test with empty/zero/None args
# excerpt(text=...) # TODO: test with invalid text
# excerpt(limit=...) # TODO: test with invalid limit
from evennia_tools.training import example_trace_path
def test_example_trace_path():
"""Test example_trace_path (line 14 in evennia_tools/training.py)."""
# TODO: provide valid arguments for: repo_root
result = example_trace_path(None)
assert result is not None or result is None # TODO: real assertion
def test_example_trace_path_edge_cases():
"""Edge cases for example_trace_path."""
# Test with empty/zero/None args
# example_trace_path(repo_root=...) # TODO: test with invalid repo_root
from evennia_tools.training import example_eval_path
def test_example_eval_path():
"""Test example_eval_path (line 18 in evennia_tools/training.py)."""
# TODO: provide valid arguments for: repo_root
result = example_eval_path(None)
assert result is not None or result is None # TODO: real assertion
def test_example_eval_path_edge_cases():
"""Edge cases for example_eval_path."""
# Test with empty/zero/None args
# example_eval_path(repo_root=...) # TODO: test with invalid repo_root
from metrics.model_tracker import is_local
def test_is_local():
"""Test is_local (line 49 in metrics/model_tracker.py)."""
# TODO: provide valid arguments for: model
result = is_local(None)
assert result is not None or result is None # TODO: real assertion
def test_is_local_edge_cases():
"""Edge cases for is_local."""
# Test with empty/zero/None args
# is_local(model=...) # TODO: test with invalid model
from metrics.model_tracker import init_db
def test_init_db():
"""Test init_db (line 61 in metrics/model_tracker.py)."""
result = init_db()
assert result is not None or result is None # TODO: real assertion
def test_init_db_edge_cases():
"""Edge cases for init_db."""
# init_db takes no args — test idempotency
r1 = init_db()
r2 = init_db()
# assert r1 == r2 # TODO: uncomment if deterministic
from metrics.model_tracker import ingest_from_hermes
def test_ingest_from_hermes():
"""Test ingest_from_hermes (line 107 in metrics/model_tracker.py)."""
# TODO: provide valid arguments for: conn, days
result = ingest_from_hermes(None, None)
assert result is not None or result is None # TODO: real assertion
def test_ingest_from_hermes_edge_cases():
"""Edge cases for ingest_from_hermes."""
# Test with empty/zero/None args
# ingest_from_hermes(conn=...) # TODO: test with invalid conn
# ingest_from_hermes(days=...) # TODO: test with invalid days
from metrics.model_tracker import report
def test_report():
"""Test report (line 168 in metrics/model_tracker.py)."""
# TODO: provide valid arguments for: conn, days
result = report(None, None)
assert result is not None or result is None # TODO: real assertion
def test_report_edge_cases():
"""Edge cases for report."""
# Test with empty/zero/None args
# report(conn=...) # TODO: test with invalid conn
# report(days=...) # TODO: test with invalid days
from metrics.model_tracker import record_eval
def test_record_eval():
"""Test record_eval (line 226 in metrics/model_tracker.py)."""
# TODO: provide valid arguments for: conn, model, task, score, latency, tokens_in, tokens_out, notes
result = record_eval(None, None, None, None, None, None, None, None)
assert result is not None or result is None # TODO: real assertion
def test_record_eval_edge_cases():
"""Edge cases for record_eval."""
# Test with empty/zero/None args
# record_eval(conn=...) # TODO: test with invalid conn
# record_eval(model=...) # TODO: test with invalid model
# record_eval(task=...) # TODO: test with invalid task
# record_eval(score=...) # TODO: test with invalid score
# record_eval(latency=...) # TODO: test with invalid latency
# record_eval(tokens_in=...) # TODO: test with invalid tokens_in
# record_eval(tokens_out=...) # TODO: test with invalid tokens_out
# record_eval(notes=...) # TODO: test with invalid notes
from metrics.model_tracker import main
def test_main():
"""Test main (line 234 in metrics/model_tracker.py)."""
result = main()
assert result is not None or result is None # TODO: real assertion
def test_main_edge_cases():
"""Edge cases for main."""
# main takes no args — test idempotency
r1 = main()
r2 = main()
# assert r1 == r2 # TODO: uncomment if deterministic
from morrowind.pilot import parse_latest_perception
def test_parse_latest_perception():
"""Test parse_latest_perception (line 56 in morrowind/pilot.py)."""
result = parse_latest_perception()
assert result is not None or result is None # TODO: real assertion
def test_parse_latest_perception_edge_cases():
"""Edge cases for parse_latest_perception."""
# parse_latest_perception takes no args — test idempotency
r1 = parse_latest_perception()
r2 = parse_latest_perception()
# assert r1 == r2 # TODO: uncomment if deterministic
from morrowind.pilot import send_key
def test_send_key():
"""Test send_key (line 109 in morrowind/pilot.py)."""
# TODO: provide valid arguments for: keycode, duration, shift
result = send_key(None, None, None)
assert result is not None or result is None # TODO: real assertion
def test_send_key_edge_cases():
"""Edge cases for send_key."""
# Test with empty/zero/None args
# send_key(keycode=...) # TODO: test with invalid keycode
# send_key(duration=...) # TODO: test with invalid duration
# send_key(shift=...) # TODO: test with invalid shift
from morrowind.pilot import move
def test_move():
"""Test move (line 126 in morrowind/pilot.py)."""
# TODO: provide valid arguments for: direction, duration, run
result = move(None, None, None)
assert result is not None or result is None # TODO: real assertion
def test_move_edge_cases():
"""Edge cases for move."""
# Test with empty/zero/None args
# move(direction=...) # TODO: test with invalid direction
# move(duration=...) # TODO: test with invalid duration
# move(run=...) # TODO: test with invalid run
from morrowind.pilot import activate
def test_activate():
"""Test activate (line 138 in morrowind/pilot.py)."""
result = activate()
assert result is not None or result is None # TODO: real assertion
def test_activate_edge_cases():
"""Edge cases for activate."""
# activate takes no args — test idempotency
r1 = activate()
r2 = activate()
# assert r1 == r2 # TODO: uncomment if deterministic
from morrowind.pilot import jump
def test_jump():
"""Test jump (line 144 in morrowind/pilot.py)."""
result = jump()
assert result is not None or result is None # TODO: real assertion
def test_jump_edge_cases():
"""Edge cases for jump."""
# jump takes no args — test idempotency
r1 = jump()
r2 = jump()
# assert r1 == r2 # TODO: uncomment if deterministic