monoco-toolkit 0.1.0__py3-none-any.whl

monoco/features/issue/linter.py

@@ -0,0 +1,172 @@
+from typing import List, Optional, Tuple, Set
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+import typer
+
+from . import core
+from .models import IssueStatus, IssueStage
+
+console = Console()
+
+
+def validate_issue(path: Path, meta: core.IssueMetadata, all_issue_ids: Set[str] = set(), issues_root: Optional[Path] = None) -> List[str]:
+    """
+    Validate a single issue's integrity.
+    """
+    errors = []
+    
+    # A. Directory/Status Consistency
+    expected_status = meta.status.value
+    path_parts = path.parts
+    # We might be validating a temp file, so we skip path check if it's not in the tree?
+    # Or strict check? For "Safe Edit", the file might be in a temp dir. 
+    # So we probably only care about content/metadata integrity.
+    
+    # But wait, if we overwrite the file, it MUST be valid.
+    # Let's assume the validation is about the content itself (metadata logic).
+    
+    # B. Solution Compliance
+    if meta.status == IssueStatus.CLOSED and not meta.solution:
+        errors.append(f"[red]Solution Missing:[/red] {meta.id} is closed but has no [dim]solution[/dim] field.")
+        
+    # C. Link Integrity
+    if meta.parent:
+        if all_issue_ids and meta.parent not in all_issue_ids:
+             # Check workspace (fallback)
+             found = False
+             if issues_root:
+                 if core.find_issue_path(issues_root, meta.parent):
+                     found = True
+             
+             if not found:
+                 errors.append(f"[red]Broken Link:[/red] {meta.id} refers to non-existent parent [bold]{meta.parent}[/bold].")
+
+    # D. Lifecycle Guard (Backlog)
+    if meta.status == IssueStatus.BACKLOG and meta.stage != IssueStage.FREEZED:
+        errors.append(f"[red]Lifecycle Error:[/red] {meta.id} is backlog but stage is not [bold]freezed[/bold] (found: {meta.stage}).")
+
+    return errors
+
+def check_integrity(issues_root: Path, recursive: bool = False) -> List[str]:
+    """
+    Verify the integrity of the Issues directory.
+    Returns a list of error messages.
+    
+    If recursive=True, performs workspace-level validation including:
+    - Cross-project ID collision detection
+    - Cross-project UID collision detection
+    """
+    errors = []
+    all_issue_ids = set()  # For parent reference validation (includes namespaced IDs)
+    id_to_projects = {}  # local_id -> [(project_name, meta, file)]
+    all_uids = {}  # uid -> (project, issue_id)
+    all_issues = []
+    
+    # Helper to collect issues from a project
+    def collect_project_issues(project_issues_root: Path, project_name: str = "local"):
+        project_issues = []
+        for subdir in ["Epics", "Features", "Chores", "Fixes"]:
+            d = project_issues_root / subdir
+            if d.exists():
+                files = []
+                for status in ["open", "closed", "backlog"]:
+                    status_dir = d / status
+                    if status_dir.exists():
+                        files.extend(status_dir.rglob("*.md"))
+
+                for f in files:
+                    meta = core.parse_issue(f)
+                    if meta:
+                        local_id = meta.id
+                        full_id = f"{project_name}::{local_id}" if project_name != "local" else local_id
+                        
+                        # Track ID occurrences per project
+                        if local_id not in id_to_projects:
+                            id_to_projects[local_id] = []
+                        id_to_projects[local_id].append((project_name, meta, f))
+                        
+                        # Add IDs for reference validation
+                        all_issue_ids.add(local_id)  # Local ID
+                        if project_name != "local":
+                            all_issue_ids.add(full_id)  # Namespaced ID
+                        
+                        # Check UID collision (if UID exists)
+                        if meta.uid:
+                            if meta.uid in all_uids:
+                                existing_project, existing_id = all_uids[meta.uid]
+                                errors.append(
+                                    f"[red]UID Collision:[/red] UID {meta.uid} is duplicated.\n"
+                                    f"  - {existing_project}::{existing_id}\n"
+                                    f"  - {project_name}::{local_id}"
+                                )
+                            else:
+                                all_uids[meta.uid] = (project_name, local_id)
+                        
+                        project_issues.append((f, meta, project_name))
+        return project_issues
+
+    # 1. Collect local issues
+    all_issues.extend(collect_project_issues(issues_root, "local"))
+
+    # 2. If recursive, collect workspace member issues
+    if recursive:
+        try:
+            from monoco.core.config import get_config
+            project_root = issues_root.parent
+            conf = get_config(str(project_root))
+            
+            for member_name, rel_path in conf.project.members.items():
+                member_root = (project_root / rel_path).resolve()
+                member_issues_dir = member_root / "Issues"
+                
+                if member_issues_dir.exists():
+                    all_issues.extend(collect_project_issues(member_issues_dir, member_name))
+        except Exception as e:
+            # Fail gracefully if workspace config is missing
+            pass
+
+    # 3. Check for ID collisions within same project
+    for local_id, occurrences in id_to_projects.items():
+        # Group by project
+        projects_with_id = {}
+        for project_name, meta, f in occurrences:
+            if project_name not in projects_with_id:
+                projects_with_id[project_name] = []
+            projects_with_id[project_name].append((meta, f))
+        
+        # Check for duplicates within same project
+        for project_name, metas in projects_with_id.items():
+            if len(metas) > 1:
+                # Same ID appears multiple times in same project - this is an error
+                error_msg = f"[red]ID Collision:[/red] {local_id} appears {len(metas)} times in project '{project_name}':\n"
+                for idx, (meta, f) in enumerate(metas, 1):
+                    error_msg += f"  {idx}. uid: {meta.uid or 'N/A'} | created: {meta.created_at} | stage: {meta.stage} | status: {meta.status.value}\n"
+                error_msg += f"  [yellow]→ Action:[/yellow] Remove duplicate or use 'monoco issue move --to <target> --renumber' to resolve."
+                errors.append(error_msg)
+
+    # 4. Validation
+    for path, meta, project_name in all_issues:
+        # A. Directory/Status Consistency (Only check this for files in the tree)
+        expected_status = meta.status.value
+        path_parts = path.parts
+        if expected_status not in path_parts:
+             errors.append(f"[yellow]Placement Error:[/yellow] {meta.id} has status [cyan]{expected_status}[/cyan] but is not under a [dim]{expected_status}/[/dim] directory.")
+        
+        # Reuse common logic
+        errors.extend(validate_issue(path, meta, all_issue_ids, issues_root))
+
+    return errors
+
+
+def run_lint(issues_root: Path, recursive: bool = False):
+    errors = check_integrity(issues_root, recursive)
+    
+    if not errors:
+        console.print("[green]✔[/green] Issue integrity check passed. No integrity errors found.")
+    else:
+        table = Table(title="Issue Integrity Issues", show_header=False, border_style="red")
+        for err in errors:
+            table.add_row(err)
+        console.print(table)
+        raise typer.Exit(code=1)

