@danmoisan/drm-copilot-mcp 0.0.1

package/resources/scripts/dev_tools/new_active_feature_folder_markdown.py

@@ -0,0 +1,252 @@
+"""Markdown transformation helpers for active feature folder creation."""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from dev_tools.new_active_feature_folder_models import PLACEHOLDERS
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+def format_checklist(text: str) -> str:
+    """Normalize freeform checklist text into markdown checkboxes."""
+    lines: list[str] = []
+    for raw_line in text.splitlines():
+        trimmed = raw_line.strip()
+        if not trimmed:
+            continue
+        if re.match(r"^-\s*\[?\s*\]", trimmed):
+            lines.append(trimmed)
+        elif trimmed.startswith("-"):
+            lines.append(trimmed)
+        else:
+            lines.append(f"- [ ] {trimmed}")
+    return "\n".join(lines)
+
+
+def get_section(content: str, name: str) -> str:
+    """Extract a markdown section body by heading."""
+    pattern = re.compile(
+        rf"^\s*##\s+{re.escape(name)}\s*\r?\n(.*?)(?=^\s*##\s+|\Z)",
+        re.DOTALL | re.MULTILINE,
+    )
+    match = pattern.search(content)
+    if not match:
+        return ""
+    return match.group(1).strip()
+
+
+def upsert_work_mode_marker(content: str, mode: str) -> str:
+    """Insert or update work-mode marker directly above first `##` heading."""
+    marker_line = f"- Work Mode: {mode}"
+    marker_pattern = re.compile(
+        r"^- Work Mode:\s*(minor-audit|full-feature|full-bug|full)\s*$"
+    )
+    lines = [line for line in content.splitlines() if not marker_pattern.match(line)]
+
+    for idx, line in enumerate(lines):
+        if line.lstrip().startswith("## "):
+            lines.insert(idx, "")
+            lines.insert(idx, marker_line)
+            return "\n".join(lines)
+
+    if lines and lines[-1] != "":
+        lines.append("")
+    lines.append(marker_line)
+    return "\n".join(lines)
+
+
+def set_section(content: str, name: str, body: str) -> str:
+    """Set or append a markdown section body."""
+    if not body or not body.strip():
+        return content
+
+    pattern = re.compile(
+        rf"(^##\s+{re.escape(name)}\s*\r?\n)(.*?)(?=^\s*##\s+|\Z)",
+        re.DOTALL | re.MULTILINE,
+    )
+    if pattern.search(content):
+        return pattern.sub(
+            lambda match: f"{match.group(1)}{body}\n\n",
+            content,
+            count=1,
+        )
+
+    trimmed = content.rstrip()
+    if trimmed:
+        trimmed += "\n\n"
+    return f"{trimmed}## {name}\n{body}\n"
+
+
+def prepend_to_section_body(section_body: str, prefix: str) -> str:
+    """Prepend text to an existing section body while preserving content."""
+    trimmed_prefix = prefix.strip()
+    if not trimmed_prefix:
+        return section_body
+
+    trimmed_body = section_body.strip()
+    if not trimmed_body:
+        return f"{trimmed_prefix}\n"
+    return f"{trimmed_prefix}\n\n{trimmed_body}\n"
+
+
+def update_section_body(
+    content: str,
+    section_name: str,
+    updater: Callable[[str], str],
+) -> tuple[str, bool]:
+    """Update a `##` section body using a transformation function."""
+    pattern = re.compile(
+        rf"(^##\s+{re.escape(section_name)}\s*\r?\n)(.*?)(?=^\s*##\s+|\Z)",
+        re.DOTALL | re.MULTILINE,
+    )
+    match = pattern.search(content)
+    if not match:
+        return content, False
+
+    header = match.group(1)
+    body = match.group(2)
+    updated_body = updater(body)
+    if updated_body == body:
+        return content, False
+
+    return (
+        pattern.sub(
+            lambda _match: f"{header}{updated_body}\n",
+            content,
+            count=1,
+        ),
+        True,
+    )
+
+
+def set_header_placeholder(
+    content: str,
+    feature_name: str,
+    issue_field: str,
+    owner_field: str,
+    updated_field: str,
+    status_field: str | None = None,
+    parent_field: str | None = None,
+    version_field: str | None = None,
+) -> str:
+    """Replace template placeholders in the frontmatter/header block."""
+    result = content
+    for placeholder in PLACEHOLDERS:
+        result = result.replace(placeholder, feature_name)
+    result = result.replace("<issue>", issue_field)
+    if parent_field is not None:
+        result = result.replace("<parent-id>", parent_field)
+    if status_field is not None:
+        result = result.replace("<status>", status_field)
+    if version_field is not None:
+        result = result.replace("<version_number>", version_field)
+    result = re.sub(r"#`?<id>`?", issue_field, result)
+    result = result.replace("<#id or TBD>", issue_field)
+    result = result.replace("#<tracking-issue>", issue_field)
+
+    result = re.sub(
+        r"^-\s*\*\*Issue:\*\*\s+.*$",
+        f"- **Issue:** {issue_field}",
+        result,
+        flags=re.MULTILINE,
+    )
+    result = re.sub(
+        r"^-\s*Issue\s*:\s+.*$",
+        f"- Issue: {issue_field}",
+        result,
+        flags=re.MULTILINE,
+    )
+
+    result = re.sub(
+        r"^-\s*\*\*Owner:\*\*\s+(?:name|<name>|.*)$",
+        f"- **Owner:** {owner_field}",
+        result,
+        flags=re.MULTILINE,
+    )
+    result = re.sub(
+        r"^-\s*Owner\s*:\s+(?:name|<name>|.*)$",
+        f"- Owner: {owner_field}",
+        result,
+        flags=re.MULTILINE,
+    )
+
+    if parent_field is not None:
+        result = re.sub(
+            r"^-\s*\*\*Parent \(optional\):\*\*\s+.*$",
+            f"- **Parent (optional):** {parent_field}",
+            result,
+            flags=re.MULTILINE,
+        )
+        result = re.sub(
+            r"^-\s*Parent \(optional\)\s*:\s+.*$",
+            f"- Parent (optional): {parent_field}",
+            result,
+            flags=re.MULTILINE,
+        )
+
+    result = re.sub(
+        r"^-\s*\*\*Last Updated:\*\*\s+.*$",
+        f"- **Last Updated:** {updated_field}",
+        result,
+        flags=re.MULTILINE,
+    )
+    result = re.sub(
+        r"^-\s*Last Updated\s*:\s+.*$",
+        f"- Last Updated: {updated_field}",
+        result,
+        flags=re.MULTILINE,
+    )
+
+    result = re.sub(
+        r"^-\s*\*\*Date:\*\*\s+.*$",
+        f"- **Date:** {updated_field}",
+        result,
+        flags=re.MULTILINE,
+    )
+    result = re.sub(
+        r"^-\s*Date\s*:\s+YYYY-MM-DD$",
+        f"- Date: {updated_field}",
+        result,
+        flags=re.MULTILINE,
+    )
+    result = result.replace("<yyyy-MM-ddTHH-mm>", updated_field)
+
+    if status_field is not None:
+        result = re.sub(
+            r"^-\s*\*\*Status:\*\*\s+.*$",
+            f"- **Status:** {status_field}",
+            result,
+            flags=re.MULTILINE,
+        )
+        result = re.sub(
+            r"^-\s*Status\s*:\s+.*$",
+            f"- Status: {status_field}",
+            result,
+            flags=re.MULTILINE,
+        )
+
+    if version_field is not None:
+        result = re.sub(
+            r"^-\s*\*\*Version:\*\*\s+.*$",
+            f"- **Version:** {version_field}",
+            result,
+            flags=re.MULTILINE,
+        )
+        result = re.sub(
+            r"^-\s*Version\s*:\s+.*$",
+            f"- Version: {version_field}",
+            result,
+            flags=re.MULTILINE,
+        )
+
+    if not re.search(
+        r"^-\s*(?:\*\*Issue:\*\*\s*|Issue\s*:)\s*#?",
+        result,
+        flags=re.MULTILINE,
+    ):
+        result = f"- Issue: {issue_field}\n{result}"
+    return result

