@mc1global/opencode-jarvis 0.13.1 → 0.14.0

package/scripts/obsidian_sync_cli.py

@@ -1,964 +0,0 @@
-#!/usr/bin/env python3
-"""
-Obsidian Sync CLI - Bidirectional sync between JARVIS and Obsidian vault.
-
-Maintains JARVIS SQLite as source of truth while providing rich visualization
-in Obsidian. Token-efficient operations using obsidian_markdown_manager.
-
-Usage:
-    python obsidian_sync_cli.py sync-cards --vault /path/to/vault
-    python obsidian_sync_cli.py update-status CD-123 doing --vault /path/to/vault
-    python obsidian_sync_cli.py create-dashboard sprint --vault /path/to/vault
-"""
-
-import argparse
-import sys
-from pathlib import Path
-from typing import Dict, List, Optional
-import json
-from datetime import datetime
-
-# Add project root to path
-project_root = Path(__file__).parent.parent
-sys.path.insert(0, str(project_root))
-
-try:
-    from scripts.managers.obsidian_markdown_manager import ObsidianMarkdownManager
-    from src.infrastructure.kanban import KanbanRepository
-    from src.application.kanban import KanbanService
-    from scripts.managers.workspace_path_manager import get_workspace_path
-except ImportError as e:
-    print(f"Import error: {e}", file=sys.stderr)
-    print("Make sure you're running from the project root directory", file=sys.stderr)
-    sys.exit(1)
-
-
-class ObsidianSyncService:
-    """Service for syncing JARVIS data with Obsidian vault."""
-
-    def __init__(self, vault_path: str, workspace: str = "JARVIS"):
-        """
-        Initialize sync service.
-
-        Args:
-            vault_path: Path to Obsidian vault
-            workspace: JARVIS workspace name
-        """
-        self.vault_path = Path(vault_path)
-        self.workspace = workspace
-        self.markdown_manager = ObsidianMarkdownManager()
-
-        # Ensure workspace-specific vault directories exist
-        workspace_dir = self.vault_path / workspace
-        self.cards_dir = workspace_dir / "Cards"
-        self.epics_dir = workspace_dir / "Epics"
-        self.agents_dir = workspace_dir / "Agents"
-        self.dashboards_dir = workspace_dir / "Dashboards"
-
-        for directory in [
-            self.cards_dir,
-            self.epics_dir,
-            self.agents_dir,
-            self.dashboards_dir,
-        ]:
-            directory.mkdir(parents=True, exist_ok=True)
-
-    def _slugify(self, text: str, max_length: int = 50) -> str:
-        """Convert text to URL-friendly slug for filenames."""
-        import re
-        import unicodedata
-        
-        # Normalize unicode characters
-        text = unicodedata.normalize('NFKD', text)
-        text = text.encode('ascii', 'ignore').decode('ascii')
-        
-        # Convert to lowercase and replace spaces/special chars with hyphens
-        text = re.sub(r'[^\w\s-]', '', text.lower())
-        text = re.sub(r'[-\s]+', '-', text).strip('-')
-        
-        # Truncate to max length at word boundary
-        if len(text) > max_length:
-            text = text[:max_length].rsplit('-', 1)[0]
-        
-        return text
-
-    def _make_friendly_filename(self, entity_id: str, title: str) -> str:
-        """Create friendly filename: ID_slug-of-title.md"""
-        slug = self._slugify(title)
-        return f"{entity_id}_{slug}.md"
-
-    def sync_all_cards(self) -> Dict[str, int]:
-        """
-        Sync all cards from JARVIS to Obsidian.
-
-        Returns:
-            Dictionary with sync statistics
-        """
-        stats = {"created": 0, "updated": 0, "errors": 0}
-
-        try:
-            with KanbanRepository(self.workspace) as repo:
-                cards = repo.list_cards()
-
-            for card in cards:
-                try:
-                    if self._sync_card(card):
-                        # Check if file existed before
-                        card_file = self.cards_dir / f"{card.id}.md"
-                        if card_file.exists():
-                            stats["updated"] += 1
-                        else:
-                            stats["created"] += 1
-                    else:
-                        stats["errors"] += 1
-
-                except Exception as e:
-                    print(f"Error syncing card {card.id}: {e}", file=sys.stderr)
-                    stats["errors"] += 1
-
-        except Exception as e:
-            print(f"Error accessing JARVIS repository: {e}", file=sys.stderr)
-            stats["errors"] += 1
-
-        return stats
-
-    def _sync_card(self, card) -> bool:
-        """
-        Sync individual card to Obsidian.
-
-        Args:
-            card: Card object from JARVIS
-
-        Returns:
-            True if successful
-        """
-        card_file = self.cards_dir / f"{card.id}.md"
-
-        try:
-            # Check if file exists
-            if card_file.exists():
-                # Update existing file
-                return self._update_existing_card(card_file, card)
-            else:
-                # Create new file
-                return self._create_new_card(card_file, card)
-
-        except Exception as e:
-            print(f"Error syncing card {card.id}: {e}", file=sys.stderr)
-            return False
-
-    def _create_new_card(self, card_file: Path, card) -> bool:
-        """Create new card file in Obsidian."""
-        template_content = f"""---
-tags: [card, kanban]
-id: {card.id}
-title: "{card.title}"
-status: {card.status}
-priority: {card.priority or "medium"}
-assignee: {card.assigned_agent or ""}
-epic: {card.epic_id or ""}
-sprint: {card.sprint_id or ""}
-story_points: {card.story_points or 0}
-created: {datetime.now().strftime("%Y-%m-%d")}
-updated: {datetime.now().strftime("%Y-%m-%d")}
----
-
-# {card.id}: {card.title}
-
-> [!info]- Card Metadata
-> **Status:** `$= dv.current().status`
-> **Priority:** `= this.priority`
-> **Assignee:** `= this.assignee`
-> **Epic:** `= this.epic`
-> **Sprint:** `= this.sprint`
-> **Points:** `= this.story_points`
-
-## Description
-
-{card.description or ""}
-
-## Acceptance Criteria
-
-{self._format_acceptance_criteria(card)}
-
-## Progress
-
-- [ ] Analysis
-- [ ] Implementation  
-- [ ] Testing
-- [ ] Review
-- [ ] Documentation
-
-## Notes
-
-## Related Items
-
-- Epic: [[{card.epic_id}]]
-- Sprint: [[Sprint-{card.sprint_id}]]
-
-## JARVIS Integration
-
-**Last Sync:** {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
-**Source:** JARVIS Kanban System
-"""
-
-        try:
-            with open(card_file, "w", encoding="utf-8") as f:
-                f.write(template_content)
-            return True
-        except Exception as e:
-            print(f"Error creating card file {card_file}: {e}", file=sys.stderr)
-            return False
-
-    def _update_existing_card(self, card_file: Path, card) -> bool:
-        """Update existing card file with current JARVIS data."""
-        try:
-            # Update key fields that should sync from JARVIS
-            success = True
-            success &= self.markdown_manager.set_frontmatter_field(
-                str(card_file), "status", card.status
-            )
-            success &= self.markdown_manager.set_frontmatter_field(
-                str(card_file), "assignee", card.assigned_agent or ""
-            )
-            success &= self.markdown_manager.set_frontmatter_field(
-                str(card_file), "updated", datetime.now().strftime("%Y-%m-%d")
-            )
-
-            # Update story points if changed
-            if card.story_points:
-                success &= self.markdown_manager.set_frontmatter_field(
-                    str(card_file), "story_points", card.story_points
-                )
-
-            return success
-
-        except Exception as e:
-            print(f"Error updating card file {card_file}: {e}", file=sys.stderr)
-            return False
-
-    def _format_acceptance_criteria(self, card) -> str:
-        """Format acceptance criteria as checklist."""
-        if not hasattr(card, "acceptance_criteria") or not card.acceptance_criteria:
-            return "- [ ] To be defined"
-
-        criteria_list = []
-        if isinstance(card.acceptance_criteria, list):
-            for criterion in card.acceptance_criteria:
-                criteria_list.append(f"- [ ] {criterion}")
-        else:
-            criteria_list.append(f"- [ ] {card.acceptance_criteria}")
-
-        return "\n".join(criteria_list)
-
-    def update_card_status_in_vault(self, card_id: str, new_status: str) -> bool:
-        """
-        Update card status in Obsidian vault.
-
-        Args:
-            card_id: Card ID (e.g., CD-123)
-            new_status: New status
-
-        Returns:
-            True if successful
-        """
-        return self.markdown_manager.sync_card_status(
-            str(self.vault_path), card_id, new_status
-        )
-
-    def create_sprint_dashboard(self, sprint_id: str) -> bool:
-        """
-        Create sprint dashboard in Obsidian.
-
-        Args:
-            sprint_id: Sprint ID
-
-        Returns:
-            True if successful
-        """
-        dashboard_file = self.dashboards_dir / f"Sprint-{sprint_id}-Dashboard.md"
-
-        template_content = f"""---
-tags: [dashboard, sprint]
-title: "Sprint {sprint_id} Dashboard"
-sprint: {sprint_id}
-created: {datetime.now().strftime("%Y-%m-%d")}
----
-
-# Sprint {sprint_id} Dashboard
-
-> [!info]- Dashboard Info
-> **Sprint:** `= this.sprint`
-> **Created:** `= this.created`
-
-## Sprint Overview
-
-```dataview
-TABLE
-  file.link AS "Card",
-  status AS "Status",
-  priority AS "Priority",
-  assignee AS "Assignee",
-  story_points AS "Points"
-FROM "{self.workspace}/Cards"
-WHERE sprint = "{sprint_id}"
-SORT priority DESC, status ASC
-```
-
-## Progress Summary
-
-```dataview
-TABLE
-  status,
-  length(rows) AS "Count",
-  sum(rows.story_points) AS "Points"
-FROM "{self.workspace}/Cards"
-WHERE sprint = "{sprint_id}"
-GROUP BY status
-SORT length(rows) DESC
-```
-
-## Active Work
-
-```dataview
-LIST
-FROM "{self.workspace}/Cards"
-WHERE sprint = "{sprint_id}" AND status IN ["doing", "review", "technical_review"]
-```
-
-## Completed This Sprint
-
-```dataview
-TABLE
-  file.link AS "Card",
-  assignee AS "Assignee",
-  story_points AS "Points"
-FROM "{self.workspace}/Cards"
-WHERE sprint = "{sprint_id}" AND status = "done"
-SORT file.mtime DESC
-```
-
-## Blockers
-
-```dataview
-LIST
-FROM "{self.workspace}/Cards"
-WHERE sprint = "{sprint_id}" AND status = "blocked"
-```
-
----
-*Auto-generated by JARVIS Obsidian Sync*
-"""
-
-        try:
-            with open(dashboard_file, "w", encoding="utf-8") as f:
-                f.write(template_content)
-            return True
-        except Exception as e:
-            print(f"Error creating sprint dashboard: {e}", file=sys.stderr)
-            return False
-
-    def create_epic_overview(self, epic_id: str) -> bool:
-        """
-        Create epic overview in Obsidian.
-
-        Args:
-            epic_id: Epic ID
-
-        Returns:
-            True if successful
-        """
-        epic_file = self.epics_dir / f"{epic_id}.md"
-
-        try:
-            with KanbanRepository(self.workspace) as repo:
-                # Get epic data (simplified - would need epic repository)
-                cards = repo.list_cards(epic=epic_id)
-
-        except Exception as e:
-            print(f"Error accessing epic data: {e}", file=sys.stderr)
-            return False
-
-        template_content = f"""---
-tags: [epic, feature]
-id: {epic_id}
-title: "Epic {epic_id}"
-status: active
-created: {datetime.now().strftime("%Y-%m-%d")}
----
-
-# {epic_id}: Epic Title
-
-> [!info]- Epic Metadata
-> **Status:** `= this.status`
-> **Cards:** `= length(dv.pages("#card").where(p => p.epic = "{epic_id}"))`
-> **Completed:** `= length(dv.pages("#card").where(p => p.epic = "{epic_id}" && p.status = "done"))`
-
-## Epic Cards
-
-```dataview
-TABLE
-  file.link AS "Card",
-  status AS "Status",
-  priority AS "Priority",
-  assignee AS "Assignee",
-  story_points AS "Points"
-FROM "{self.workspace}/Cards"
-WHERE epic = "{epic_id}"
-SORT priority DESC, status ASC
-```
-
-## Progress
-
-```dataview
-TABLE
-  status,
-  length(rows) AS "Count",
-  round(length(rows) * 100 / length(dv.pages("#card").where(p => p.epic = "{epic_id}")), 1) + "%" AS "Percentage"
-FROM "{self.workspace}/Cards"
-WHERE epic = "{epic_id}"
-GROUP BY status
-```
-
----
-*Auto-generated by JARVIS Obsidian Sync*
-"""
-
-        try:
-            with open(epic_file, "w", encoding="utf-8") as f:
-                f.write(template_content)
-            return True
-        except Exception as e:
-            print(f"Error creating epic overview: {e}", file=sys.stderr)
-            return False
-
-    def sync_roadmaps(self) -> Dict[str, int]:
-        """
-        Sync roadmaps from JARVIS to Obsidian vault.
-
-        Returns:
-            Dict with sync statistics
-        """
-        try:
-            # Import here to avoid circular imports
-            from src.infrastructure.roadmap import RoadmapRepository
-
-            stats = {"created": 0, "updated": 0, "errors": 0}
-
-            with RoadmapRepository(self.workspace) as repo:
-                roadmaps = repo.list_roadmaps()
-
-                for roadmap in roadmaps:
-                    try:
-                        success = self._sync_roadmap(roadmap)
-                        if success:
-                            # Check if file existed before
-                            roadmap_file = (
-                                self.vault_path
-                                / self.workspace
-                                / "Roadmaps"
-                                / f"{roadmap.id}.md"
-                            )
-                            if roadmap_file.exists():
-                                stats["updated"] += 1
-                            else:
-                                stats["created"] += 1
-                        else:
-                            stats["errors"] += 1
-                    except Exception as e:
-                        print(
-                            f"Error syncing roadmap {roadmap.id}: {e}", file=sys.stderr
-                        )
-                        stats["errors"] += 1
-
-            return stats
-
-        except Exception as e:
-            print(f"Error syncing roadmaps: {e}", file=sys.stderr)
-            return {"created": 0, "updated": 0, "errors": 1}
-
-    def _sync_roadmap(self, roadmap) -> bool:
-        """Sync individual roadmap to Obsidian."""
-        try:
-            from src.infrastructure.roadmap import RoadmapRepository
-            import re
-
-            # Create Roadmaps directory
-            roadmaps_dir = self.vault_path / self.workspace / "Roadmaps"
-            roadmaps_dir.mkdir(parents=True, exist_ok=True)
-
-            # Use friendly filename
-            filename = self._make_friendly_filename(roadmap.id, roadmap.title)
-            roadmap_file = roadmaps_dir / filename
-
-            # Get releases for this roadmap to build timeline
-            with RoadmapRepository(self.workspace) as repo:
-                releases = repo.list_releases(roadmap_id=roadmap.id)
-
-            # Build Chronos timeline content
-            chronos_content = self._build_roadmap_chronos_timeline(roadmap, releases)
-
-            # Load template
-            template_path = (
-                self.vault_path / self.workspace / "Templates" / "Roadmap-Template.md"
-            )
-            if template_path.exists():
-                with open(template_path, "r", encoding="utf-8") as f:
-                    template_content = f.read()
-            else:
-                template_content = self._get_basic_roadmap_template()
-
-            # Replace template variables
-            content = template_content.replace("{{id}}", roadmap.id)
-            content = content.replace("{{title}}", roadmap.title)
-            content = content.replace("{{status}}", roadmap.status)
-            content = content.replace("{{workspace}}", roadmap.workspace)
-            content = content.replace("{{start_date}}", roadmap.start_date or "")
-            content = content.replace("{{end_date}}", roadmap.end_date or "")
-            content = content.replace("{{created_at}}", roadmap.created_at)
-            content = content.replace("{{updated_at}}", roadmap.updated_at)
-            content = content.replace(
-                "{{sync_timestamp}}", datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            )
-            content = content.replace("{{description}}", roadmap.description or "")
-            
-            # Strategic fields - use DB values or placeholder
-            problem = getattr(roadmap, 'problem', None) or "_Definir: Qual problema este roadmap resolve?_"
-            vision = getattr(roadmap, 'vision', None) or "_Definir: Onde queremos chegar?_"
-            value = getattr(roadmap, 'value_delivered', None) or "_Definir: Que benefícios concretos serão entregues?_"
-            decisions = getattr(roadmap, 'key_decisions', None) or "_Definir: Decisões arquiteturais chave._"
-            risks = getattr(roadmap, 'risks', None) or "_Definir: Riscos e dependências externas._"
-            
-            content = content.replace("{{problem}}", problem)
-            content = content.replace("{{vision}}", vision)
-            content = content.replace("{{value}}", value)
-            content = content.replace("{{decisions}}", decisions)
-            content = content.replace("{{risks}}", risks)
-
-            # Replace chronos timeline with actual data
-            chronos_pattern = r"```chronos\n.*?```"
-            chronos_block = f"```chronos\n> HEIGHT 400\n> ORDERBY start\n> DEFAULTVIEW {roadmap.start_date or '2026-01-01'}|{roadmap.end_date or '2026-12-31'}\n{chronos_content}\n```"
-            content = re.sub(chronos_pattern, chronos_block, content, flags=re.DOTALL)
-
-            # Clean up any remaining Mustache placeholders
-            content = re.sub(r'\{\{#\w+\}\}[\s\S]*?\{\{/\w+\}\}', '', content)
-            content = re.sub(r'\{\{\w+\}\}', '', content)
-            content = re.sub(r'\n{3,}', '\n\n', content)
-
-            # Write file
-            with open(roadmap_file, "w", encoding="utf-8") as f:
-                f.write(content)
-
-            return True
-
-        except Exception as e:
-            print(f"Error syncing roadmap {roadmap.id}: {e}", file=sys.stderr)
-            return False
-
-    def _build_roadmap_chronos_timeline(self, roadmap, releases) -> str:
-        """Build Chronos timeline content for roadmap."""
-        lines = [f"# {roadmap.title} Timeline"]
-
-        # Add roadmap start marker
-        if roadmap.start_date:
-            lines.append(f"= [{roadmap.start_date}] Roadmap Start")
-
-        # Add releases as events
-        for release in releases:
-            color = (
-                "#blue"
-                if "1.0" in release.version
-                else "#green"
-                if "2.0" in release.version
-                else "#orange"
-            )
-            start_date = release.start_date or roadmap.start_date
-            end_date = release.end_date or roadmap.end_date
-            description = release.description or f"Release {release.version}"
-
-            if start_date and end_date:
-                lines.append(
-                    f"- [{start_date}~{end_date}] {color} {release.title} | {description}"
-                )
-            elif start_date:
-                lines.append(
-                    f"- [{start_date}] {color} {release.title} | {description}"
-                )
-
-        # Add roadmap end marker
-        if roadmap.end_date:
-            lines.append(f"= [{roadmap.end_date}] Roadmap End")
-
-        return "\n".join(lines)
-
-    def sync_releases(self) -> Dict[str, int]:
-        """
-        Sync releases from JARVIS to Obsidian vault.
-
-        Returns:
-            Dict with sync statistics
-        """
-        try:
-            from src.infrastructure.roadmap import RoadmapRepository
-
-            stats = {"created": 0, "updated": 0, "errors": 0}
-
-            with RoadmapRepository(self.workspace) as repo:
-                releases = repo.list_releases()
-
-                for release in releases:
-                    try:
-                        success = self._sync_release(release)
-                        if success:
-                            release_file = (
-                                self.vault_path
-                                / self.workspace
-                                / "Releases"
-                                / f"{release.id}.md"
-                            )
-                            if release_file.exists():
-                                stats["updated"] += 1
-                            else:
-                                stats["created"] += 1
-                        else:
-                            stats["errors"] += 1
-                    except Exception as e:
-                        print(
-                            f"Error syncing release {release.id}: {e}", file=sys.stderr
-                        )
-                        stats["errors"] += 1
-
-            return stats
-
-        except Exception as e:
-            print(f"Error syncing releases: {e}", file=sys.stderr)
-            return {"created": 0, "updated": 0, "errors": 1}
-
-    def _sync_release(self, release) -> bool:
-        """Sync individual release to Obsidian."""
-        try:
-            from src.infrastructure.roadmap import RoadmapRepository
-            import re
-
-            # Create Releases directory
-            releases_dir = self.vault_path / self.workspace / "Releases"
-            releases_dir.mkdir(parents=True, exist_ok=True)
-
-            # Use friendly filename
-            filename = self._make_friendly_filename(release.id, release.title)
-            release_file = releases_dir / filename
-
-            # Get milestones for this release to build timeline
-            with RoadmapRepository(self.workspace) as repo:
-                milestones = repo.list_milestones(release_id=release.id)
-
-            # Build Chronos timeline content
-            chronos_content = self._build_release_chronos_timeline(release, milestones)
-
-            # Load template
-            template_path = (
-                self.vault_path / self.workspace / "Templates" / "Release-Template.md"
-            )
-            if template_path.exists():
-                with open(template_path, "r", encoding="utf-8") as f:
-                    template_content = f.read()
-            else:
-                template_content = self._get_basic_release_template()
-
-            # Replace template variables
-            content = template_content.replace("{{id}}", release.id)
-            content = content.replace("{{title}}", release.title)
-            content = content.replace("{{version}}", release.version or "")
-            content = content.replace("{{status}}", release.status)
-            content = content.replace("{{roadmap_id}}", release.roadmap_id)
-            content = content.replace("{{workspace}}", release.workspace)
-            content = content.replace("{{start_date}}", release.start_date or "")
-            content = content.replace("{{end_date}}", release.end_date or "")
-            content = content.replace("{{created_at}}", release.created_at)
-            content = content.replace("{{updated_at}}", release.updated_at)
-            content = content.replace(
-                "{{sync_timestamp}}", datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            )
-
-            # Strategic fields - use DB values or placeholder
-            problem = getattr(release, 'problem', None) or "_Definir: Qual problema específico esta release resolve?_"
-            deliverables = getattr(release, 'deliverables', None) or "_Definir: O que o usuário poderá fazer após esta release?_"
-            success_criteria = getattr(release, 'success_criteria', None) or "_Definir: Como mediremos o sucesso?_"
-            technical_scope = getattr(release, 'technical_scope', None) or "_Definir: Componentes, APIs, integrações a construir._"
-            out_of_scope = getattr(release, 'out_of_scope', None) or "_Definir: O que NÃO faz parte desta release._"
-            dependencies = getattr(release, 'dependencies_notes', None) or "_Definir: Dependências externas e internas._"
-            
-            content = content.replace("{{problem}}", problem)
-            content = content.replace("{{deliverables}}", deliverables)
-            content = content.replace("{{success_criteria}}", success_criteria)
-            content = content.replace("{{technical_scope}}", technical_scope)
-            content = content.replace("{{out_of_scope}}", out_of_scope)
-            content = content.replace("{{dependencies}}", dependencies)
-
-            # Replace chronos timeline with actual data
-            chronos_pattern = r"```chronos\n.*?```"
-            chronos_block = f"```chronos\n> HEIGHT 350\n> ORDERBY start\n> NOTODAY\n{chronos_content}\n```"
-            content = re.sub(chronos_pattern, chronos_block, content, flags=re.DOTALL)
-
-            # Clean up any remaining Mustache placeholders
-            content = re.sub(r'\{\{#\w+\}\}[\s\S]*?\{\{/\w+\}\}', '', content)
-            content = re.sub(r'\{\{\w+\}\}', '', content)
-            content = re.sub(r'\n{3,}', '\n\n', content)
-
-            # Write file
-            with open(release_file, "w", encoding="utf-8") as f:
-                f.write(content)
-
-            return True
-
-        except Exception as e:
-            print(f"Error syncing release {release.id}: {e}", file=sys.stderr)
-            return False
-
-    def _build_release_chronos_timeline(self, release, milestones) -> str:
-        """Build Chronos timeline content for release."""
-        lines = [f"# {release.title} Timeline"]
-
-        # Add release period
-        if release.start_date and release.end_date:
-            lines.append(
-                f"@ [{release.start_date}~{release.end_date}] #green {{{release.title}}} Release Period"
-            )
-
-        # Add release start marker
-        if release.start_date:
-            lines.append(f"= [{release.start_date}] Release Start")
-
-        # Add milestones as points
-        for milestone in milestones:
-            description = milestone.description or f"Milestone: {milestone.title}"
-            lines.append(f"* [{milestone.due_date}] {milestone.title} | {description}")
-
-        # Add release end marker
-        if release.end_date:
-            lines.append(f"= [{release.end_date}] Release Target")
-
-        return "\n".join(lines)
-
-    def _get_basic_roadmap_template(self) -> str:
-        """Get basic roadmap template if file template not found."""
-        return """---
-tags: [roadmap, strategic]
-title: "{{title}}"
-type: roadmap
-id: "{{id}}"
-status: "{{status}}"
-workspace: "{{workspace}}"
----
-
-# 🗺️ {{title}}
-
-**ID:** {{id}}
-**Status:** {{status}}
-**Period:** {{start_date}} → {{end_date}}
-
-## Description
-
-{{description}}
-
-## Strategic Timeline
-
-```chronos
-> HEIGHT 400
-> ORDERBY start
-> DEFAULTVIEW {{start_date}}|{{end_date}}
-# {{title}} Timeline
-= [{{start_date}}] Roadmap Start
-# Releases will be populated by sync process
-= [{{end_date}}] Roadmap End
-```
-
-## Releases
-
-```dataview
-TABLE status, version, start_date, end_date
-FROM #release 
-WHERE roadmap_id = "{{id}}"
-SORT start_date ASC
-```
-
----
-**Last Sync:** {{sync_timestamp}}
-"""
-
-    def _get_basic_release_template(self) -> str:
-        """Get basic release template if file template not found."""
-        return """---
-tags: [release, strategic]
-title: "{{title}}"
-type: release
-id: "{{id}}"
-roadmap_id: "{{roadmap_id}}"
-status: "{{status}}"
-version: "{{version}}"
----
-
-# 🚀 {{title}}
-
-**ID:** {{id}}
-**Version:** {{version}}
-**Status:** {{status}}
-**Period:** {{start_date}} → {{end_date}}
-**Roadmap:** [[{{roadmap_id}}]]
-
-## Description
-
-{{description}}
-
-## Release Timeline
-
-```chronos
-> HEIGHT 350
-> ORDERBY start
-> NOTODAY
-# {{title}} Timeline
-@ [{{start_date}}~{{end_date}}] #green {{{title}}} Release Period
-= [{{start_date}}] Release Start
-# Milestones and initiatives will be populated by sync process
-= [{{end_date}}] Release Target
-```
-
----
-**Last Sync:** {{sync_timestamp}}
-"""
-
-
-def main():
-    """CLI interface for Obsidian sync operations."""
-    parser = argparse.ArgumentParser(
-        description="Obsidian Sync CLI - Sync JARVIS data with Obsidian vault"
-    )
-
-    parser.add_argument("--vault", required=True, help="Path to Obsidian vault")
-    parser.add_argument("--workspace", default="JARVIS", help="JARVIS workspace name")
-
-    subparsers = parser.add_subparsers(dest="command", help="Commands")
-
-    # Sync all cards
-    sync_parser = subparsers.add_parser("sync-cards", help="Sync all cards to Obsidian")
-
-    # Update card status
-    status_parser = subparsers.add_parser(
-        "update-status", help="Update card status in vault"
-    )
-    status_parser.add_argument("card_id", help="Card ID")
-    status_parser.add_argument("status", help="New status")
-
-    # Create dashboard
-    dashboard_parser = subparsers.add_parser(
-        "create-dashboard", help="Create dashboard"
-    )
-    dashboard_parser.add_argument(
-        "type", choices=["sprint", "epic"], help="Dashboard type"
-    )
-    dashboard_parser.add_argument("id", help="Sprint or Epic ID")
-
-    # Bulk sync
-    bulk_parser = subparsers.add_parser("bulk-sync", help="Full sync of all data")
-
-    # Strategic Layer sync
-    roadmap_parser = subparsers.add_parser(
-        "sync-roadmaps", help="Sync roadmaps to Obsidian"
-    )
-    release_parser = subparsers.add_parser(
-        "sync-releases", help="Sync releases to Obsidian"
-    )
-    strategic_parser = subparsers.add_parser(
-        "sync-strategic", help="Sync all strategic layer data"
-    )
-
-    args = parser.parse_args()
-
-    if not args.command:
-        parser.print_help()
-        return
-
-    # Initialize sync service
-    sync_service = ObsidianSyncService(args.vault, args.workspace)
-
-    # Handle commands
-    if args.command == "sync-cards":
-        print("Syncing cards to Obsidian vault...")
-        stats = sync_service.sync_all_cards()
-        print(
-            f"Sync complete: {stats['created']} created, {stats['updated']} updated, {stats['errors']} errors"
-        )
-
-    elif args.command == "update-status":
-        success = sync_service.update_card_status_in_vault(args.card_id, args.status)
-        print("OK" if success else "FAILED")
-
-    elif args.command == "create-dashboard":
-        if args.type == "sprint":
-            success = sync_service.create_sprint_dashboard(args.id)
-        elif args.type == "epic":
-            success = sync_service.create_epic_overview(args.id)
-        else:
-            success = False
-
-        print("OK" if success else "FAILED")
-
-    elif args.command == "bulk-sync":
-        print("Starting full sync...")
-
-        # Sync cards
-        print("Syncing cards...")
-        card_stats = sync_service.sync_all_cards()
-        print(
-            f"Cards: {card_stats['created']} created, {card_stats['updated']} updated"
-        )
-
-        # Create dashboards for active sprints
-        print("Creating sprint dashboards...")
-        try:
-            with KanbanRepository(args.workspace) as repo:
-                sprints = repo.list_sprints("active")
-                for sprint in sprints:
-                    sync_service.create_sprint_dashboard(sprint.id)
-                print(f"Created {len(sprints)} sprint dashboards")
-        except Exception as e:
-            print(f"Error creating sprint dashboards: {e}", file=sys.stderr)
-
-        print("Full sync complete!")
-
-    elif args.command == "sync-roadmaps":
-        print("Syncing roadmaps to Obsidian vault...")
-        stats = sync_service.sync_roadmaps()
-        print(
-            f"Roadmap sync complete: {stats['created']} created, {stats['updated']} updated, {stats['errors']} errors"
-        )
-
-    elif args.command == "sync-releases":
-        print("Syncing releases to Obsidian vault...")
-        stats = sync_service.sync_releases()
-        print(
-            f"Release sync complete: {stats['created']} created, {stats['updated']} updated, {stats['errors']} errors"
-        )
-
-    elif args.command == "sync-strategic":
-        print("Syncing strategic layer to Obsidian vault...")
-
-        # Sync roadmaps
-        print("Syncing roadmaps...")
-        roadmap_stats = sync_service.sync_roadmaps()
-        print(
-            f"Roadmaps: {roadmap_stats['created']} created, {roadmap_stats['updated']} updated"
-        )
-
-        # Sync releases
-        print("Syncing releases...")
-        release_stats = sync_service.sync_releases()
-        print(
-            f"Releases: {release_stats['created']} created, {release_stats['updated']} updated"
-        )
-
-        print("Strategic layer sync complete!")
-
-
-if __name__ == "__main__":
-    main()