@mc1global/opencode-jarvis 0.13.0 → 0.13.1

package/scripts/obsidian_sync_cli.py

@@ -0,0 +1,964 @@
+#!/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()