package/resources/scripts/dev_tools/new_active_feature_folder_models.py

@@ -0,0 +1,136 @@
+"""Core models and basic utilities for active feature folder creation."""
+
+from __future__ import annotations
+
+import re
+import shutil
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, Protocol
+from zoneinfo import ZoneInfo
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable
+
+NAME_PATTERN = re.compile(r"^[a-z0-9]+(?:[-_][a-z0-9]+)*$")
+EXCLUDED_POTENTIAL_NAMES = {"template.md", "README.md"}
+PLACEHOLDERS = [
+    "<feature-name>",
+    "<refactor-name>",
+    "<epic-name>",
+    "<name>",
+    "<bug-name>",
+]
+
+PLAN_TIMESTAMP_TEMPLATE_NAME = "plan.yyyy-MM-ddTHH-mm.md"
+
+
+@dataclass
+class IssueMeta:
+    """Issue metadata container."""
+
+    number: str
+    author: str
+    updated_date: str
+
+
+@dataclass
+class ActiveFolderResult:
+    """Result payload for active-folder creation."""
+
+    target: Path
+    potential_issue_path: Path | None
+
+
+class FileSystem(Protocol):
+    """Filesystem contract for folder creation workflows."""
+
+    def exists(self, path: Path) -> bool: ...
+
+    def ensure_dir(self, path: Path) -> None: ...
+
+    def copy_file(self, src: Path, dest: Path) -> None: ...
+
+    def copy_tree(self, src: Path, dest: Path) -> None: ...
+
+    def list_files(self, path: Path) -> Iterable[Path]: ...
+
+    def read_text(self, path: Path) -> str: ...
+
+    def write_text(self, path: Path, content: str) -> None: ...
+
+    def move(self, src: Path, dest: Path) -> None: ...
+
+
+@dataclass
+class RealFileSystem(FileSystem):
+    """Disk-backed FileSystem implementation."""
+
+    def exists(self, path: Path) -> bool:
+        return path.exists()
+
+    def ensure_dir(self, path: Path) -> None:
+        path.mkdir(parents=True, exist_ok=True)
+
+    def copy_file(self, src: Path, dest: Path) -> None:
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(src, dest)
+
+    def copy_tree(self, src: Path, dest: Path) -> None:
+        for file_path in src.rglob("*"):
+            if file_path.is_dir():
+                continue
+            relative = file_path.relative_to(src)
+            target_path = dest / relative
+            self.copy_file(file_path, target_path)
+
+    def list_files(self, path: Path) -> Iterable[Path]:
+        if not path.exists():
+            return []
+        return [p for p in path.iterdir() if p.is_file()]
+
+    def read_text(self, path: Path) -> str:
+        return path.read_text(encoding="utf-8")
+
+    def write_text(self, path: Path, content: str) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content, encoding="utf-8")
+
+    def move(self, src: Path, dest: Path) -> None:
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        if dest.exists() and dest.is_file():
+            dest.unlink()
+        src.replace(dest)
+
+
+def resolve_workspace() -> Path:
+    """Resolve repository workspace root."""
+    return Path.cwd()
+
+
+def get_est_timestamp(now_provider: Callable[[], datetime] | None = None) -> str:
+    """Return a Windows-safe timestamp string for America/New_York."""
+    now = (
+        now_provider()
+        if now_provider
+        else datetime.now(tz=ZoneInfo("America/New_York"))
+    )
+    if now.tzinfo is None:
+        raise ValueError("now_provider must return a timezone-aware datetime")
+    localized = now.astimezone(ZoneInfo("America/New_York"))
+    return localized.strftime("%Y-%m-%dT%H-%M")
+
+
+def extract_date_from_timestamp(timestamp: str) -> str:
+    """Extract YYYY-MM-DD date component from a timestamp string."""
+    return timestamp.split("T", 1)[0]
+
+
+def validate_feature_name(feature_name: str) -> None:
+    """Validate feature-name slug format."""
+    if not feature_name or not NAME_PATTERN.fullmatch(feature_name):
+        raise ValueError(
+            f"Aborted: '{feature_name}' is invalid. Use kebab/underscore-case "
+            "letters/numbers (e.g., notes-feature or notes_feature)."
+        )