monoco/features/issue/models.py

@@ -0,0 +1,154 @@
+from enum import Enum
+from typing import List, Optional, Any
+from pydantic import BaseModel, Field, model_validator
+from datetime import datetime
+import hashlib
+import secrets
+
+
+class IssueID:
+    """
+    Helper for parsing Issue IDs that might be namespaced (e.g. 'toolkit::FEAT-0001').
+    """
+    def __init__(self, raw: str):
+        self.raw = raw
+        if "::" in raw:
+            self.namespace, self.local_id = raw.split("::", 1)
+        else:
+            self.namespace = None
+            self.local_id = raw
+
+    def __str__(self):
+        if self.namespace:
+            return f"{self.namespace}::{self.local_id}"
+        return self.local_id
+        
+    def __repr__(self):
+        return f"IssueID({self.raw})"
+
+    @property
+    def is_local(self) -> bool:
+        return self.namespace is None
+
+    def matches(self, other_id: str) -> bool:
+        """Check if this ID matches another ID string."""
+        return str(self) == other_id or (self.is_local and self.local_id == other_id)
+
+def current_time() -> datetime:
+    return datetime.now().replace(microsecond=0)
+
+def generate_uid() -> str:
+    """
+    Generate a globally unique 6-character short hash for issue identity.
+    Uses timestamp + random bytes to ensure uniqueness across projects.
+    """
+    timestamp = str(datetime.now().timestamp()).encode()
+    random_bytes = secrets.token_bytes(8)
+    combined = timestamp + random_bytes
+    hash_digest = hashlib.sha256(combined).hexdigest()
+    return hash_digest[:6]
+
+
+class IssueType(str, Enum):
+    EPIC = "epic"
+    FEATURE = "feature"
+    CHORE = "chore"
+    FIX = "fix"
+
+class IssueStatus(str, Enum):
+    OPEN = "open"
+    CLOSED = "closed"
+    BACKLOG = "backlog"
+
+class IssueStage(str, Enum):
+    TODO = "todo"
+    DOING = "doing"
+    REVIEW = "review"
+    DONE = "done"
+    FREEZED = "freezed"
+
+class IssueSolution(str, Enum):
+    IMPLEMENTED = "implemented"
+    CANCELLED = "cancelled"
+    WONTFIX = "wontfix"
+    DUPLICATE = "duplicate"
+
+class IsolationType(str, Enum):
+    BRANCH = "branch"
+    WORKTREE = "worktree"
+
+class IssueIsolation(BaseModel):
+    type: IsolationType
+    ref: str  # Git branch name
+    path: Optional[str] = None  # Worktree path (relative to repo root or absolute)
+    created_at: datetime = Field(default_factory=current_time)
+
+class IssueMetadata(BaseModel):
+    model_config = {"extra": "allow"}
+    
+    id: str
+    uid: Optional[str] = None  # Global unique identifier for cross-project identity
+    type: IssueType
+    status: IssueStatus = IssueStatus.OPEN
+    stage: Optional[IssueStage] = None
+    title: str
+    
+    # Time Anchors
+    created_at: datetime = Field(default_factory=current_time)
+    opened_at: Optional[datetime] = None
+    updated_at: datetime = Field(default_factory=current_time)
+    closed_at: Optional[datetime] = None
+
+    parent: Optional[str] = None
+    sprint: Optional[str] = None
+    solution: Optional[IssueSolution] = None
+    isolation: Optional[IssueIsolation] = None
+    dependencies: List[str] = []
+    related: List[str] = []
+    tags: List[str] = []
+
+
+    @model_validator(mode='before')
+    @classmethod
+    def normalize_fields(cls, v: Any) -> Any:
+        if isinstance(v, dict):
+            # Normalize type and status to lowercase for compatibility
+            if "type" in v and isinstance(v["type"], str):
+                v["type"] = v["type"].lower()
+            if "status" in v and isinstance(v["status"], str):
+                v["status"] = v["status"].lower()
+            if "solution" in v and isinstance(v["solution"], str):
+                v["solution"] = v["solution"].lower()
+            # Stage normalization
+            if "stage" in v and isinstance(v["stage"], str):
+                v["stage"] = v["stage"].lower()
+        return v
+
+    @model_validator(mode='after')
+    def validate_lifecycle(self) -> 'IssueMetadata':
+        # Logic Definition:
+        # status: backlog -> stage: null
+        # status: closed -> stage: done
+        # status: open -> stage: todo | doing | review (default todo)
+
+        if self.status == IssueStatus.BACKLOG:
+            self.stage = IssueStage.FREEZED
+        
+        elif self.status == IssueStatus.CLOSED:
+            # Enforce stage=done for closed issues
+            if self.stage != IssueStage.DONE:
+                self.stage = IssueStage.DONE
+            # Auto-fill closed_at if missing
+            if not self.closed_at:
+                self.closed_at = current_time()
+        
+        elif self.status == IssueStatus.OPEN:
+            # Ensure valid stage for open status
+            if self.stage is None or self.stage == IssueStage.DONE:
+                self.stage = IssueStage.TODO
+        
+        return self
+
+class IssueDetail(IssueMetadata):
+    body: str = ""
+    raw_content: Optional[str] = None # Full file content including frontmatter for editing

