cowork-flow 0.0.26 → 0.0.27

package/template/.cowork-flow/scripts/common/validate_coding_standards.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""
+Coding standards reminder script.
+
+Reads coding standards from markdown files and outputs a summary.
+Does NOT perform validation - only provides guidance for Agent review.
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from pathlib import Path
+
+
+def get_coding_standards_summary(
+    repo_root: Path,
+    task_dir: Path,
+) -> str:
+    """
+    Get coding standards summary based on changed files.
+
+    Args:
+        repo_root: Repository root directory
+        task_dir: Task directory
+
+    Returns:
+        Summary string of relevant coding standards
+    """
+    # Get modified files
+    modified_files = _get_modified_files(repo_root)
+    if not modified_files:
+        return ""
+
+    # Classify files
+    backend_files = [f for f in modified_files if _is_backend_file(f)]
+    frontend_files = [f for f in modified_files if _is_frontend_file(f)]
+
+    summaries = []
+
+    # Get backend standards summary
+    if backend_files:
+        backend_summary = _get_standards_summary(repo_root, "backend")
+        if backend_summary:
+            summaries.append(f"=== Backend Coding Standards ===\n{backend_summary}")
+
+    # Get frontend standards summary
+    if frontend_files:
+        frontend_summary = _get_standards_summary(repo_root, "frontend")
+        if frontend_summary:
+            summaries.append(f"=== Frontend Coding Standards ===\n{frontend_summary}")
+
+    return "\n\n".join(summaries)
+
+
+def _get_modified_files(repo_root: Path) -> list[str]:
+    """Get list of modified files"""
+    try:
+        result = subprocess.run(
+            ["git", "diff", "--name-only"],
+            cwd=repo_root,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0:
+            return [f for f in result.stdout.strip().split("\n") if f]
+        return []
+    except Exception:
+        return []
+
+
+def _is_backend_file(file_path: str) -> bool:
+    """Check if file is a backend file"""
+    backend_patterns = [
+        r"\.py$",
+        r"\.java$",
+        r"\.go$",
+        r"\.rs$",
+        r"\.rb$",
+    ]
+    return any(re.search(p, file_path) for p in backend_patterns)
+
+
+def _is_frontend_file(file_path: str) -> bool:
+    """Check if file is a frontend file"""
+    frontend_patterns = [
+        r"\.tsx$",
+        r"\.jsx$",
+        r"\.vue$",
+        r"\.svelte$",
+    ]
+    return any(re.search(p, file_path) for p in frontend_patterns)
+
+
+def _get_standards_summary(repo_root: Path, category: str) -> str:
+    """
+    Get summary of coding standards from markdown files.
+
+    Args:
+        repo_root: Repository root directory
+        category: 'backend' or 'frontend'
+
+    Returns:
+        Summary string
+    """
+    spec_dir = repo_root / ".cowork-flow" / "spec" / category
+    if not spec_dir.exists():
+        return ""
+
+    summaries = []
+
+    for md_file in sorted(spec_dir.glob("*.md")):
+        if md_file.name == "index.md":
+            continue
+
+        content = md_file.read_text(encoding="utf-8")
+        rules = _extract_key_rules(content)
+
+        if rules:
+            summaries.append(f"File: {md_file.name}")
+            for rule in rules[:5]:  # Limit to top 5 rules per file
+                summaries.append(f"  - {rule}")
+            summaries.append("")
+
+    return "\n".join(summaries)
+
+
+def _extract_key_rules(content: str) -> list[str]:
+    """Extract key rules from markdown content"""
+    rules = []
+
+    # Extract forbidden patterns (Must not, Should not, Do not, etc.)
+    # Also match Chinese patterns
+    forbidden_patterns = [
+        r"[-*]\s*(Must not|Should not|Do not|Never|Avoid)\s+(.+)",
+        r"[-*]\s*(禁止|不得|不能|不应|避免|不要|不可)\s*(.+)",
+        r"[-*]\s*(.+不得|.+不能|.+不应|.+避免|.+不要)\s*(.+)",
+    ]
+
+    for line in content.split("\n"):
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+
+        for pattern in forbidden_patterns:
+            match = re.search(pattern, line, re.IGNORECASE)
+            if match:
+                # Extract the rule text
+                rule_text = line.lstrip("-* ").strip()
+                if len(rule_text) > 5:  # Skip very short rules
+                    rules.append(rule_text[:80])  # Limit length
+                    break  # Only match one pattern per line
+
+    return rules[:10]  # Return top 10 rules
+
+
+def main():
+    """Main entry point"""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Get coding standards summary")
+    parser.add_argument("--task-dir", required=True, help="Task directory path")
+    parser.add_argument("--repo-root", default=".", help="Repository root path")
+
+    args = parser.parse_args()
+
+    repo_root = Path(args.repo_root).resolve()
+    task_dir = Path(args.task_dir).resolve()
+
+    summary = get_coding_standards_summary(repo_root, task_dir)
+
+    if summary:
+        print(summary)
+    else:
+        print("No relevant coding standards found for changed files.")
+
+
+if __name__ == "__main__":
+    main()

package/template/.cowork-flow/scripts/common/validate_implementation.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""
+Implementation validation script.
+
+Validates code changes against forbidden action rules after task implementation.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+
+def validate_implementation(
+    repo_root: Path,
+    task_dir: Path,
+) -> list[dict]:
+    """
+    Validate code changes against implementation rules.
+
+    Args:
+        repo_root: Repository root directory
+        task_dir: Task directory
+
+    Returns:
+        List of violations
+    """
+    violations = []
+
+    # Get git diff
+    diff_output = _get_git_diff(repo_root)
+    if not diff_output:
+        return violations
+
+    # Check forbidden action rules
+    violations.extend(_check_spec_file_modifications(diff_output, repo_root))
+    violations.extend(_check_premature_abstraction(diff_output))
+    violations.extend(_check_unrequested_features(diff_output, task_dir))
+
+    return violations
+
+
+def _get_git_diff(repo_root: Path) -> str:
+    """Get git diff output"""
+    try:
+        result = subprocess.run(
+            ["git", "diff", "--name-only"],
+            cwd=repo_root,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            return ""
+
+        # Get actual diff content
+        files = result.stdout.strip().split("\n")
+        if not files or files == [""]:
+            return ""
+
+        diff_result = subprocess.run(
+            ["git", "diff"] + files,
+            cwd=repo_root,
+            capture_output=True,
+            text=True,
+        )
+        return diff_result.stdout
+    except Exception:
+        return ""
+
+
+def _check_spec_file_modifications(
+    diff_output: str,
+    repo_root: Path,
+) -> list[dict]:
+    """R-AG-002: Check if spec files were modified"""
+    violations = []
+
+    # Spec file path patterns
+    spec_patterns = [
+        r"\.cowork-flow/spec/",
+        r"\.cowork-flow/workflow\.md",
+        r"AGENTS\.md",
+        r"CLAUDE\.md",
+    ]
+
+    for pattern in spec_patterns:
+        if re.search(pattern, diff_output):
+            violations.append({
+                "rule_id": "R-AG-002",
+                "type": "forbidden_action",
+                "severity": "block",
+                "passed": False,
+                "message": "Subagent attempted to modify spec files",
+                "file": pattern,
+                "fix_hint": "Spec files can only be modified by main session",
+            })
+
+    return violations
+
+
+def _check_premature_abstraction(diff_output: str) -> list[dict]:
+    """R-AG-006: Check if premature abstraction was used"""
+    violations = []
+
+    # Detection patterns for abstraction
+    abstraction_patterns = [
+        r"def\s+base_",           # base_ prefixed functions
+        r"class\s+Abstract",      # Abstract prefixed classes
+        r"class\s+Base",          # Base prefixed classes
+        r"class\s+Generic",       # Generic prefixed classes
+        r"def\s+create_factory",  # Factory pattern
+        r"def\s+get_instance",    # Singleton pattern
+    ]
+
+    for pattern in abstraction_patterns:
+        matches = re.findall(pattern, diff_output)
+        if matches:
+            violations.append({
+                "rule_id": "R-AG-006",
+                "type": "forbidden_action",
+                "severity": "warn",
+                "passed": False,
+                "message": f"Premature abstraction detected: {pattern}",
+                "file": "",
+                "fix_hint": "Keep code simple and direct, only abstract when reuse is confirmed",
+            })
+
+    return violations
+
+
+def _check_unrequested_features(
+    diff_output: str,
+    task_dir: Path,
+) -> list[dict]:
+    """R-AG-005: Check if unrequested features were introduced"""
+    violations = []
+
+    # Read PRD
+    prd_path = task_dir / "prd.md"
+    if not prd_path.exists():
+        return violations
+
+    prd_content = prd_path.read_text(encoding="utf-8")
+
+    # Check for obvious extra features
+    # This is a simple heuristic check, actual implementation may need more complex NLP analysis
+    feature_indicators = [
+        r"Added.*feature",
+        r"New.*functionality",
+        r"Implemented.*module",
+    ]
+
+    for pattern in feature_indicators:
+        if re.search(pattern, diff_output) and not re.search(pattern, prd_content):
+            violations.append({
+                "rule_id": "R-AG-005",
+                "type": "forbidden_action",
+                "severity": "block",
+                "passed": False,
+                "message": "Unrequested feature introduced",
+                "file": "",
+                "fix_hint": "Only implement features explicitly required by the PRD",
+            })
+
+    return violations
+
+
+def main():
+    """Main entry point"""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Validate implementation against spec")
+    parser.add_argument("--task-dir", required=True, help="Task directory path")
+    parser.add_argument("--repo-root", default=".", help="Repository root path")
+
+    args = parser.parse_args()
+
+    repo_root = Path(args.repo_root).resolve()
+    task_dir = Path(args.task_dir).resolve()
+
+    violations = validate_implementation(repo_root, task_dir)
+
+    if violations:
+        for v in violations:
+            print(json.dumps(v, ensure_ascii=False))
+        sys.exit(1)
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/template/.cowork-flow/scripts/common/validate_rules.py

@@ -0,0 +1,302 @@
+#!/usr/bin/env python3
+"""
+Rule validation script for cowork-flow workflow.
+
+Validates rules at task start/complete checkpoints.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def validate_rules(
+    repo_root: Path,
+    scope: str,
+    task_dir: Path | None = None,
+) -> list[dict]:
+    """
+    Validate rules for given scope.
+
+    Args:
+        repo_root: Repository root path
+        scope: Validation scope (task_start, task_complete, check, implement)
+        task_dir: Optional task directory path
+
+    Returns:
+        List of violations (empty if all rules pass)
+    """
+    violations = []
+
+    # Load rules
+    rules_path = repo_root / ".cowork-flow" / "spec" / "rules.json"
+    if not rules_path.exists():
+        return violations
+
+    with open(rules_path) as f:
+        rules_data = json.load(f)
+
+    rules = rules_data.get("rules", [])
+
+    # Filter rules by scope
+    applicable_rules = [
+        r for r in rules
+        if r["scope"] == scope or r["scope"] == "all"
+    ]
+
+    # Validate each rule
+    for rule in applicable_rules:
+        violation = _validate_rule(rule, repo_root, task_dir)
+        if violation:
+            violations.append(violation)
+
+    return violations
+
+
+def _validate_rule(
+    rule: dict,
+    repo_root: Path,
+    task_dir: Path | None,
+) -> dict | None:
+    """Validate a single rule. Returns violation dict if rule fails."""
+    rule_type = rule["type"]
+
+    if rule_type == "phase_gate":
+        return _validate_phase_gate(rule, repo_root, task_dir)
+    elif rule_type == "forbidden_action":
+        # Forbidden actions are validated at runtime, not at checkpoints
+        return None
+
+    return None
+
+
+def _validate_phase_gate(
+    rule: dict,
+    repo_root: Path,
+    task_dir: Path | None,
+) -> dict | None:
+    """Validate a phase_gate rule."""
+    rule_id = rule["id"]
+
+    # R-WF-001 to R-WF-005: L2 readiness checks
+    if rule_id in ["R-WF-001", "R-WF-002", "R-WF-003", "R-WF-004", "R-WF-005"]:
+        if task_dir is None:
+            return None
+
+        # Check if task has L2 change
+        change_dir = _find_linked_change(repo_root, task_dir)
+        if change_dir is None:
+            return None
+
+        # Validate specific file requirements
+        if rule_id == "R-WF-001":
+            return _check_file_exists(change_dir / "proposal.md", rule, "proposal.md")
+        elif rule_id == "R-WF-002":
+            return _check_file_exists(change_dir / "spec.md", rule, "spec.md")
+        elif rule_id == "R-WF-003":
+            return _check_file_exists(change_dir / "design.md", rule, "design.md")
+        elif rule_id == "R-WF-004":
+            return _check_plan_link(repo_root, change_dir, rule)
+        elif rule_id == "R-WF-005":
+            return _check_task_link(change_dir, rule)
+
+    # R-WF-006: Implementation without failing test
+    if rule_id == "R-WF-006":
+        # This is a warn-level rule, just log
+        return None
+
+    # R-WF-007: Task completion without check
+    if rule_id == "R-WF-007":
+        if scope == "task_complete" and task_dir:
+            task_json = task_dir / "task.json"
+            if task_json.exists():
+                with open(task_json) as f:
+                    task_data = json.load(f)
+                if task_data.get("status") != "review":
+                    return {
+                        "rule_id": rule_id,
+                        "type": rule["type"],
+                        "severity": rule["severity"],
+                        "passed": False,
+                        "message": rule["message"],
+                        "file": str(task_json),
+                        "fix_hint": rule["fix_hint"],
+                    }
+
+    return None
+
+
+def _find_linked_change(repo_root: Path, task_dir: Path) -> Path | None:
+    """Find the change directory linked to a task."""
+    changes_dir = repo_root / ".cowork-flow" / "changes"
+    if not changes_dir.exists():
+        return None
+
+    task_name = task_dir.name
+    for change_dir in changes_dir.iterdir():
+        if change_dir.is_dir() and change_dir.name != "archive":
+            change_yaml = change_dir / "change.yaml"
+            if change_yaml.exists():
+                with open(change_yaml) as f:
+                    content = f.read()
+                if task_name in content:
+                    return change_dir
+
+    return None
+
+
+def _check_file_exists(
+    file_path: Path,
+    rule: dict,
+    filename: str,
+) -> dict | None:
+    """Check if a required file exists and is not empty."""
+    if not file_path.exists():
+        return {
+            "rule_id": rule["id"],
+            "type": rule["type"],
+            "severity": rule["severity"],
+            "passed": False,
+            "message": f"L2 readiness: {filename} is missing",
+            "file": str(file_path),
+            "fix_hint": rule["fix_hint"],
+        }
+
+    if file_path.stat().st_size == 0:
+        return {
+            "rule_id": rule["id"],
+            "type": rule["type"],
+            "severity": rule["severity"],
+            "passed": False,
+            "message": f"L2 readiness: {filename} is empty",
+            "file": str(file_path),
+            "fix_hint": rule["fix_hint"],
+        }
+
+    return None
+
+
+def _check_plan_link(
+    repo_root: Path,
+    change_dir: Path,
+    rule: dict,
+) -> dict | None:
+    """Check if change has a plan link."""
+    change_yaml = change_dir / "change.yaml"
+    if not change_yaml.exists():
+        return {
+            "rule_id": rule["id"],
+            "type": rule["type"],
+            "severity": rule["severity"],
+            "passed": False,
+            "message": "L2 readiness: change.yaml is missing",
+            "file": str(change_yaml),
+            "fix_hint": rule["fix_hint"],
+        }
+
+    with open(change_yaml) as f:
+        content = f.read()
+
+    if "plan:" not in content or "plan: null" in content:
+        return {
+            "rule_id": rule["id"],
+            "type": rule["type"],
+            "severity": rule["severity"],
+            "passed": False,
+            "message": "L2 readiness: plan link is missing",
+            "file": str(change_yaml),
+            "fix_hint": rule["fix_hint"],
+        }
+
+    return None
+
+
+def _check_task_link(
+    change_dir: Path,
+    rule: dict,
+) -> dict | None:
+    """Check if change has a task link."""
+    change_yaml = change_dir / "change.yaml"
+    if not change_yaml.exists():
+        return {
+            "rule_id": rule["id"],
+            "type": rule["type"],
+            "severity": rule["severity"],
+            "passed": False,
+            "message": "L2 readiness: change.yaml is missing",
+            "file": str(change_yaml),
+            "fix_hint": rule["fix_hint"],
+        }
+
+    with open(change_yaml) as f:
+        content = f.read()
+
+    if "tasks:" not in content:
+        return {
+            "rule_id": rule["id"],
+            "type": rule["type"],
+            "severity": rule["severity"],
+            "passed": False,
+            "message": "L2 readiness: task link is missing",
+            "file": str(change_yaml),
+            "fix_hint": rule["fix_hint"],
+        }
+
+    return None
+
+
+def log_violations(
+    violations: list[dict],
+    scope: str,
+    task_dir: Path | None,
+    repo_root: Path,
+) -> None:
+    """Log violations to rule-events.jsonl."""
+    if not violations:
+        return
+
+    log_dir = repo_root / ".cowork-flow" / "logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    log_path = log_dir / "rule-events.jsonl"
+
+    log_entry = {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "scope": scope,
+        "task_dir": str(task_dir) if task_dir else None,
+        "violations": violations,
+    }
+
+    with open(log_path, "a") as f:
+        f.write(json.dumps(log_entry, ensure_ascii=False) + "\n")
+
+
+def main():
+    """Main entry point for CLI usage."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Validate workflow rules")
+    parser.add_argument("scope", choices=["task_start", "task_complete", "check", "implement"])
+    parser.add_argument("--task-dir", help="Task directory path")
+    parser.add_argument("--repo-root", default=".", help="Repository root path")
+
+    args = parser.parse_args()
+
+    repo_root = Path(args.repo_root).resolve()
+    task_dir = Path(args.task_dir).resolve() if args.task_dir else None
+
+    violations = validate_rules(repo_root, args.scope, task_dir)
+
+    if violations:
+        log_violations(violations, args.scope, task_dir, repo_root)
+        for v in violations:
+            print(json.dumps(v, ensure_ascii=False))
+        sys.exit(1)
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()