Simplify /note to uv-run CLI tool

- Replace TypeScript tool with simple Python script
- Location: .opencode/bin/note (executable)
- Commands: create, save, list, search
- Output: JSON for model to present
- No dependencies, no pyproject.toml changes

Author: apiad

.opencode/bin/note

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""note - Simple CLI for structured notes.
+
+Usage:
+  uv run note create --content "..."
+  uv run note save --content "..." --filename "name"
+  uv run note list
+  uv run note search --query "..."
+"""
+import json
+import os
+import re
+import sys
+from datetime import datetime
+from pathlib import Path
+
+NOTES_DIR = Path(".knowledge/notes")
+
+
+def generate_id():
+    date = datetime.now().strftime("%Y-%m-%d")
+    random = os.urandom(3).hex()[:6]
+    return f"{date}-{random}"
+
+
+def slugify(title: str) -> str:
+    return re.sub(r"[^a-z0-9]+", "-", title.lower()).strip("-")
+
+
+def suggest_tags(content: str) -> list[str]:
+    content_lower = content.lower()
+    tags = set()
+    patterns = {
+        "auth": ["auth", "oauth", "login"],
+        "api": ["api", "endpoint"],
+        "design": ["design", "architecture"],
+        "bug": ["bug", "error", "fix"],
+    }
+    for tag, keywords in patterns.items():
+        if any(kw in content_lower for kw in keywords):
+            tags.add(tag)
+    return sorted(tags)
+
+
+def create(args):
+    content = args.get("--content") or args.get("-c")
+    title = args.get("--title") or args.get("-t")
+    
+    if not content:
+        print("Error: --content required", file=sys.stderr)
+        sys.exit(1)
+    
+    if not title:
+        first = content.split("\n")[0].strip()
+        title = first if len(first) < 80 else " ".join(content.split()[:5]) + "..."
+    
+    tags = suggest_tags(content)
+    note_id = generate_id()
+    filename = slugify(title) or f"note-{note_id}"
+    
+    result = {
+        "id": note_id,
+        "title": title,
+        "created": datetime.now().strftime("%Y-%m-%d"),
+        "type": "note",
+        "tags": tags,
+        "filename": filename,
+    }
+    
+    print(json.dumps(result, indent=2))
+
+
+def save(args):
+    content = args.get("--content") or args.get("-c")
+    filename = args.get("--filename") or args.get("-f")
+    
+    if not content or not filename:
+        print("Error: --content and --filename required", file=sys.stderr)
+        sys.exit(1)
+    
+    NOTES_DIR.mkdir(parents=True, exist_ok=True)
+    filepath = NOTES_DIR / f"{filename}.md"
+    
+    if filepath.exists():
+        print(f'{{"error": "File exists: {filepath}"}}')
+        sys.exit(1)
+    
+    filepath.write_text(content)
+    print(json.dumps({"saved": str(filepath)}))
+
+
+def list_notes(args):
+    if not NOTES_DIR.exists():
+        print(json.dumps({"notes": [], "count": 0}))
+        return
+    
+    notes = sorted([f.name for f in NOTES_DIR.glob("*.md")], reverse=True)
+    print(json.dumps({"notes": notes, "count": len(notes)}))
+
+
+def search(args):
+    query = args.get("--query") or args.get("-q")
+    if not query:
+        print("Error: --query required", file=sys.stderr)
+        sys.exit(1)
+    
+    results = []
+    if NOTES_DIR.exists():
+        for f in NOTES_DIR.glob("*.md"):
+            if query.lower() in f.read_text().lower():
+                results.append(f.name)
+    
+    print(json.dumps({"results": sorted(results, reverse=True)}))
+
+
+def parse_args():
+    args = {}
+    i = 1
+    while i < len(sys.argv):
+        if sys.argv[i].startswith("--") or sys.argv[i].startswith("-"):
+            key = sys.argv[i]
+            if i + 1 < len(sys.argv) and not sys.argv[i + 1].startswith("-"):
+                args[key] = sys.argv[i + 1]
+                i += 2
+            else:
+                args[key] = True
+                i += 1
+        else:
+            args["_command"] = sys.argv[i]
+            i += 1
+    return args
+
+
+def main():
+    if len(sys.argv) < 2:
+        print(__doc__)
+        sys.exit(1)
+    
+    command = sys.argv[1]
+    args = parse_args()
+    
+    commands = {
+        "create": create,
+        "save": save,
+        "list": list_notes,
+        "search": search,
+    }
+    
+    if command not in commands:
+        print(f"Unknown command: {command}")
+        print(__doc__)
+        sys.exit(1)
+    
+    commands[command](args)
+
+
+if __name__ == "__main__":
+    main()

.opencode/commands/note.md

@@ -1,132 +1,64 @@
 # /note Command
 
-Transform raw thoughts into structured, Obsidian-compatible notes.
+Create structured notes from raw thoughts.
 
 ## Usage
 
 ```
 /note <your raw thoughts>
 ```
 
-## Flow
+## How It Works
 
-1. **Create** - User provides raw content
-2. **Structure** - Tool structures into YAML + Markdown with tags and [[links]]
-3. **Review** - Model presents formatted note
-4. **Iterate** - User can request modifications (re-runs tool)
-5. **Save** - User says "save" → Tool writes to file
+The model runs the `note` CLI tool:
 
-## Tool Actions
+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"`
 
-### `create` - Structure content
+## CLI Tool
 
-```typescript
-note_tool(
-  action: "create",
-  content: "your raw thoughts...",
-  mode: "draft",           // Returns formatted note for review
-  title?: string,          // Optional title override
-  tags?: string,           // Comma-separated tags
-  modifications?: string    // Instructions for changes
-)
-```
+**Location**: `.opencode/bin/note`
 
-Returns:
-- `frontmatter` - YAML metadata (id, title, created, type, tags)
-- `body` - Structured markdown body
-- `suggested_tags` - Auto-detected tags
-- `suggested_links` - Detected [[WikiLinks]]
-- `filename_suggestion` - Auto-generated filename
-
-### `create` with `mode: "finalize"` - Save directly
-
-```typescript
-note_tool(
-  action: "create",
-  content: "...",
-  mode: "finalize",
-  filename?: string        // Optional, auto-generated if not provided
-)
-```
+**Commands**:
 
-### Other actions
+```bash
+# Structure content into note
+uv run note create --content "Your thoughts..."
 
-- `save` - Write pre-formatted content directly
-- `list` - Show existing notes
-- `search` - Search note contents
+# Save to file
+uv run note save --content "..." --filename "name"
 
-## Example Session
+# List existing notes
+uv run note list
 
+# Search notes
+uv run note search --query "auth"
 ```
-User: /note "I was thinking about the auth flow. We need to handle OAuth2 
-            and API keys. Error handling is important but I'm not sure 
-            where it fits."
-
-Model: [Calls note_tool(action="create", content="...", mode="draft")]
-
----
-id: 2026-03-27-a1b2c3
-title: Auth Flow Design Thoughts
-created: 2026-03-27
-type: note
-tags:
-  - auth
-  - oauth
-  - api
----
-
-## Auth Flow Design Thoughts
-
-## Authentication Methods
-We need to handle OAuth2 and API keys for the new feature.
-
-## Error Handling Questions
-Error handling is important but I'm not sure where it fits.
-
-**Suggested Tags:** auth, oauth, api  
-**Suggested Links:** [[OAuth2]], [[API Keys]], [[Error Handling]]  
-**Suggested Filename:** auth-flow-design-thoughts
 
-Want me to save this, or would you like modifications?
+## Example
 
-User: Add a section about OAuth2 implementation details
-
-Model: [Calls note_tool(action="create", content="...", mode="draft", 
-                       modifications="Add section about OAuth2 implementation")]
-
-[Returns updated note with new section]
-
-User: Save as auth-design
-
-Model: [Calls note_tool(action="create", content="...", mode="finalize", 
-                       filename="auth-design")]
-
-✅ Saved to .knowledge/notes/auth-design.md
 ```
+User: /note "I was thinking about auth flow. We need OAuth2."
 
-## How It Works
-
-The **tool** does all the work:
-- Parses raw content
-- Extracts/generates title
-- Structures into sections (## headings)
-- Generates YAML frontmatter
-- Suggests tags based on keywords
-- Identifies [[WikiLinks]]
-- Formats Obsidian-compatible output
+Model: uv run note create --content "I was thinking about auth flow..."
 
-The **model** just:
-- Calls the tool
-- Presents the result
-- Handles user feedback
-- Re-calls tool for modifications
+Output:
+{
+  "id": "2026-03-27-abc123",
+  "title": "Auth Flow Thoughts",
+  "created": "2026-03-27",
+  "type": "note",
+  "tags": ["auth"],
+  "filename": "auth-flow-thoughts"
+}
 
-## Output Location
+Model: Here's your note with tags: auth. Save as "auth-flow-thoughts"?
 
-All notes saved to: `.knowledge/notes/<filename>.md`
+User: Yes
 
-## Related
+Model: uv run note save --content "..." --filename "auth-flow-thoughts"
+```
 
-- [[.knowledge]] - Knowledge directory
-- [[/research]] - Deep research (requires workflow state)
-- [[/plan]] - Structured planning (requires workflow state)
+Notes saved to: `.knowledge/notes/<filename>.md`