monoco/features/skills/__init__.py

@@ -0,0 +1 @@
+from .core import init

monoco/features/skills/core.py

@@ -0,0 +1,96 @@
+import os
+import re
+from pathlib import Path
+from typing import Dict, List, Any
+from rich.console import Console
+
+console = Console()
+
+def init(root: Path, resources: List[Dict[str, Any]]):
+    """
+    Initialize the Skills module.
+    
+    Args:
+        root: Project root directory.
+        resources: List of resource dicts from modules. 
+                   Expected format: 
+                   {
+                       "skills": { "name": "content" },
+                       "prompts": { "name": "content" } 
+                   }
+    """
+    skills_root = root / "Toolkit" / "skills"
+    skills_root.mkdir(parents=True, exist_ok=True)
+    
+    # 1. Write Skills
+    for res in resources:
+        if "skills" in res:
+            for name, content in res["skills"].items():
+                target_dir = skills_root / name
+                target_dir.mkdir(exist_ok=True)
+                target_file = target_dir / "SKILL.md"
+                # Idempotency: Overwrite if content is different? Or just always overwrite?
+                # User asked for "scaffold", implies creation. 
+                # Let's overwrite to ensure extensive "Repair" capability.
+                target_file.write_text(content, encoding="utf-8")
+                console.print(f"[dim]  - Scaffolding skill:[/dim] {name}")
+
+    # 2. Update Agent Docs
+    update_agent_docs(root, resources)
+
+def update_agent_docs(root: Path, resources: List[Dict[str, Any]]):
+    """
+    Inject prompts into AGENTS.md, GEMINI.md, CLAUDE.md.
+    """
+    target_files = ["AGENTS.md", "GEMINI.md", "CLAUDE.md"]
+    
+    # Aggregate Prompts
+    aggregated_prompt = "\n\n".join([
+        res["prompts"][name] 
+        for res in resources 
+        if "prompts" in res 
+        for name in res["prompts"]
+    ])
+    
+    injection_content = f"""
+## Monoco Toolkit
+
+The following tools and skills are available in this environment.
+
+{aggregated_prompt}
+"""
+
+    for filename in target_files:
+        _inject_section(root / filename, injection_content)
+
+def _inject_section(file_path: Path, content: str):
+    if not file_path.exists():
+        # Create if not exists? User said "Edit AGENTS.md...", implies existence.
+        # But if we init in a fresh repo, maybe we should create them?
+        # Let's create if missing.
+        file_path.write_text(f"# Project Guidelines\n{content}", encoding="utf-8")
+        console.print(f"[green]✔[/green] Created {file_path.name}")
+        return
+
+    original_content = file_path.read_text(encoding="utf-8")
+    
+    # Regex to find existing section
+    # Matches ## Monoco Toolkit ... until next ## or End of String
+    pattern = r"(## Monoco Toolkit.*?)(\n## |\Z)"
+    
+    # Check if section exists
+    if re.search(pattern, original_content, re.DOTALL):
+        # Replace
+        new_content = re.sub(pattern, f"{content.strip()}\n\n\\2", original_content, flags=re.DOTALL)
+        if new_content != original_content:
+            file_path.write_text(new_content, encoding="utf-8")
+            console.print(f"[green]✔[/green] Updated {file_path.name}")
+        else:
+            console.print(f"[dim]  - {file_path.name} is up to date.[/dim]")
+    else:
+        # Append
+        with open(file_path, "a", encoding="utf-8") as f:
+            if not original_content.endswith("\n"):
+                f.write("\n")
+            f.write(content)
+        console.print(f"[green]✔[/green] Appended to {file_path.name}")

