jsonify
diff --git a/‎CHANGELOG.md‎
Lines changed: 42 additions & 0 deletions b/‎CHANGELOG.md‎
Lines changed: 42 additions & 0 deletions
diff --git a/‎CLAUDE.md‎
Lines changed: 46 additions & 0 deletions b/‎CLAUDE.md‎
Lines changed: 46 additions & 0 deletions
diff --git a/‎dev-docs/TESTING-AUTO-TAGGING.md‎
Lines changed: 238 additions & 0 deletions b/‎dev-docs/TESTING-AUTO-TAGGING.md‎
Lines changed: 238 additions & 0 deletions
@@ -2,6 +2,48 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [Unreleased]
+
+### Features
+
+* **Smart Auto-Tagging (Phase 1 - Infrastructure)**: Implement core auto-tagging infrastructure
+  - Add `TagParser` for YAML frontmatter tag storage with metadata
+  - Add `TagManager` for comprehensive tag operations (CRUD, search, rename, merge)
+  - Add `TagGenerator` with VS Code LLM API integration for AI-powered tag suggestions
+  - Add configuration settings for tagging (enabled, maxTags, customCategories, excludePatterns)
+  - Install `js-yaml` dependency for frontmatter parsing
+  - Tags stored in frontmatter format: `tags: [tag1, tag2, tag3]`
+  - Full caching support for performance optimization
+  - Compatible with existing tag system (inline #hashtags and frontmatter tags)
+
+* **Smart Auto-Tagging (Phase 3 - UI Integration)**: Connect infrastructure to VS Code UI
+  - Add `noted.generateTags` command for AI-powered tag generation
+  - Add `noted.generateTagsCurrentNote` command for current note
+  - Add `noted.batchGenerateTags` command for batch processing
+  - Add `noted.manageNoteTags` command for manual tag management
+  - Add `noted.addCustomTag` command for adding custom tags
+  - Context menu integration in notes tree view (right-click on notes)
+  - Commands available via Command Palette
+  - Interactive quick pick UI for reviewing and selecting suggested tags
+  - Progress indicators for batch operations
+  - Full error handling with user-friendly messages
+
+* **Smart Auto-Tagging (Phase 4 - Advanced Features)**: Enhance tagging with smart automation
+  - Auto-tag on note creation (controlled by `noted.tagging.autoTagOnCreate` setting)
+    * Automatically tags new notes 2 seconds after creation
+    * Only applies high-confidence tags (>0.75) automatically
+    * Works for daily notes and template-based notes
+    * Non-blocking: runs in background without interrupting workflow
+    * Shows notification with option to view/manage tags
+  - Tag statistics and analytics
+    * `noted.showTagStats` - Quick summary of tag usage
+    * `noted.showTagStatsDetailed` - Beautiful webview with comprehensive statistics
+    * Shows total tags, tagged/untagged notes, average tags per note
+    * Displays most used tags with usage counts
+    * Tracks AI-generated vs manually added tags
+    * Shows recently added tags (last 24 hours)
+    * Visual progress bars and interactive charts
+
 ## [1.39.0](https://github.com/jsonify/noted/compare/v1.38.1...v1.39.0) (2025-11-08)
 
 
 
@@ -53,6 +53,11 @@ The extension now uses a fully modular architecture with clear separation of con
   - `undoHelpers.ts`: Undo operation helpers (v1.13.0)
   - `graphService.ts`: Graph data preparation and analysis (v1.14.0)
   - `activityService.ts`: Activity metrics collection and analysis (v1.36.0)
+- **`src/tagging/`**: Smart Auto-Tagging infrastructure (v1.40.0 - Phase 1)
+  - `TagParser.ts`: YAML frontmatter tag parsing and writing
+  - `TagManager.ts`: Tag CRUD operations, search, rename, merge
+  - `TagGenerator.ts`: AI-powered tag generation using VS Code LLM API
+  - `autoTagCommands.ts`: Command handlers for auto-tagging features
 - **`src/providers/`**: VS Code tree view providers
   - `treeItems.ts`: Tree item classes (includes ConnectionSectionItem and ConnectionItem)
   - `templatesTreeProvider.ts`: Templates view
@@ -198,6 +203,42 @@ The extension now uses a fully modular architecture with clear separation of con
   - `openWorkspaceSearch()` opens VS Code search with tag regex pattern
   - `hasChildren()`, `getChildCount()` helper methods for hierarchy checks
 
+- **TagParser** (v1.40.0 - Smart Auto-Tagging Phase 1): YAML frontmatter tag parsing and writing
+  - `parseTags()` extracts tags from YAML frontmatter with metadata
+  - `writeTags()` inserts or updates frontmatter with tags in array format `[tag1, tag2, tag3]`
+  - `hasFrontmatter()` checks if file has YAML frontmatter block
+  - `removeTags()` removes all tags from a note
+  - Preserves existing frontmatter fields when updating
+  - Compatible with existing tag extraction system
+  - Stores tag metadata: name, confidence, source (ai/manual), addedAt timestamp
+
+- **TagManager** (v1.40.0 - Smart Auto-Tagging Phase 1): Comprehensive tag management operations
+  - `tagNote()` applies tags to a note file (merge or replace mode)
+  - `getNoteTags()` retrieves all tags from a specific note
+  - `findNotesByTag()` searches for notes containing a specific tag
+  - `getAllTags()` returns map of all unique tags with occurrence counts
+  - `removeTag()` removes a specific tag from a note
+  - `removeAllTags()` clears all tags from a note
+  - `renameTag()` renames a tag across all notes
+  - `mergeTags()` merges multiple tags into a single tag
+  - `deleteTag()` deletes a tag from all notes
+  - In-memory caching with TTL for performance (5 second cache)
+  - Singleton instance exported as `tagManager`
+  - Excludes template files from operations
+
+- **TagGenerator** (v1.40.0 - Smart Auto-Tagging Phase 1): AI-powered tag generation using VS Code LLM API
+  - `generateTags()` analyzes note content and generates tag suggestions with confidence scores
+  - Uses GitHub Copilot (gpt-4o) via VS Code Language Model API
+  - `buildTagPrompt()` constructs prompts with available categories and tagging rules
+  - `getCategories()` returns default + custom tag categories from configuration
+  - `parseTagResponse()` parses JSON response from LLM and filters by confidence (>0.6)
+  - Content hashing (SHA-256) for cache invalidation
+  - `needsRetagging()` checks if content has changed since last tagging
+  - Cache TTL: 1 hour
+  - Handles errors gracefully (Copilot not available, rate limiting, malformed responses)
+  - Default categories: note types, technologies, topics, status
+  - Singleton instance exported as `tagGenerator`
+
 ### File Organization Pattern
 
 Notes are stored in hierarchical structure:
@@ -250,6 +291,11 @@ Settings in `package.json` contributions:
 - `noted.template`: Template string (defined but not used - only built-in templates are used)
 - `noted.tagAutoComplete`: Enable tag autocomplete (default: true)
 - `noted.autoBacklinks`: Automatically append backlinks sections to notes (default: true, v1.24.0)
+- `noted.tagging.enabled`: Enable automatic tagging features (default: true, v1.40.0)
+- `noted.tagging.autoTagOnCreate`: Automatically tag new notes when created (default: false, v1.40.0)
+- `noted.tagging.maxTags`: Maximum number of tags to suggest per note (default: 5, v1.40.0)
+- `noted.tagging.customCategories`: Custom tag categories for your domain (default: [], v1.40.0)
+- `noted.tagging.excludePatterns`: Tag patterns to exclude from suggestions (default: ["draft", "temp"], v1.40.0)
 
 ## Commands
 
 
@@ -0,0 +1,238 @@
+# Smart Auto-Tagging Testing Guide
+
+## Prerequisites
+
+1. **GitHub Copilot**: You must have GitHub Copilot installed and signed in
+   - The feature uses VS Code's Language Model API (Copilot)
+   - Without Copilot, you'll get a friendly error message
+
+2. **Notes Folder**: Have the Noted extension configured with a notes folder
+
+## Quick Testing Steps
+
+### Test 1: Manual Tag Generation (Easiest to Start)
+
+1. **Create a test note** with some content:
+   ```
+   PROBLEM: User authentication fails with 401 error
+
+   STEPS TAKEN:
+   1. Checked JWT token expiration
+   2. Verified API endpoint configuration
+   3. Tested with Postman
+
+   SOLUTION:
+   The JWT secret key was incorrect in the .env file.
+   Updated the key and restarted the server.
+
+   NOTES:
+   - Need to add better error messages
+   - Should implement token refresh logic
+   ```
+
+2. **Open Command Palette** (`Cmd+Shift+P` or `Ctrl+Shift+P`)
+
+3. **Run**: `Noted: Generate Tags for Current Note`
+
+4. **Expected behavior**:
+   - Shows "Generating tags..." notification
+   - AI analyzes the content (takes 2-3 seconds)
+   - Quick pick appears with suggested tags and confidence scores
+   - Tags might include: `bug`, `authentication`, `jwt`, `problem-solving`
+   - High confidence tags (>80%) are pre-selected
+   - Select/deselect tags as desired
+   - Press Enter to apply
+
+5. **Verify**:
+   - Open the note again
+   - Should see frontmatter at the top:
+   ```yaml
+   ---
+   tags: [bug, authentication, jwt, problem-solving]
+   tagged-at: 2025-11-08T...
+   ---
+   ```
+
+### Test 2: Right-Click Context Menu
+
+1. **In the Noted sidebar**, right-click any note
+2. **Look for**: "Generate Tags with AI" (sparkle icon ✨)
+3. **Click it** - same behavior as Test 1
+4. **Also try**: "Manage Note Tags" to manually edit tags
+
+### Test 3: Batch Tag Multiple Notes
+
+1. **Open Command Palette**
+2. **Run**: `Noted: Batch Generate Tags`
+3. **Choose option**:
+   - "Tag only untagged notes" (recommended for testing)
+   - OR "Re-tag all notes"
+4. **Confirm** the action
+5. **Watch progress**: Shows "Tagging notes... (1/10)" etc.
+6. **Review results**: Shows summary of how many notes were tagged
+
+### Test 4: Auto-Tag on Creation (Advanced)
+
+1. **Enable the setting**:
+   - Open Settings (`Cmd+,`)
+   - Search for: `noted.tagging.autoTagOnCreate`
+   - Check the box to enable
+
+2. **Create a new note**:
+   - Run: `Noted: Open Today's Note`
+   - OR: `Noted: Open with Template`
+
+3. **Write some content** (at least 50 characters):
+   ```
+   Meeting with the frontend team about the new React dashboard.
+   Discussed performance optimizations and state management.
+   ```
+
+4. **Wait 2 seconds**
+
+5. **Expected behavior**:
+   - Notification appears: "Auto-tagged note with: meeting, react, frontend"
+   - Click "View Tags" to review
+   - Tags are already in frontmatter
+
+### Test 5: Tag Statistics
+
+1. **After tagging some notes**, run: `Noted: Show Tag Statistics`
+
+2. **See summary** with:
+   - Total tags
+   - Tagged/untagged notes
+   - Top 5 tags
+   - AI vs manual count
+
+3. **Click "View Details"** to see beautiful dashboard:
+   - Stat cards
+   - Most used tags list
+   - Progress bars
+   - Recent activity
+
+### Test 6: Manage Tags Manually
+
+1. **Open a note** that has tags
+2. **Run**: `Noted: Manage Note Tags`
+3. **See**:
+   - Existing tags (pre-selected with checkmarks)
+   - AI-suggested tags (unchecked)
+4. **Toggle selections** as desired
+5. **Press Enter** to update
+
+### Test 7: Add Custom Tag
+
+1. **Open a note**
+2. **Run**: `Noted: Add Custom Tag`
+3. **Enter tag name**: e.g., `urgent` or `follow-up`
+4. **Validation**: Only allows lowercase, hyphens, numbers
+5. **Tag is added** to the note
+
+## Expected Tag Suggestions
+
+Based on content, you should see tags like:
+
+**For bug/problem notes:**
+- `bug`, `problem-solving`, `debugging`, `troubleshooting`
+- Technology tags: `typescript`, `javascript`, `react`, `node`
+- Specific issues: `authentication`, `api`, `database`
+
+**For meeting notes:**
+- `meeting`, `discussion`, `planning`
+- Teams: `frontend`, `backend`, `design`
+- Topics: `architecture`, `performance`, `ui-ux`
+
+**For research notes:**
+- `research`, `learning`, `documentation`
+- Technologies being researched
+- Topics: `security`, `optimization`, `deployment`
+
+## Configuration Options to Test
+
+Open Settings and try:
+
+1. **`noted.tagging.maxTags`**: Change from 5 to 3
+   - Should only suggest 3 tags instead of 5
+
+2. **`noted.tagging.customCategories`**: Add your own categories
+   ```json
+   ["frontend-team", "backend-team", "urgent", "later"]
+   ```
+   - AI should include these in suggestions
+
+3. **`noted.tagging.excludePatterns`**: Add patterns to exclude
+   ```json
+   ["draft", "temp", "test"]
+   ```
+   - AI won't suggest these tags
+
+## Troubleshooting
+
+### "GitHub Copilot is not available"
+- **Cause**: Not signed in to Copilot
+- **Fix**: Install GitHub Copilot extension and sign in
+
+### No tags suggested
+- **Cause**: Note content too short or generic
+- **Fix**: Add more specific technical content (at least 100 chars recommended)
+
+### Tags not appearing in frontmatter
+- **Cause**: File wasn't saved
+- **Fix**: Save the file (Cmd+S) and reopen
+
+### Auto-tag not working
+- **Cause**: Setting disabled or note too short
+- **Fix**:
+  - Enable `noted.tagging.autoTagOnCreate`
+  - Write at least 50 characters
+  - Wait 2 seconds
+
+## Verifying Tag Storage
+
+Open any tagged note in a text editor - you should see:
+
+```yaml
+---
+tags: [bug, typescript, react]
+tagged-at: 2025-11-08T10:30:00.000Z
+---
+
+Your note content here...
+```
+
+The tags are:
+- ✅ Searchable using existing tag features (F2 rename, tag search, etc.)
+- ✅ Compatible with inline `#hashtags`
+- ✅ Shown in the Tags sidebar view
+- ✅ Included in tag statistics
+
+## What to Look For
+
+**Good signs:**
+- ✅ Suggested tags are relevant to content
+- ✅ Confidence scores make sense (higher for obvious tags)
+- ✅ Tags follow naming convention (lowercase, hyphenated)
+- ✅ No duplicate tags
+- ✅ Frontmatter preserves other fields
+
+**Issues to report:**
+- ❌ Irrelevant tag suggestions
+- ❌ Duplicate tags in frontmatter
+- ❌ Frontmatter corrupted
+- ❌ Performance issues (slow response)
+- ❌ Crashes or errors
+
+## Performance Notes
+
+- **Single note**: ~2-3 seconds (depends on Copilot API)
+- **Batch tagging**: ~1-2 notes per second (rate limited)
+- **Auto-tag on create**: Non-blocking, runs in background
+
+## Next Steps
+
+After testing, you can:
+1. Review tag statistics to see patterns
+2. Adjust configuration based on your needs
+3. Use tags for better note organization
+4. Search notes by tags using existing features