claude-turing 4.4.0 → 4.6.0

package/templates/scripts/harness_doctor.py

@@ -32,7 +32,7 @@ REQUIRED_SCRIPTS = ["train.py", "prepare.py", "evaluate.py"]
 REQUIRED_CONFIG_FIELDS = ["evaluation"]
 
 CHECK_CATEGORIES = ["environment", "dependencies", "config", "experiment_log",
-                     "scripts", "disk_space", "git_state"]
+                     "scripts", "disk_space", "git_state", "claude_hooks"]
 
 
 # --- Individual Checks ---
@@ -288,9 +288,136 @@ def check_git_state(project_dir: str = ".") -> dict:
         }
 
 
+def check_claude_hooks(settings_path: str = ".claude/settings.local.json") -> dict:
+    """Check Claude Code project hook schema."""
+    path = Path(settings_path)
+    if not path.exists():
+        return {
+            "name": "Claude hooks",
+            "status": "WARN",
+            "detail": f"{settings_path} not found",
+            "issues": [],
+        }
+
+    try:
+        settings = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as e:
+        return {
+            "name": "Claude hooks",
+            "status": "FAIL",
+            "detail": f"{settings_path} has JSON parse error",
+            "issues": [str(e)],
+            "fixable": False,
+        }
+
+    hooks = settings.get("hooks", {})
+    if not isinstance(hooks, dict):
+        return {
+            "name": "Claude hooks",
+            "status": "FAIL",
+            "detail": "hooks must be a JSON object",
+            "issues": ["hooks must map event names to hook group arrays"],
+            "fixable": False,
+        }
+
+    issues = []
+    fixable = False
+    group_count = 0
+
+    for event, entries in hooks.items():
+        if not isinstance(entries, list):
+            issues.append(f"hooks.{event} must be an array")
+            continue
+
+        for index, entry in enumerate(entries):
+            if not isinstance(entry, dict):
+                issues.append(f"hooks.{event}[{index}] must be an object")
+                continue
+
+            if (
+                set(entry.keys()) == {"type", "command"}
+                and entry["type"] == "command"
+                and isinstance(entry["command"], str)
+            ):
+                issues.append(f"hooks.{event}[{index}] uses legacy bare command hook shape")
+                fixable = True
+                continue
+
+            nested_hooks = entry.get("hooks")
+            if not isinstance(nested_hooks, list):
+                issues.append(f"hooks.{event}[{index}].hooks must be an array")
+                continue
+
+            group_count += 1
+            for hook_index, hook in enumerate(nested_hooks):
+                if not isinstance(hook, dict):
+                    issues.append(f"hooks.{event}[{index}].hooks[{hook_index}] must be an object")
+                    continue
+                if hook.get("type") == "command" and not hook.get("command"):
+                    issues.append(f"hooks.{event}[{index}].hooks[{hook_index}] command hook missing command")
+
+    status = "FAIL" if issues else "PASS"
+    result = {
+        "name": "Claude hooks",
+        "status": status,
+        "detail": f"{group_count} hook groups valid" if not issues else f"{len(issues)} hook schema issue(s)",
+        "issues": issues,
+        "fixable": fixable,
+    }
+    if fixable:
+        result["fix"] = "Run /turing:doctor --fix to migrate legacy bare command hooks"
+    return result
+
+
 # --- Fix Operations ---
 
 
+def fix_claude_hooks(settings_path: str = ".claude/settings.local.json") -> dict:
+    """Migrate legacy bare command hooks into Claude Code hook groups."""
+    path = Path(settings_path)
+    if not path.exists():
+        return {"fixed": False, "reason": "Settings file not found"}
+
+    try:
+        settings = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return {"fixed": False, "reason": "Settings file has invalid JSON"}
+
+    hooks = settings.get("hooks")
+    if not isinstance(hooks, dict):
+        return {"fixed": False, "reason": "hooks is not a JSON object"}
+
+    migrated = 0
+    for event, entries in hooks.items():
+        if not isinstance(entries, list):
+            continue
+
+        fixed_entries = []
+        for entry in entries:
+            if (
+                isinstance(entry, dict)
+                and set(entry.keys()) == {"type", "command"}
+                and entry["type"] == "command"
+                and isinstance(entry["command"], str)
+            ):
+                fixed_entries.append({
+                    "matcher": "",
+                    "hooks": [{"type": "command", "command": entry["command"]}],
+                })
+                migrated += 1
+            else:
+                fixed_entries.append(entry)
+        hooks[event] = fixed_entries
+
+    if not migrated:
+        return {"fixed": False, "reason": "No legacy bare command hooks found"}
+
+    backup = path.with_suffix(path.suffix + ".bak")
+    shutil.copy2(path, backup)
+    path.write_text(json.dumps(settings, indent=2) + "\n", encoding="utf-8")
+    return {"fixed": True, "migrated": migrated, "backup": str(backup)}
+
+
 def fix_corrupt_log(log_path: str = DEFAULT_LOG_PATH) -> dict:
     """Remove corrupt lines from experiment log."""
     path = Path(log_path)
