jfox-cli 0.1.0__py3-none-any.whl

jfox/template.py

@@ -0,0 +1,301 @@
+"""Template management for standardized note creation"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import yaml
+from jinja2 import Template, UndefinedError
+
+from .models import NoteType
+
+
+@dataclass
+class NoteTemplate:
+    """Template definition for creating notes"""
+    name: str
+    description: str
+    note_type: str
+    title_format: str
+    content: str
+    tags: List[str] = field(default_factory=list)
+    is_builtin: bool = False
+
+
+class TemplateError(Exception):
+    """Template-related error"""
+    pass
+
+
+class TemplateNotFoundError(TemplateError):
+    """Template not found error"""
+    pass
+
+
+class TemplateRenderError(TemplateError):
+    """Template rendering error"""
+    pass
+
+
+class TemplateManager:
+    """Manage note templates"""
+    
+    # Built-in template definitions
+    BUILTIN_TEMPLATES = {
+        "quick": {
+            "name": "quick",
+            "description": "快速记录想法",
+            "note_type": "fleeting",
+            "title_format": "{{date}}-{{title}}",
+            "content": '## 快速笔记\n\n创建于 {{datetime}}\n\n{{content}}',
+            "tags": ["fleeting"],
+        },
+        "meeting": {
+            "name": "meeting",
+            "description": "会议记录模板",
+            "note_type": "permanent",
+            "title_format": "{{date}}-{{title}}",
+            "content": '## 会议信息\n- **日期**: {{date}}\n- **时间**: {{time}}\n\n## 参会人员\n\n## 议程\n\n## 会议内容\n\n{{content}}\n\n## 行动项\n- [ ] ',
+            "tags": ["meeting", "permanent"],
+        },
+        "literature": {
+            "name": "literature",
+            "description": "阅读笔记模板",
+            "note_type": "literature",
+            "title_format": "{{title}}",
+            "content": '## 文献信息\n- **来源**: {{source}}\n- **作者**: \n- **阅读日期**: {{date}}\n\n## 核心观点\n\n## 个人思考\n\n## 关联笔记\n\n{{content}}',
+            "tags": ["literature"],
+        },
+    }
+    
+    def __init__(self, templates_dir: Path):
+        """
+        Initialize template manager
+        
+        Args:
+            templates_dir: Directory to store templates
+        """
+        self.templates_dir = templates_dir
+        self._ensure_templates_dir()
+        self._ensure_builtin_templates()
+    
+    def _ensure_templates_dir(self) -> None:
+        """Create templates directory if it doesn't exist"""
+        self.templates_dir.mkdir(parents=True, exist_ok=True)
+    
+    def _ensure_builtin_templates(self) -> None:
+        """Create built-in templates if they don't exist"""
+        for name, template_data in self.BUILTIN_TEMPLATES.items():
+            template_path = self.templates_dir / f"{name}.yaml"
+            if not template_path.exists():
+                self._save_template_file(template_path, template_data, is_builtin=True)
+    
+    def _save_template_file(self, path: Path, data: Dict[str, Any], is_builtin: bool = False) -> None:
+        """Save template to YAML file"""
+        template_data = {
+            "name": data["name"],
+            "description": data["description"],
+            "note_type": data["note_type"],
+            "title_format": data["title_format"],
+            "content": data["content"],
+            "tags": data.get("tags", []),
+            "is_builtin": is_builtin,
+        }
+        with open(path, "w", encoding="utf-8") as f:
+            yaml.dump(template_data, f, allow_unicode=True, sort_keys=False)
+    
+    def list_templates(self) -> List[NoteTemplate]:
+        """
+        List all available templates
+        
+        Returns:
+            List of NoteTemplate objects
+        """
+        templates = []
+        
+        # Scan templates directory for YAML files
+        for template_file in self.templates_dir.glob("*.yaml"):
+            try:
+                template = self._load_template_file(template_file)
+                if template:
+                    templates.append(template)
+            except Exception:
+                # Skip invalid template files
+                continue
+        
+        # Sort by name
+        templates.sort(key=lambda t: t.name)
+        return templates
+    
+    def _load_template_file(self, path: Path) -> Optional[NoteTemplate]:
+        """Load a single template from file"""
+        with open(path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+        
+        if not data:
+            return None
+        
+        return NoteTemplate(
+            name=data.get("name", path.stem),
+            description=data.get("description", ""),
+            note_type=data.get("note_type", "fleeting"),
+            title_format=data.get("title_format", "{{title}}"),
+            content=data.get("content", ""),
+            tags=data.get("tags", []),
+            is_builtin=data.get("is_builtin", False),
+        )
+    
+    def get_template(self, name: str) -> Optional[NoteTemplate]:
+        """
+        Get a template by name
+        
+        Args:
+            name: Template name
+            
+        Returns:
+            NoteTemplate or None if not found
+        """
+        template_path = self.templates_dir / f"{name}.yaml"
+        
+        if not template_path.exists():
+            return None
+        
+        return self._load_template_file(template_path)
+    
+    def render(self, name: str, variables: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Render a template with variables
+        
+        Args:
+            name: Template name
+            variables: Variables to use in rendering
+            
+        Returns:
+            Dict with rendered title, content, note_type, and tags
+            
+        Raises:
+            TemplateNotFoundError: If template doesn't exist
+            TemplateRenderError: If template rendering fails
+        """
+        template = self.get_template(name)
+        
+        if not template:
+            available = [t.name for t in self.list_templates()]
+            raise TemplateNotFoundError(
+                f"Template '{name}' not found. "
+                f"Available templates: {', '.join(available) if available else 'none'}"
+            )
+        
+        # Merge provided variables with defaults
+        render_vars = self._get_default_variables()
+        render_vars.update(variables)
+        
+        try:
+            # Render title
+            title_template = Template(template.title_format)
+            rendered_title = title_template.render(**render_vars)
+            
+            # Render content
+            content_template = Template(template.content)
+            rendered_content = content_template.render(**render_vars)
+            
+        except UndefinedError as e:
+            raise TemplateRenderError(f"Template variable undefined: {e}")
+        except Exception as e:
+            raise TemplateRenderError(f"Failed to render template: {e}")
+        
+        return {
+            "title": rendered_title,
+            "content": rendered_content,
+            "note_type": template.note_type,
+            "tags": template.tags.copy(),
+        }
+    
+    def _get_default_variables(self) -> Dict[str, str]:
+        """Get default template variables (date, time, etc.)"""
+        now = datetime.now()
+        return {
+            "date": now.strftime("%Y-%m-%d"),
+            "time": now.strftime("%H:%M"),
+            "datetime": now.strftime("%Y-%m-%d %H:%M"),
+        }
+    
+    def get_available_templates(self) -> List[str]:
+        """Get list of available template names"""
+        return [t.name for t in self.list_templates()]
+    
+    def create_template(self, name: str, description: str, note_type: str, 
+                       title_format: str, content: str, tags: List[str]) -> NoteTemplate:
+        """
+        Create a new custom template
+        
+        Args:
+            name: Template name
+            description: Template description
+            note_type: Note type (fleeting/literature/permanent)
+            title_format: Title format with variables
+            content: Template content
+            tags: Default tags
+            
+        Returns:
+            Created NoteTemplate
+            
+        Raises:
+            TemplateError: If template already exists
+        """
+        template_path = self.templates_dir / f"{name}.yaml"
+        
+        if template_path.exists():
+            raise TemplateError(f"Template '{name}' already exists")
+        
+        template_data = {
+            "name": name,
+            "description": description,
+            "note_type": note_type,
+            "title_format": title_format,
+            "content": content,
+            "tags": tags,
+            "is_builtin": False,
+        }
+        
+        self._save_template_file(template_path, template_data, is_builtin=False)
+        
+        return NoteTemplate(
+            name=name,
+            description=description,
+            note_type=note_type,
+            title_format=title_format,
+            content=content,
+            tags=tags,
+            is_builtin=False,
+        )
+    
+    def delete_template(self, name: str) -> None:
+        """
+        Delete a custom template
+        
+        Args:
+            name: Template name
+            
+        Raises:
+            TemplateNotFoundError: If template doesn't exist
+            TemplateError: If trying to delete a built-in template
+        """
+        template = self.get_template(name)
+        
+        if not template:
+            raise TemplateNotFoundError(f"Template '{name}' not found")
+        
+        if template.is_builtin:
+            raise TemplateError(f"Cannot remove built-in template '{name}'")
+        
+        template_path = self.templates_dir / f"{name}.yaml"
+        template_path.unlink()
+    
+    def get_template_path(self, name: str) -> Optional[Path]:
+        """Get the file path of a template"""
+        template_path = self.templates_dir / f"{name}.yaml"
+        if template_path.exists():
+            return template_path
+        return None

jfox/template_cli.py

@@ -0,0 +1,327 @@
+"""Template management CLI commands"""
+
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional, List
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from .config import config
+from .template import TemplateManager, TemplateError, TemplateNotFoundError
+
+
+console = Console()
+
+# Create template subcommand app
+template_app = typer.Typer(
+    name="template",
+    help="Manage note templates",
+)
+
+
+def get_template_manager() -> TemplateManager:
+    """Get template manager instance for current knowledge base"""
+    templates_dir = config.base_dir / ".zk" / "templates"
+    return TemplateManager(templates_dir)
+
+
+@template_app.command("list")
+def list_templates(
+    kb: Optional[str] = typer.Option(None, "--kb", "-k", help="目标知识库名称"),
+    output_format: str = typer.Option("table", "--format", "-f", help="输出格式: json, table"),
+    json_output: bool = typer.Option(False, "--json", help="JSON 输出（快捷方式，等同于 --format json）"),
+):
+    """列出所有可用模板"""
+    try:
+        from .config import use_kb
+        
+        # 处理 --json 快捷方式
+        if json_output:
+            output_format = "json"
+        
+        if kb:
+            with use_kb(kb):
+                manager = get_template_manager()
+                templates = manager.list_templates()
+        else:
+            manager = get_template_manager()
+            templates = manager.list_templates()
+        
+        # Separate built-in and custom templates
+        builtin_templates = [t for t in templates if t.is_builtin]
+        custom_templates = [t for t in templates if not t.is_builtin]
+        
+        if output_format == "json":
+            import json
+            result = {
+                "builtin": [
+                    {
+                        "name": t.name,
+                        "description": t.description,
+                        "note_type": t.note_type,
+                    }
+                    for t in builtin_templates
+                ],
+                "custom": [
+                    {
+                        "name": t.name,
+                        "description": t.description,
+                        "note_type": t.note_type,
+                    }
+                    for t in custom_templates
+                ],
+            }
+            print(json.dumps(result, ensure_ascii=False, indent=2))
+        elif output_format == "table":
+            if builtin_templates:
+                console.print("[bold]Built-in Templates:[/bold]")
+                table = Table()
+                table.add_column("Name", style="cyan")
+                table.add_column("Description", style="white")
+                table.add_column("Type", style="green")
+                
+                for t in builtin_templates:
+                    table.add_row(t.name, t.description, t.note_type)
+                console.print(table)
+                console.print()
+            
+            if custom_templates:
+                console.print("[bold]Custom Templates:[/bold]")
+                table = Table()
+                table.add_column("Name", style="cyan")
+                table.add_column("Description", style="white")
+                table.add_column("Type", style="green")
+                
+                for t in custom_templates:
+                    table.add_row(t.name, t.description, t.note_type)
+                console.print(table)
+            elif not builtin_templates:
+                console.print("[dim]No templates found[/dim]")
+        else:
+            console.print(f"[red]Error:[/red] Unsupported format: {output_format}")
+            raise typer.Exit(1)
+                
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@template_app.command("show")
+def show_template(
+    name: str = typer.Argument(..., help="模板名称"),
+    kb: Optional[str] = typer.Option(None, "--kb", "-k", help="目标知识库名称"),
+    json_output: bool = typer.Option(True, "--json/--no-json", help="JSON 输出"),
+):
+    """查看模板详情"""
+    try:
+        from .config import use_kb
+        
+        if kb:
+            with use_kb(kb):
+                manager = get_template_manager()
+                template = manager.get_template(name)
+        else:
+            manager = get_template_manager()
+            template = manager.get_template(name)
+        
+        if not template:
+            available = manager.get_available_templates()
+            console.print(f"[red]Template '{name}' not found[/red]")
+            if available:
+                console.print(f"[dim]Available: {', '.join(available)}[/dim]")
+            raise typer.Exit(1)
+        
+        if json_output:
+            import json
+            result = {
+                "name": template.name,
+                "description": template.description,
+                "note_type": template.note_type,
+                "title_format": template.title_format,
+                "content": template.content,
+                "tags": template.tags,
+                "is_builtin": template.is_builtin,
+            }
+            print(json.dumps(result, ensure_ascii=False, indent=2))
+        else:
+            builtin_tag = " (built-in)" if template.is_builtin else ""
+            console.print(f"[bold]{template.name}{builtin_tag}[/bold]")
+            console.print(f"[dim]{template.description}[/dim]")
+            console.print()
+            console.print(f"Type: {template.note_type}")
+            console.print(f"Title Format: {template.title_format}")
+            console.print(f"Tags: {', '.join(template.tags) if template.tags else 'none'}")
+            console.print()
+            console.print("[bold]Content:[/bold]")
+            console.print(template.content)
+            
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@template_app.command("create")
+def create_template(
+    name: str = typer.Argument(..., help="模板名称"),
+    description: Optional[str] = typer.Option(None, "--description", "-d", help="模板描述"),
+    note_type: str = typer.Option("fleeting", "--type", "-t", help="笔记类型 (fleeting/literature/permanent)"),
+    title_format: str = typer.Option("{{date}}-{{title}}", "--title-format", help="标题格式"),
+    content: Optional[str] = typer.Option(None, "--content", "-c", help="模板内容"),
+    tags: Optional[List[str]] = typer.Option(None, "--tag", help="默认标签"),
+    kb: Optional[str] = typer.Option(None, "--kb", "-k", help="目标知识库名称"),
+    force: bool = typer.Option(False, "--force", "-f", help="覆盖已存在模板"),
+    json_output: bool = typer.Option(True, "--json/--no-json", help="JSON 输出"),
+):
+    """创建新模板"""
+    try:
+        from .config import use_kb
+        
+        if kb:
+            with use_kb(kb):
+                manager = get_template_manager()
+        else:
+            manager = get_template_manager()
+        
+        # Check if template exists
+        existing = manager.get_template(name)
+        if existing and not force:
+            console.print(f"[red]Template '{name}' already exists[/red]")
+            console.print("[dim]Use --force to overwrite[/dim]")
+            raise typer.Exit(1)
+        
+        # Interactive mode if not all required fields provided
+        desc = description or typer.prompt("Description", default=f"Custom {name} template")
+        content_str = content or typer.prompt(
+            "Content (use {{variable}} for variables)",
+            default="## {{title}}\n\n{{content}}"
+        )
+        
+        # Validate note_type
+        if note_type not in ["fleeting", "literature", "permanent"]:
+            console.print(f"[red]Invalid note type: {note_type}[/red]")
+            raise typer.Exit(1)
+        
+        template = manager.create_template(
+            name=name,
+            description=desc,
+            note_type=note_type,
+            title_format=title_format,
+            content=content_str,
+            tags=tags or [],
+        )
+        
+        if json_output:
+            import json
+            result = {
+                "success": True,
+                "template": {
+                    "name": template.name,
+                    "description": template.description,
+                    "note_type": template.note_type,
+                },
+            }
+            print(json.dumps(result, ensure_ascii=False, indent=2))
+        else:
+            action = "updated" if existing else "created"
+            console.print(f"[green]Template '{name}' {action} successfully[/green]")
+            
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@template_app.command("edit")
+def edit_template(
+    name: str = typer.Argument(..., help="模板名称"),
+    kb: Optional[str] = typer.Option(None, "--kb", "-k", help="目标知识库名称"),
+):
+    """编辑模板（使用系统默认编辑器）"""
+    try:
+        from .config import use_kb
+        
+        if kb:
+            with use_kb(kb):
+                manager = get_template_manager()
+                template = manager.get_template(name)
+        else:
+            manager = get_template_manager()
+            template = manager.get_template(name)
+        
+        if not template:
+            console.print(f"[red]Template '{name}' not found[/red]")
+            raise typer.Exit(1)
+        
+        if template.is_builtin:
+            console.print(f"[red]Cannot edit built-in template '{name}'[/red]")
+            console.print("[dim]Create a custom template instead[/dim]")
+            raise typer.Exit(1)
+        
+        template_path = manager.get_template_path(name)
+        if not template_path:
+            console.print(f"[red]Template file not found[/red]")
+            raise typer.Exit(1)
+        
+        # Get editor from environment
+        editor = os.environ.get("EDITOR", "notepad" if os.name == "nt" else "vi")
+        
+        # Open editor
+        subprocess.run([editor, str(template_path)], check=True)
+        console.print(f"[green]Template '{name}' updated[/green]")
+        
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]Editor failed: {e}[/red]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@template_app.command("remove")
+def remove_template(
+    name: str = typer.Argument(..., help="模板名称"),
+    kb: Optional[str] = typer.Option(None, "--kb", "-k", help="目标知识库名称"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="跳过确认"),
+    json_output: bool = typer.Option(True, "--json/--no-json", help="JSON 输出"),
+):
+    """删除自定义模板"""
+    try:
+        from .config import use_kb
+        
+        if kb:
+            with use_kb(kb):
+                manager = get_template_manager()
+        else:
+            manager = get_template_manager()
+        
+        template = manager.get_template(name)
+        if not template:
+            console.print(f"[red]Template '{name}' not found[/red]")
+            raise typer.Exit(1)
+        
+        if template.is_builtin:
+            console.print(f"[red]Cannot remove built-in template '{name}'[/red]")
+            raise typer.Exit(1)
+        
+        # Confirm deletion
+        if not yes:
+            if not json_output:
+                confirm = input(f"Delete template '{name}'? (y/N): ")
+                if confirm.lower() != "y":
+                    console.print("Cancelled")
+                    raise typer.Exit(0)
+        
+        manager.delete_template(name)
+        
+        if json_output:
+            import json
+            result = {"success": True, "deleted": name}
+            print(json.dumps(result, ensure_ascii=False, indent=2))
+        else:
+            console.print(f"[green]Template '{name}' deleted[/green]")
+            
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)