Simplify note.py with Typer and stdin input

- Use Typer for CLI parsing
- Content read from stdin
- Required: --title, Optional: --slug, --tags
- Always prints formatted note to stdout
- --save flag writes to .knowledge/notes/<slug>.md
- Inline script metadata for uv dependencies

Author: apiad

.knowledge/notes/auth-thoughts.md

@@ -0,0 +1,12 @@
+---
+title: "Auth Thoughts"
+slug: auth-thoughts
+date: 2026-03-27
+tags:
+  - auth
+  - oauth
+---
+
+# Auth Thoughts
+
+This is my note content about auth flow.

.opencode/bin/note

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "typer", "pyyaml"
+# ]
+# ///
+
+"""Create structured notes.
+
+Usage:
+  uv run note --title "My Note" [--slug my-note] [--tags "tag1,tag2"] < content.txt
+  uv run note --title "My Note" --save < content.txt
+"""
+import sys
+from datetime import datetime
+from pathlib import Path
+
+import typer
+
+app = typer.Typer(help="Create structured notes")
+NOTES_DIR = Path(".knowledge/notes")
+
+
+def slugify(title: str) -> str:
+    """Convert title to URL-safe slug."""
+    import re
+    return re.sub(r"[^a-z0-9]+", "-", title.lower()).strip("-")
+
+
+def format_note(title: str, slug: str, tags: list[str], content: str) -> str:
+    """Format note with YAML frontmatter."""
+    date = datetime.now().strftime("%Y-%m-%d")
+
+    lines = ["---"]
+    lines.append(f'title: "{title}"')
+    lines.append(f"slug: {slug}")
+    lines.append(f"date: {date}")
+    lines.append("tags:")
+    for tag in tags:
+        lines.append(f"  - {tag}")
+    lines.append("---")
+    lines.append("")
+    lines.append(f"# {title}")
+    lines.append("")
+    lines.append(content)
+
+    return "\n".join(lines)
+
+
+@app.command()
+def main(
+    title: str = typer.Option(..., "--title", "-t", help="Note title"),
+    slug: str | None = typer.Option(None, "--slug", "-s", help="URL slug (auto-generated from title if not provided)"),
+    tags: str = typer.Option("", "--tags", help="Comma-separated tags"),
+    save: bool = typer.Option(False, "--save", help="Save to file (prints to stdout regardless)"),
+):
+    """Create a structured note from stdin content."""
+    # Read content from stdin
+    content = sys.stdin.read().strip()
+
+    if not content:
+        typer.echo("Error: No content provided via stdin", err=True)
+        raise typer.Exit(1)
+
+    # Generate slug if not provided
+    if not slug:
+        slug = slugify(title)
+
+    # Parse tags
+    tag_list = [t.strip() for t in tags.split(",") if t.strip()]
+
+    # Format the note
+    formatted = format_note(title, slug, tag_list, content)
+
+    # Print to stdout
+    print(formatted)
+
+    # Save if requested
+    if save:
+        NOTES_DIR.mkdir(parents=True, exist_ok=True)
+        filepath = NOTES_DIR / f"{slug}.md"
+
+        if filepath.exists():
+            typer.echo(f"\nError: File already exists: {filepath}", err=True)
+            raise typer.Exit(1)
+
+        filepath.write_text(formatted)
+        typer.echo(f"\n✓ Saved to: {filepath}")
+
+
+if __name__ == "__main__":
+    app()

.opencode/bin/note.py

@@ -1,64 +1,76 @@
 # /note Command
 
-Create structured notes from raw thoughts.
+Create structured notes from content via stdin.
 
 ## Usage
 
 ```
-/note <your raw thoughts>
+/note --title "Title" [--tags "tag1,tag2"] [--save]
 ```
 
 ## How It Works
 
-The model runs the `note` CLI tool:
+Model pipes content to `note.py` via stdin:
 
-1. **Create**: `uv run note create --content "..."`
-2. **Review**: Model presents structured note
-3. **Iterate**: Re-run with modifications if needed
-4. **Save**: `uv run note save --content "..." --filename "name"`
+```bash
+echo "Note content..." | uv run note --title "Title" --tags "tag1"
+```
+
+## CLI Options
 
-## CLI Tool
+- `--title, -t` (required) - Note title
+- `--slug, -s` (optional) - URL slug (auto-generated from title)  
+- `--tags` (optional) - Comma-separated tags
+- `--save` (flag) - Save to file (always prints to stdout)
 
-**Location**: `.opencode/bin/note`
+## Example
 
-**Commands**:
+```
+User: /note "Auth Design Thoughts"
 
-```bash
-# Structure content into note
-uv run note create --content "Your thoughts..."
+Model: echo "I was thinking about auth flow. We need OAuth2..." | \
+       uv run note --title "Auth Design Thoughts" --tags "auth,design"
 
-# Save to file
-uv run note save --content "..." --filename "name"
+Output:
+---
+title: "Auth Design Thoughts"
+slug: auth-design-thoughts
+date: 2026-03-27
+tags:
+  - auth
+  - design
+---
 
-# List existing notes
-uv run note list
+# Auth Design Thoughts
 
-# Search notes
-uv run note search --query "auth"
-```
+I was thinking about auth flow. We need OAuth2...
 
-## Example
+User: Save it
 
+Model: [re-runs with --save flag]
 ```
-User: /note "I was thinking about auth flow. We need OAuth2."
 
-Model: uv run note create --content "I was thinking about auth flow..."
+## Output
 
-Output:
-{
-  "id": "2026-03-27-abc123",
-  "title": "Auth Flow Thoughts",
-  "created": "2026-03-27",
-  "type": "note",
-  "tags": ["auth"],
-  "filename": "auth-flow-thoughts"
-}
+Always prints YAML frontmatter + Markdown to stdout:
 
-Model: Here's your note with tags: auth. Save as "auth-flow-thoughts"?
+```yaml
+---
+title: "My Title"
+slug: my-title
+date: 2026-03-27
+tags:
+  - tag1
+  - tag2
+---
 
-User: Yes
+# My Title
 
-Model: uv run note save --content "..." --filename "auth-flow-thoughts"
+Content from stdin...
 ```
 
-Notes saved to: `.knowledge/notes/<filename>.md`
+With `--save`, also writes to: `.knowledge/notes/<slug>.md`
+
+## Script Location
+
+`.opencode/bin/note.py` (inline script with uv dependencies)