monoco/features/spike/commands.py

@@ -0,0 +1,110 @@
+import typer
+from pathlib import Path
+from rich.console import Console
+
+from monoco.core.config import get_config
+from . import core
+
+app = typer.Typer(help="Spike & Repo Management.")
+console = Console()
+
+@app.command("init")
+def init():
+    """Initialize the Spike environment (gitignore setup)."""
+    config = get_config()
+    root_dir = Path(config.paths.root)
+    spikes_dir_name = config.paths.spikes
+    
+    core.ensure_gitignore(root_dir, spikes_dir_name)
+    
+    # Create the directory
+    (root_dir / spikes_dir_name).mkdir(exist_ok=True)
+    
+    console.print(f"[green]✔[/green] Initialized Spike environment. Added '{spikes_dir_name}/' to .gitignore.")
+
+@app.command("add")
+def add_repo(
+    url: str = typer.Argument(..., help="Git Repository URL"),
+):
+    """Add a new research repository."""
+    config = get_config()
+    root_dir = Path(config.paths.root)
+    
+    # Infer name from URL
+    # e.g., https://github.com/foo/bar.git -> bar
+    # e.g., git@github.com:foo/bar.git -> bar
+    name = url.split("/")[-1]
+    if name.endswith(".git"):
+        name = name[:-4]
+        
+    core.update_config_repos(root_dir, name, url)
+    console.print(f"[green]✔[/green] Added repo [bold]{name}[/bold] ({url}) to configuration.")
+    console.print("Run [bold]monoco spike sync[/bold] to download content.")
+
+@app.command("remove")
+def remove_repo(
+    name: str = typer.Argument(..., help="Repository Name"),
+    force: bool = typer.Option(False, "--force", "-f", help="Force delete physical directory without asking"),
+):
+    """Remove a repository from configuration."""
+    config = get_config()
+    root_dir = Path(config.paths.root)
+    spikes_dir = root_dir / config.paths.spikes
+    
+    if name not in config.project.spike_repos:
+        console.print(f"[yellow]![/yellow] Repo [bold]{name}[/bold] not found in configuration.")
+        return
+
+    # Remove from config
+    core.update_config_repos(root_dir, name, "", remove=True)
+    console.print(f"[green]✔[/green] Removed [bold]{name}[/bold] from configuration.")
+    
+    target_path = spikes_dir / name
+    if target_path.exists():
+        if force or typer.confirm(f"Do you want to delete the directory {target_path}?", default=False):
+            core.remove_repo_dir(spikes_dir, name)
+            console.print(f"[gray]✔[/gray] Deleted directory {target_path}.")
+        else:
+            console.print(f"[gray]ℹ[/gray] Directory {target_path} kept.")
+
+@app.command("sync")
+def sync_repos():
+    """Sync (Clone/Pull) all configured repositories."""
+    # Force reload config to get latest updates
+    config = get_config()
+    # Note: get_config is a singleton, so for 'add' then 'sync' in same process, 
+    # we rely on 'add' writing to disk and us reading from memory? 
+    # Actually, if we run standard CLI "monoco spike add" then "monoco spike sync", 
+    # they are separate processes, so config loads fresh.
+    
+    root_dir = Path(config.paths.root)
+    spikes_dir = root_dir / config.paths.spikes
+    spikes_dir.mkdir(exist_ok=True)
+    
+    repos = config.project.spike_repos
+    
+    if not repos:
+        console.print("[yellow]No repositories configured.[/yellow] Use 'monoco spike add <url>' first.")
+        return
+        
+    console.print(f"Syncing {len(repos)} repositories...")
+    
+    for name, url in repos.items():
+        core.sync_repo(root_dir, spikes_dir, name, url)
+        
+    console.print("[green]✔[/green] Sync complete.")
+
+# Alias for list (showing configured repos) could be useful but not strictly asked for.
+# Let's add a simple list command to see what we have.
+@app.command("list")
+def list_repos():
+    """List configured repositories."""
+    config = get_config()
+    repos = config.project.spike_repos
+    
+    if not repos:
+        console.print("[yellow]No repositories configured.[/yellow]")
+        return
+        
+    for name, url in repos.items():
+        console.print(f"- [bold]{name}[/bold]: {url}")