@@ -328,6 +455,7 @@ def fix_corrupt_log(log_path: str = DEFAULT_LOG_PATH) -> dict:
 def run_doctor(
     config_path: str = "config.yaml",
     log_path: str = DEFAULT_LOG_PATH,
+    hooks_path: str = ".claude/settings.local.json",
     fix: bool = False,
     verbose: bool = False,
 ) -> dict:
@@ -336,6 +464,7 @@ def run_doctor(
     Args:
         config_path: Path to config.yaml.
         log_path: Path to experiment log.
+        hooks_path: Path to Claude Code project settings.
         fix: If True, auto-fix safe issues.
         verbose: Include detailed info.
 
@@ -350,6 +479,7 @@ def run_doctor(
         check_scripts(),
         check_disk_space(),
         check_git_state(),
+        check_claude_hooks(hooks_path),
     ]
 
     # Apply fixes if requested
@@ -366,6 +496,18 @@ def run_doctor(
                         checks[i] = check_experiment_log(log_path)
                         break
 
+        hooks_check = next((c for c in checks if c["name"] == "Claude hooks"), None)
+        if hooks_check and hooks_check.get("fixable"):
+            fix_result = fix_claude_hooks(hooks_path)
+            if fix_result.get("fixed"):
+                fixes_applied.append(
+                    f"Migrated {fix_result['migrated']} legacy Claude hook entries (backup: {fix_result['backup']})"
+                )
+                for i, c in enumerate(checks):
+                    if c["name"] == "Claude hooks":
+                        checks[i] = check_claude_hooks(hooks_path)
+                        break
+
     # Compute score
     passed = sum(1 for c in checks if c["status"] == "PASS")
     warned = sum(1 for c in checks if c["status"] == "WARN")
@@ -441,6 +583,7 @@ def main():
     parser.add_argument("--verbose", action="store_true", help="Show detailed info")
     parser.add_argument("--config", default="config.yaml", help="Path to config.yaml")
     parser.add_argument("--log", default=DEFAULT_LOG_PATH, help="Path to experiment log")
+    parser.add_argument("--hooks", default=".claude/settings.local.json", help="Path to Claude Code settings")
     parser.add_argument("--json", action="store_true", help="Output raw JSON")
 
     args = parser.parse_args()
@@ -448,6 +591,7 @@ def main():
     report = run_doctor(
         config_path=args.config,
         log_path=args.log,
+        hooks_path=args.hooks,
         fix=args.fix,
         verbose=args.verbose,
     )

package/templates/scripts/scaffold.py

@@ -34,6 +34,8 @@ PLACEHOLDER_MAP = {
     "ML_DIR": "ml_dir",
     "DATA_SOURCE": "data_source",
     "METRIC_DIRECTION": "metric_direction",
+    "LOWER_IS_BETTER": "lower_is_better",
+    "MEMORY_DIR_NAME": "memory_dir_name",
 }
 
 # Files to copy from templates/ to the ML directory
@@ -223,32 +225,49 @@ SHELL_SCRIPTS = [
 
 def find_templates_dir() -> Path | None:
     """Locate the templates directory relative to this script or plugin root."""
-    # When running from a scaffolded project, templates are local
+    env_templates_dir = os.environ.get("TURING_TEMPLATES_DIR")
+    if env_templates_dir:
+        candidate = Path(env_templates_dir).expanduser()
+        if (candidate / "prepare.py").exists():
+            return candidate
+
     script_dir = Path(__file__).parent
 
-    # Check: are we inside the plugin's templates/scripts/ ?
-    candidate = script_dir.parent  # templates/
-    if (candidate / "prepare.py").exists():
-        return candidate
-
-    # Check: plugin root (two levels up from scripts/)
-    plugin_root = script_dir.parent.parent
-    candidate = plugin_root / "templates"
-    if candidate.exists() and (candidate / "prepare.py").exists():
-        return candidate
-
-    # Search common plugin locations
-    home = Path.home()
-    for pattern in [
-        home / ".claude" / "plugins" / "*" / "templates",
+    project_command_templates = [
+        path / ".claude" / "commands" / "turing" / "templates"
+        for path in [Path.cwd(), *Path.cwd().parents]
+    ]
+
+    for candidate in [
+        script_dir.parent,
+        script_dir.parent.parent / "templates",
+        *project_command_templates,
+        Path.home() / ".claude" / "commands" / "turing" / "templates",
+        Path.cwd() / "node_modules" / "claude-turing" / "templates",
     ]:
-        for match in sorted(pattern.parent.glob(pattern.name)):
-            if (match / "prepare.py").exists():
-                return match
+        if (candidate / "prepare.py").exists():
+            return candidate
+
+    plugins_dir = Path.home() / ".claude" / "plugins"
+    for match in sorted(plugins_dir.glob("*/templates")):
+        if (match / "prepare.py").exists():
+            return match
 
     return None
 
 
+def derive_values(values: dict[str, str]) -> dict[str, str]:
+    """Add scaffold values derived from user-provided fields."""
+    derived = dict(values)
+    derived["lower_is_better"] = (
+        "true" if derived.get("metric_direction", "").lower() == "lower" else "false"
+    )
+    derived["memory_dir_name"] = re.sub(
+        r"[^a-zA-Z0-9_.-]+", "-", derived["project_name"]
+    ).strip("-")
+    return derived
+
+
 def replace_placeholders(text: str, values: dict[str, str]) -> str:
     """Replace all {{PLACEHOLDER}} markers in text with values."""
     for placeholder, arg_name in PLACEHOLDER_MAP.items():
@@ -276,6 +295,7 @@ def scaffold_project(
     Returns:
         Dict with counts: files_copied, placeholders_replaced, dirs_created.
     """
+    values = derive_values(values)
     target = Path(ml_dir)
     target.mkdir(parents=True, exist_ok=True)
 
@@ -329,7 +349,7 @@ def scaffold_project(
                 continue
 
     # Setup agent memory
-    memory_dir = Path(".claude") / "agent-memory" / "ml-researcher"
+    memory_dir = Path(".claude") / "agent-memory" / f"ml-researcher-{values['memory_dir_name']}"
     memory_dir.mkdir(parents=True, exist_ok=True)
     memory_src = templates_dir / "MEMORY.md"
     if memory_src.exists():
@@ -348,6 +368,14 @@ def scaffold_project(
     return stats
 
 
+def make_command_hook_group(command: str, matcher: str = "") -> dict:
+    """Build a Claude Code command hook group."""
+    return {
+        "matcher": matcher,
+        "hooks": [{"type": "command", "command": command}],
+    }
+
+
 def _setup_hooks(ml_dir: str) -> None:
     """Configure Claude Code hooks in .claude/settings.local.json."""
     settings_path = Path(".claude") / "settings.local.json"
@@ -366,20 +394,14 @@ def _setup_hooks(ml_dir: str) -> None:
     post_hooks = hooks.get("PostToolUse", [])
     post_hook_cmd = f"bash {ml_dir}/scripts/post-train-hook.sh"
     if not any(post_hook_cmd in str(h) for h in post_hooks):
-        post_hooks.append({
-            "matcher": "Bash",
-            "hooks": [{"type": "command", "command": post_hook_cmd}],
-        })
+        post_hooks.append(make_command_hook_group(post_hook_cmd, matcher="Bash"))
     hooks["PostToolUse"] = post_hooks
 
     # Stop hook for convergence
     stop_hooks = hooks.get("Stop", [])
     stop_hook_cmd = f"bash {ml_dir}/scripts/stop-hook.sh"
     if not any(stop_hook_cmd in str(h) for h in stop_hooks):
-        stop_hooks.append({
-            "type": "command",
-            "command": stop_hook_cmd,
-        })
+        stop_hooks.append(make_command_hook_group(stop_hook_cmd))
     hooks["Stop"] = stop_hooks
 
     settings["hooks"] = hooks