monoco/features/spike/core.py

@@ -0,0 +1,154 @@
+import os
+import shutil
+import subprocess
+import yaml
+from pathlib import Path
+from typing import Dict, Optional, List, Any
+from rich.console import Console
+
+from monoco.core.config import get_config
+
+console = Console()
+
+def run_git_command(cmd: List[str], cwd: Path) -> bool:
+    """Run a git command in the specified directory."""
+    try:
+        subprocess.run(
+            cmd,
+            cwd=cwd,
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        return True
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]Git Error:[/red] {' '.join(cmd)}\n{e.stderr}")
+        return False
+    except FileNotFoundError:
+        console.print("[red]Error:[/red] git command not found.")
+        return False
+
+def get_config_file_path(root: Path) -> Path:
+    """Determine the config file to update."""
+    # Priority 1: .monoco/config.yaml
+    hidden = root / ".monoco" / "config.yaml"
+    if hidden.exists():
+        return hidden
+    
+    # Priority 2: monoco.yaml
+    visible = root / "monoco.yaml"
+    if visible.exists():
+        return visible
+    
+    # Default to .monoco/config.yaml for new files
+    hidden.parent.mkdir(exist_ok=True)
+    return hidden
+
+def update_config_repos(root: Path, repo_name: str, repo_url: str, remove: bool = False):
+    """Update the repos list in the config file."""
+    config_path = get_config_file_path(root)
+    
+    data = {}
+    if config_path.exists():
+        try:
+            with open(config_path, "r") as f:
+                data = yaml.safe_load(f) or {}
+        except Exception:
+            data = {}
+            
+    # Ensure structure exists
+    if "project" not in data:
+        data["project"] = {}
+    if "spike_repos" not in data["project"]:
+        data["project"]["spike_repos"] = {}
+        
+    if remove:
+        if repo_name in data["project"]["spike_repos"]:
+            del data["project"]["spike_repos"][repo_name]
+    else:
+        data["project"]["spike_repos"][repo_name] = repo_url
+        
+    with open(config_path, "w") as f:
+        yaml.dump(data, f, sort_keys=False, default_flow_style=False)
+
+def ensure_gitignore(root: Path, target_dir_name: str):
+    """Ensure the target directory is in .gitignore."""
+    gitignore = root / ".gitignore"
+    if not gitignore.exists():
+        gitignore.write_text(f"{target_dir_name}/\n")
+        return
+
+    content = gitignore.read_text()
+    if f"{target_dir_name}/" not in content and f"{target_dir_name}" not in content:
+        # Avoid redundant newlines if file ends with one
+        prefix = "\n" if content and not content.endswith("\n") else ""
+        with open(gitignore, "a") as f:
+            f.write(f"{prefix}{target_dir_name}/\n")
+
+def sync_repo(root: Path, spikes_dir: Path, name: str, url: str):
+    """Clone or Pull a repo."""
+    target_path = spikes_dir / name
+    
+    if target_path.exists() and (target_path / ".git").exists():
+        console.print(f"Updating [bold]{name}[/bold]...")
+        run_git_command(["git", "pull"], cwd=target_path)
+    else:
+        # If dir exists but not a git repo, warn or error? 
+        # For safety, if non-empty and not git, skip or error.
+        if target_path.exists() and any(target_path.iterdir()):
+             console.print(f"[yellow]Skipping {name}:[/yellow] Directory exists and is not empty, but not a git repo.")
+             return
+
+        console.print(f"Cloning [bold]{name}[/bold]...")
+        target_path.mkdir(parents=True, exist_ok=True)
+        run_git_command(["git", "clone", url, "."], cwd=target_path)
+
+def remove_repo_dir(spikes_dir: Path, name: str):
+    """Physically remove the repo directory."""
+    target_path = spikes_dir / name
+
+    if target_path.exists():
+        shutil.rmtree(target_path)
+
+SKILL_CONTENT = """---
+name: git-repo-spike
+description: Manage external Git repositories as References in `.reference/`.
+---
+
+# Git Repo Spike (Reference Management)
+
+This skill normalizes how we introduce external code repositories.
+
+## Core Principles
+1. **Read-Only**: Code in `.reference/` is for reference only.
+2. **Isolation**: All external repos sit within `.reference/`.
+3. **VCS Hygiene**: `.reference/` is gitignored. We track the intent to clone, not the files.
+
+## Workflow
+1. **Add**: `monoco spike add <url>`
+2. **Sync**: `monoco spike sync` (Clones/Pulls all repos)
+3. **Remove**: `monoco spike remove <name>`
+"""
+
+PROMPT_CONTENT = """### Spike (Research)
+Manage external reference repositories.
+- **Add Repo**: `monoco spike add <url>` (Available in `.reference/<name>` for reading)
+- **Sync**: `monoco spike sync` (Run to download content)
+- **Constraint**: Never edit files in `.reference/`. Treat them as read-only external knowledge."""
+
+def init(root: Path, spikes_dir_name: str):
+    """Initialize Spike environment."""
+    ensure_gitignore(root, spikes_dir_name)
+    (root / spikes_dir_name).mkdir(exist_ok=True)
+
+def get_resources() -> Dict[str, Any]:
+    return {
+        "skills": {
+            "git-repo-spike": SKILL_CONTENT
+        },
+        "prompts": {
+            "spike": PROMPT_CONTENT
+        }
+    }
+