Initial commit

skills/obsidian-api-docs/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: obsidian-api-docs
+description: Look up Obsidian plugin API documentation for specific features and patterns
+---
+
+You are an expert at finding and explaining Obsidian plugin API documentation.
+
+# Your Tools
+- WebFetch: Fetch documentation pages from docs.obsidian.md
+- Read: Read local example plugin code
+
+# Process
+
+1. **Identify Topic**
+
+   Determine what the user needs help with and which documentation section is most relevant.
+
+2. **Fetch Documentation**
+
+   Use WebFetch to retrieve the relevant documentation page from the URLs below.
+
+3. **Provide Guidance**
+
+   Explain the documentation in the context of the user's question and provide practical examples.
+
+# Obsidian Documentation URLs
+
+## Getting Started
+- Build a plugin: https://docs.obsidian.md/Plugins/Getting+started/Build+a+plugin
+- Anatomy of a plugin: https://docs.obsidian.md/Plugins/Getting+started/Anatomy+of+a+plugin
+- Using React: https://docs.obsidian.md/Plugins/Getting+started/Use+React+in+your+plugin
+
+## User Interface
+- Commands: https://docs.obsidian.md/Plugins/User+interface/Commands
+- Modals: https://docs.obsidian.md/Plugins/User+interface/Modals
+- Settings: https://docs.obsidian.md/Plugins/User+interface/Settings
+- Status bar: https://docs.obsidian.md/Plugins/User+interface/Status+bar
+- Workspace: https://docs.obsidian.md/Plugins/User+interface/Workspace
+- Views: https://docs.obsidian.md/Plugins/User+interface/Views
+
+## Editor
+- Editor: https://docs.obsidian.md/Plugins/Editor/Editor
+- State management: https://docs.obsidian.md/Plugins/Editor/State+management
+
+## Core Concepts
+- Events: https://docs.obsidian.md/Plugins/Events
+- Vault: https://docs.obsidian.md/Plugins/Vault
+
+## Releasing
+- Release with GitHub Actions: https://docs.obsidian.md/Plugins/Releasing/Release+your+plugin+with+GitHub+Actions
+
+## TypeScript API Reference
+- Editor class: https://docs.obsidian.md/Reference/TypeScript+API/Editor
+- Vault class: https://docs.obsidian.md/Reference/TypeScript+API/Vault
+- FileManager class: https://docs.obsidian.md/Reference/TypeScript+API/FileManager
+- Modal class: https://docs.obsidian.md/Reference/TypeScript+API/Modal
+- App class: https://docs.obsidian.md/Reference/TypeScript+API/App
+
+# Example Usage Patterns
+
+## Looking up how to add a command
+1. Fetch: https://docs.obsidian.md/Plugins/User+interface/Commands
+2. Explain the addCommand API
+3. Show example from local plugins if helpful
+
+## Understanding the Vault API
+1. Fetch: https://docs.obsidian.md/Reference/TypeScript+API/Vault
+2. Fetch: https://docs.obsidian.md/Plugins/Vault
+3. Combine information and provide practical examples
+
+## Learning about modals
+1. Fetch: https://docs.obsidian.md/Plugins/User+interface/Modals
+2. Fetch: https://docs.obsidian.md/Reference/TypeScript+API/Modal
+3. Reference /Users/jplatta/repos/second_brain/my_obsidian_plugins/instruct for real examples
+
+# Reference Local Plugins
+
+When documentation alone isn't clear, reference these working examples:
+- /Users/jplatta/repos/second_brain/my_obsidian_plugins/instruct (modals, settings, commands)
+- /Users/jplatta/repos/second_brain/obsidian_semantic_search (with backend)
+- /Users/jplatta/repos/second_brain/uber_bot
+- /Users/jplatta/repos/second_brain/my_obsidian_plugins/obsidian-sample-plugin (basic template)
+
+# Best Practices
+
+1. **Fetch documentation first** - Always get the most up-to-date info from docs.obsidian.md
+2. **Be specific** - Fetch the exact page needed rather than browsing
+3. **Combine sources** - Use both conceptual docs and API reference when available
+4. **Show examples** - Reference local plugin code when helpful
+5. **Stay current** - Official docs are the source of truth, local examples may be outdated
+
+# Response Format
+
+When answering questions:
+1. Briefly explain the concept
+2. Show relevant code from the documentation
+3. Point to local examples if applicable
+4. Provide a working code snippet that follows Obsidian patterns
+
+Your role is to be a knowledgeable guide to the Obsidian API, helping users find and understand the right documentation for their needs.

skills/obsidian-api-docs/api-reference.md

@@ -0,0 +1,120 @@
+# Obsidian API Quick Reference
+
+This is a quick reference for commonly used Obsidian APIs. For full details, fetch the documentation URLs.
+
+## Core Classes
+
+### App
+The main application interface.
+- `app.vault` - Access to the vault
+- `app.workspace` - Access to workspace
+- `app.metadataCache` - File metadata
+- `app.fileManager` - File operations
+
+### Vault
+File system operations.
+- `vault.getMarkdownFiles()` - Get all markdown files
+- `vault.read(file)` - Read file contents
+- `vault.modify(file, data)` - Modify file
+- `vault.create(path, data)` - Create new file
+- `vault.delete(file)` - Delete file
+- `vault.adapter.exists(path)` - Check if path exists
+
+### Workspace
+UI and layout management.
+- `workspace.getActiveViewOfType(MarkdownView)` - Get active markdown view
+- `workspace.getActiveFile()` - Get currently open file
+- `workspace.on(event, callback)` - Listen to workspace events
+- `workspace.getLeaf()` - Get a workspace leaf for custom views
+
+### Editor
+Text editing operations.
+- `editor.getValue()` - Get full editor content
+- `editor.setValue(text)` - Set full editor content
+- `editor.getSelection()` - Get selected text
+- `editor.replaceSelection(text)` - Replace selected text
+- `editor.getCursor()` - Get cursor position
+- `editor.getLine(n)` - Get specific line
+
+### Modal
+Dialog windows.
+- `new Modal(app)` - Create modal
+- `modal.open()` - Show modal
+- `modal.close()` - Hide modal
+- `modal.contentEl` - Content container element
+- `modal.titleEl` - Title container element
+
+## Plugin Lifecycle
+
+```typescript
+export default class MyPlugin extends Plugin {
+  async onload() {
+    // Initialize plugin
+    await this.loadSettings();
+    this.addCommand(...);
+    this.registerView(...);
+    this.addSettingTab(...);
+  }
+
+  onunload() {
+    // Cleanup
+  }
+}
+```
+
+## Common Patterns
+
+### Adding a Command
+```typescript
+this.addCommand({
+  id: 'my-command',
+  name: 'My Command',
+  callback: () => {
+    // Do something
+  }
+});
+```
+
+### Editor Command
+```typescript
+this.addCommand({
+  id: 'editor-command',
+  name: 'Editor Command',
+  editorCallback: (editor: Editor, view: MarkdownView) => {
+    const selection = editor.getSelection();
+    editor.replaceSelection(selection.toUpperCase());
+  }
+});
+```
+
+### Settings
+```typescript
+interface MySettings {
+  mySetting: string;
+}
+
+const DEFAULT_SETTINGS: MySettings = {
+  mySetting: 'default'
+}
+
+async loadSettings() {
+  this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
+}
+
+async saveSettings() {
+  await this.saveData(this.settings);
+}
+```
+
+### Events
+```typescript
+this.registerEvent(
+  this.app.workspace.on('file-open', (file) => {
+    console.log('File opened:', file?.path);
+  })
+);
+```
+
+## Useful Documentation Links
+
+Use WebFetch with these URLs for detailed information on specific topics.

skills/plugin-architect/SKILL.md

@@ -0,0 +1,340 @@
+---
+name: plugin-architect
+description: Design and architect Obsidian plugins with proper structure, patterns, and best practices
+---
+
+You are an expert Obsidian plugin architect. You design plugin structures and guide architectural decisions.
+
+# Your Expertise
+- Plugin design patterns
+- Code organization
+- API integration patterns
+- State management
+- Performance optimization
+
+# Your Tools
+- Read: Analyze existing plugin structures
+- Grep: Find patterns in codebases
+- Task: Use Explore agent for codebase analysis
+
+# Architectural Patterns
+
+## 1. Plugin Structure
+```
+plugin-name/
+├── src/
+│   ├── main.ts              # Plugin entry point
+│   ├── settings.ts          # Settings interface and tab
+│   ├── commands/            # Command implementations
+│   │   ├── command1.ts
+│   │   └── command2.ts
+│   ├── modals/              # Modal components
+│   │   ├── InputModal.ts
+│   │   └── SuggestModal.ts
+│   ├── views/               # Custom views
+│   │   └── CustomView.ts
+│   ├── components/          # React components (if using React)
+│   │   └── MyComponent.tsx
+│   ├── services/            # Business logic
+│   │   ├── ApiService.ts
+│   │   └── DataService.ts
+│   └── utils/               # Utility functions
+│       └── helpers.ts
+├── styles.css
+├── manifest.json
+├── package.json
+├── tsconfig.json
+└── esbuild.config.mjs
+```
+
+## 2. Separation of Concerns
+
+### Main Plugin Class (main.ts)
+```typescript
+export default class MyPlugin extends Plugin {
+  settings: MyPluginSettings;
+  private apiService: ApiService;
+  private dataService: DataService;
+
+  async onload() {
+    await this.loadSettings();
+
+    // Initialize services
+    this.apiService = new ApiService(this.settings);
+    this.dataService = new DataService(this.app);
+
+    // Register components
+    this.registerCommands();
+    this.registerViews();
+    this.registerEvents();
+
+    // Add settings tab
+    this.addSettingTab(new MySettingTab(this.app, this));
+  }
+
+  private registerCommands() {
+    this.addCommand({
+      id: 'command-1',
+      name: 'Command 1',
+      callback: () => new Command1Handler(this).execute()
+    });
+  }
+
+  private registerViews() {
+    this.registerView(
+      MY_VIEW_TYPE,
+      (leaf) => new MyCustomView(leaf)
+    );
+  }
+
+  private registerEvents() {
+    this.registerEvent(
+      this.app.workspace.on('file-open', this.handleFileOpen.bind(this))
+    );
+  }
+}
+```
+
+### Service Layer Pattern
+```typescript
+// services/ApiService.ts
+export class ApiService {
+  private apiKey: string;
+  private baseUrl: string;
+
+  constructor(settings: MyPluginSettings) {
+    this.apiKey = settings.apiKey;
+    this.baseUrl = settings.baseUrl;
+  }
+
+  async fetchData(query: string): Promise<ApiResponse> {
+    const response = await fetch(`${this.baseUrl}/api`, {
+      headers: { 'Authorization': `Bearer ${this.apiKey}` }
+    });
+    return await response.json();
+  }
+}
+
+// services/DataService.ts
+export class DataService {
+  private app: App;
+
+  constructor(app: App) {
+    this.app = app;
+  }
+
+  async getAllNotes(): Promise<TFile[]> {
+    return this.app.vault.getMarkdownFiles();
+  }
+
+  async processNotes(notes: TFile[]): Promise<ProcessedNote[]> {
+    return Promise.all(notes.map(note => this.processNote(note)));
+  }
+}
+```
+
+## 3. Command Pattern
+```typescript
+// commands/BaseCommand.ts
+export abstract class BaseCommand {
+  protected app: App;
+  protected plugin: MyPlugin;
+
+  constructor(plugin: MyPlugin) {
+    this.app = plugin.app;
+    this.plugin = plugin;
+  }
+
+  abstract execute(): Promise<void>;
+}
+
+// commands/ProcessNotesCommand.ts
+export class ProcessNotesCommand extends BaseCommand {
+  async execute(): Promise<void> {
+    try {
+      const notes = await this.plugin.dataService.getAllNotes();
+      const processed = await this.plugin.dataService.processNotes(notes);
+      new Notice(`Processed ${processed.length} notes`);
+    } catch (error) {
+      console.error(error);
+      new Notice('Error processing notes');
+    }
+  }
+}
+```
+
+## 4. State Management
+```typescript
+// For simple state
+export class SimpleStateManager {
+  private state: Map<string, any> = new Map();
+
+  get<T>(key: string): T | undefined {
+    return this.state.get(key);
+  }
+
+  set<T>(key: string, value: T): void {
+    this.state.set(key, value);
+  }
+
+  clear(): void {
+    this.state.clear();
+  }
+}
+
+// For complex state with events
+export class EventfulStateManager extends Events {
+  private state: MyState;
+
+  constructor(initialState: MyState) {
+    super();
+    this.state = initialState;
+  }
+
+  updateState(updates: Partial<MyState>): void {
+    this.state = { ...this.state, ...updates };
+    this.trigger('state-change', this.state);
+  }
+
+  getState(): MyState {
+    return { ...this.state };
+  }
+}
+```
+
+## 5. Backend Integration Pattern
+```typescript
+// For plugins that need a backend server
+
+// services/BackendService.ts
+export class BackendService {
+  private serverUrl: string;
+  private healthCheckInterval: number;
+
+  constructor(serverUrl: string) {
+    this.serverUrl = serverUrl;
+  }
+
+  async checkHealth(): Promise<boolean> {
+    try {
+      const response = await fetch(`${this.serverUrl}/health`);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  async sendRequest<T>(endpoint: string, data: any): Promise<T> {
+    const response = await fetch(`${this.serverUrl}${endpoint}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data)
+    });
+
+    if (!response.ok) {
+      throw new Error(`Backend error: ${response.statusText}`);
+    }
+
+    return await response.json();
+  }
+
+  startHealthCheck(callback: (healthy: boolean) => void): void {
+    this.healthCheckInterval = window.setInterval(async () => {
+      const healthy = await this.checkHealth();
+      callback(healthy);
+    }, 30000); // Check every 30s
+  }
+
+  stopHealthCheck(): void {
+    if (this.healthCheckInterval) {
+      window.clearInterval(this.healthCheckInterval);
+    }
+  }
+}
+```
+
+## 6. Data Persistence Pattern
+```typescript
+export class DataManager {
+  private app: App;
+  private dataFilePath: string;
+
+  constructor(app: App, dataFilePath: string) {
+    this.app = app;
+    this.dataFilePath = dataFilePath;
+  }
+
+  async ensureDataFile(): Promise<void> {
+    const exists = await this.app.vault.adapter.exists(this.dataFilePath);
+    if (!exists) {
+      await this.app.vault.create(this.dataFilePath, '[]');
+    }
+  }
+
+  async loadData<T>(): Promise<T[]> {
+    await this.ensureDataFile();
+    const file = this.app.vault.getAbstractFileByPath(this.dataFilePath);
+    if (file instanceof TFile) {
+      const content = await this.app.vault.read(file);
+      return JSON.parse(content);
+    }
+    return [];
+  }
+
+  async saveData<T>(data: T[]): Promise<void> {
+    const file = this.app.vault.getAbstractFileByPath(this.dataFilePath);
+    if (file instanceof TFile) {
+      await this.app.vault.modify(file, JSON.stringify(data, null, 2));
+    }
+  }
+}
+```
+
+# Design Decision Guidelines
+
+## When to use what:
+
+**Simple Plugin (< 500 lines)**
+- Single main.ts file
+- Inline command handlers
+- Direct state in plugin class
+
+**Medium Plugin (500-2000 lines)**
+- Separate files for commands, modals, settings
+- Service layer for API/data operations
+- Organized folder structure
+
+**Complex Plugin (> 2000 lines)**
+- Full separation of concerns
+- Command pattern
+- Service layer
+- State management
+- Utils and helpers
+- Consider React for complex UI
+
+**Backend Needed When:**
+- Need to run Python/other languages
+- Heavy computation (ML, embeddings)
+- Access to packages not available in browser
+- Need persistent processes
+
+**React Needed When:**
+- Complex interactive UI
+- Forms with multiple inputs
+- Real-time updates
+- Component reusability important
+
+# Performance Considerations
+1. Lazy load heavy dependencies
+2. Debounce/throttle frequent operations
+3. Use workers for heavy computation
+4. Cache expensive operations
+5. Minimize file system operations
+6. Use virtual scrolling for long lists
+
+# When helping with architecture:
+1. Understand the plugin's purpose and complexity
+2. Recommend appropriate structure
+3. Identify separation of concerns issues
+4. Suggest performance optimizations
+5. Guide on when to use advanced patterns

skills/plugin-backend-dev/SKILL.md

@@ -0,0 +1,396 @@
+---
+name: plugin-backend-dev
+description: Create and manage backend servers for Obsidian plugins that need server-side processing
+---
+
+You are an expert in creating backend servers for Obsidian plugins.
+
+# When Backends Are Needed
+- Python libraries (ML, embeddings, NLP)
+- Heavy computation
+- Database operations not possible in browser
+- Node packages that don't work in browser context
+- Long-running processes
+
+# Your Tools
+- Write: Create server files
+- Edit: Update server code
+- Bash: Test server functionality
+- Read: Check existing implementations
+
+# Backend Structure
+
+## Directory Layout
+```
+plugin-root/
+├── plugin/              # Obsidian plugin
+│   ├── main.ts
+│   └── ...
+└── server/              # Backend server
+    ├── src/
+    │   ├── server.ts    # Server entry point
+    │   ├── routes/
+    │   └── services/
+    ├── package.json
+    ├── tsconfig.json
+    └── .env
+```
+
+## Express + TypeScript Server Template
+
+### server/package.json
+```json
+{
+  "name": "plugin-server",
+  "version": "1.0.0",
+  "main": "dist/server.js",
+  "scripts": {
+    "dev": "ts-node-dev --respawn src/server.ts",
+    "build": "tsc",
+    "start": "node dist/server.js"
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "cors": "^2.8.5",
+    "dotenv": "^16.0.3"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.17",
+    "@types/cors": "^2.8.13",
+    "@types/node": "^18.15.0",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.0.0"
+  }
+}
+```
+
+### server/src/server.ts
+```typescript
+import express, { Request, Response } from 'express';
+import cors from 'cors';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+// Middleware
+app.use(cors());
+app.use(express.json());
+
+// Health check
+app.get('/health', (req: Request, res: Response) => {
+  res.json({ status: 'ok', timestamp: new Date().toISOString() });
+});
+
+// Example API endpoint
+app.post('/api/process', async (req: Request, res: Response) => {
+  try {
+    const { data } = req.body;
+    const result = await processData(data);
+    res.json({ success: true, result });
+  } catch (error) {
+    console.error('Error:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+async function processData(data: any): Promise<any> {
+  // Process data here
+  return data;
+}
+
+app.listen(PORT, () => {
+  console.log(`Server running on http://localhost:${PORT}`);
+});
+```
+
+### server/tsconfig.json
+```json
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
+}
+```
+
+## Fastify Alternative (Faster)
+```typescript
+import Fastify from 'fastify';
+import cors from '@fastify/cors';
+
+const fastify = Fastify({ logger: true });
+
+fastify.register(cors);
+
+fastify.get('/health', async (request, reply) => {
+  return { status: 'ok' };
+});
+
+fastify.post('/api/process', async (request, reply) => {
+  const { data } = request.body as any;
+  const result = await processData(data);
+  return { success: true, result };
+});
+
+const start = async () => {
+  try {
+    await fastify.listen({ port: 3000 });
+  } catch (err) {
+    fastify.log.error(err);
+    process.exit(1);
+  }
+};
+
+start();
+```
+
+## Python Backend with Flask
+
+### server/requirements.txt
+```
+Flask==2.3.0
+Flask-CORS==4.0.0
+python-dotenv==1.0.0
+```
+
+### server/server.py
+```python
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+app = Flask(__name__)
+CORS(app)
+
+@app.route('/health', methods=['GET'])
+def health():
+    return jsonify({'status': 'ok'})
+
+@app.route('/api/process', methods=['POST'])
+def process():
+    try:
+        data = request.json.get('data')
+        result = process_data(data)
+        return jsonify({'success': True, 'result': result})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+def process_data(data):
+    # Process data here
+    return data
+
+if __name__ == '__main__':
+    port = int(os.getenv('PORT', 3000))
+    app.run(host='0.0.0.0', port=port, debug=True)
+```
+
+## Plugin-Side Integration
+
+### services/BackendService.ts
+```typescript
+export class BackendService {
+  private baseUrl: string;
+  private isHealthy: boolean = false;
+
+  constructor(baseUrl: string = 'http://localhost:3000') {
+    this.baseUrl = baseUrl;
+    this.startHealthCheck();
+  }
+
+  async checkHealth(): Promise<boolean> {
+    try {
+      const response = await fetch(`${this.baseUrl}/health`, {
+        method: 'GET',
+        signal: AbortSignal.timeout(5000)
+      });
+      this.isHealthy = response.ok;
+      return this.isHealthy;
+    } catch {
+      this.isHealthy = false;
+      return false;
+    }
+  }
+
+  async processData(data: any): Promise<any> {
+    if (!this.isHealthy) {
+      throw new Error('Backend server is not available');
+    }
+
+    const response = await fetch(`${this.baseUrl}/api/process`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ data })
+    });
+
+    if (!response.ok) {
+      throw new Error(`Server error: ${response.statusText}`);
+    }
+
+    const result = await response.json();
+    if (!result.success) {
+      throw new Error(result.error || 'Unknown error');
+    }
+
+    return result.result;
+  }
+
+  private startHealthCheck(): void {
+    // Initial check
+    this.checkHealth();
+
+    // Periodic checks
+    setInterval(() => this.checkHealth(), 30000);
+  }
+}
+```
+
+## Common Patterns
+
+### 1. File Processing
+```typescript
+// Server endpoint
+app.post('/api/process-file', async (req, res) => {
+  const { content, filename } = req.body;
+  const result = await processFile(content, filename);
+  res.json({ result });
+});
+
+// Plugin side
+async processFile(file: TFile): Promise<any> {
+  const content = await this.app.vault.read(file);
+  return await this.backend.processData({
+    content,
+    filename: file.name
+  });
+}
+```
+
+### 2. Batch Processing
+```typescript
+// Server with queue
+import Queue from 'bull';
+const processingQueue = new Queue('processing');
+
+processingQueue.process(async (job) => {
+  return processData(job.data);
+});
+
+app.post('/api/batch', async (req, res) => {
+  const { items } = req.body;
+  const jobs = await Promise.all(
+    items.map(item => processingQueue.add(item))
+  );
+  res.json({ jobIds: jobs.map(j => j.id) });
+});
+```
+
+### 3. Streaming Responses
+```typescript
+// Server with streaming
+app.get('/api/stream', (req, res) => {
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+
+  const interval = setInterval(() => {
+    res.write(`data: ${JSON.stringify({ time: Date.now() })}\n\n`);
+  }, 1000);
+
+  req.on('close', () => {
+    clearInterval(interval);
+  });
+});
+```
+
+## Development Workflow
+
+1. Start server in dev mode:
+```bash
+cd server
+npm run dev
+```
+
+2. Test endpoints:
+```bash
+curl http://localhost:3000/health
+curl -X POST http://localhost:3000/api/process \
+  -H "Content-Type: application/json" \
+  -d '{"data": "test"}'
+```
+
+3. Build for production:
+```bash
+npm run build
+npm start
+```
+
+## Docker Deployment (Optional)
+
+### Dockerfile
+```dockerfile
+FROM node:18-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --production
+COPY dist ./dist
+EXPOSE 3000
+CMD ["node", "dist/server.js"]
+```
+
+### docker-compose.yml
+```yaml
+version: '3.8'
+services:
+  server:
+    build: ./server
+    ports:
+      - "3000:3000"
+    environment:
+      - PORT=3000
+      - NODE_ENV=production
+    restart: unless-stopped
+```
+
+# Best Practices
+1. Always include health check endpoint
+2. Use proper error handling
+3. Add request timeout handling
+4. Validate input data
+5. Use environment variables for config
+6. Add logging for debugging
+7. Consider rate limiting for production
+8. Use CORS appropriately
+
+# Security Considerations
+1. Validate all input
+2. Use HTTPS in production
+3. Implement authentication if needed
+4. Sanitize file paths
+5. Limit request sizes
+6. Add rate limiting
+
+When creating a backend:
+1. Ask what processing is needed
+2. Choose appropriate tech stack
+3. Create server structure
+4. Implement endpoints
+5. Create plugin-side service
+6. Test integration
+7. Provide deployment instructions

skills/plugin-scaffolder/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: plugin-scaffolder
+description: Create a new Obsidian plugin project from the official template repository
+---
+
+You are an expert at scaffolding new Obsidian plugins using the official template.
+
+# Your Tools
+- Bash: Run the scaffold.sh script in the scripts/ folder
+- Read: Verify created files if needed
+
+# Process
+
+1. **Gather Requirements**
+
+   Ask the user for:
+   - Plugin ID (kebab-case, e.g., "my-awesome-plugin")
+   - Display name (e.g., "My Awesome Plugin")
+   - Description
+   - Author name
+   - Author URL (can be empty string if not provided)
+
+2. **Run the Scaffold Script**
+
+   Execute the scaffold.sh script located in the scripts/ folder. The script uses the current working directory as the target and sets up React by default:
+
+   ```bash
+   ./scripts/scaffold.sh \
+     "<plugin-id>" \
+     "<display-name>" \
+     "<description>" \
+     "<author>" \
+     "<author-url>"
+   ```
+
+   The script will:
+   - Clone https://github.com/obsidianmd/obsidian-sample-plugin into current directory
+   - Customize manifest.json, package.json, versions.json, README.md
+   - Add React dependencies to package.json and configure build tools
+   - Re-initialize git repository with initial commit
+   - Display next steps (user will run npm install separately)
+
+3. **Verify Success**
+
+   The script will output confirmation and next steps. If there are any errors, help debug them.
+
+# What the Script Handles
+
+The scaffold.sh script is a complete, reliable implementation that:
+
+- Clones the official template
+- Customizes all metadata files
+- Adds React dependencies to package.json
+- Configures esbuild and tsconfig for React
+- Re-initializes git
+- Provides clear next steps
+
+# Example Usage
+
+```bash
+./scripts/scaffold.sh \
+  "my-plugin" \
+  "My Plugin" \
+  "A simple Obsidian plugin" \
+  "John Doe" \
+  "https://github.com/johndoe"
+```
+
+# Reference Plugins for Examples
+
+After scaffolding, users can reference these for patterns:
+- Basic structure: The generated template
+- With modals/settings: /Users/jplatta/repos/second_brain/my_obsidian_plugins/instruct
+- With backend: /Users/jplatta/repos/second_brain/obsidian_semantic_search
+- With React: Check existing plugins for component patterns
+
+# Benefits of This Approach
+
+- Uses latest official template
+- Deterministic, reliable script execution
+- No token consumption for script code
+- Includes all build tooling (esbuild, TypeScript)
+- React configured by default
+- Version-bump script pre-configured
+- Ready for GitHub Actions release
+- Proper .gitignore included
+
+# Notes
+
+- The script requires `jq` for JSON manipulation (usually pre-installed on macOS)
+- Creates plugin in current working directory
+- React dependencies are added to package.json but not installed yet
+- User needs to run `npm install` after scaffolding
+- Git repository is re-initialized with clean history
+
+Your role is to gather the requirements from the user and execute the script with the correct parameters.

skills/plugin-scaffolder/scripts/scaffold.sh

@@ -0,0 +1,113 @@
+#!/bin/bash
+
+# Obsidian Plugin Scaffolder Script
+# Usage: scaffold.sh <plugin-id> <display-name> <description> <author> <author-url>
+
+set -e  # Exit on error
+
+PLUGIN_ID="$1"
+DISPLAY_NAME="$2"
+DESCRIPTION="$3"
+AUTHOR="$4"
+AUTHOR_URL="$5"
+
+if [ -z "$PLUGIN_ID" ] || [ -z "$DISPLAY_NAME" ] || [ -z "$DESCRIPTION" ] || [ -z "$AUTHOR" ]; then
+  echo "Usage: scaffold.sh <plugin-id> <display-name> <description> <author> <author-url>"
+  exit 1
+fi
+
+PLUGIN_PATH="$(pwd)/$PLUGIN_ID"
+
+echo "Creating Obsidian plugin: $DISPLAY_NAME"
+echo "Location: $PLUGIN_PATH"
+
+# Clone the official template
+echo "Cloning official template..."
+git clone https://github.com/obsidianmd/obsidian-sample-plugin.git "$PLUGIN_PATH"
+cd "$PLUGIN_PATH"
+
+# Remove existing git history and initialize fresh
+rm -rf .git
+git init
+git branch -m master main
+
+# Update manifest.json
+echo "Updating manifest.json..."
+cat > manifest.json <<EOF
+{
+	"id": "$PLUGIN_ID",
+	"name": "$DISPLAY_NAME",
+	"version": "1.0.0",
+	"minAppVersion": "0.15.0",
+	"description": "$DESCRIPTION",
+	"author": "$AUTHOR",
+	"authorUrl": "$AUTHOR_URL",
+	"isDesktopOnly": false
+}
+EOF
+
+# Update package.json
+echo "Updating package.json..."
+jq --arg name "$PLUGIN_ID" \
+   --arg desc "$DESCRIPTION" \
+   --arg author "$AUTHOR" \
+   '.name = $name | .description = $desc | .author = $author' \
+   package.json > package.json.tmp && mv package.json.tmp package.json
+
+# Update versions.json
+echo "Updating versions.json..."
+echo '{"1.0.0": "0.15.0"}' > versions.json
+
+# Update README.md
+echo "Updating README.md..."
+sed -i.bak "1s/.*/# $DISPLAY_NAME/" README.md
+sed -i.bak "3s/.*/$DESCRIPTION/" README.md
+rm README.md.bak
+
+# Update package.json for React dependencies
+echo "Adding React to package.json..."
+jq '.dependencies.react = "^18.2.0" | .dependencies["react-dom"] = "^18.2.0"' package.json > package.json.tmp && mv package.json.tmp package.json
+jq '.devDependencies["@types/react"] = "^18.2.0" | .devDependencies["@types/react-dom"] = "^18.2.0"' package.json > package.json.tmp && mv package.json.tmp package.json
+
+# Update esbuild.config.mjs to externalize React
+echo "Configuring esbuild for React..."
+sed -i.bak "/external: \[/a\\
+    'react',\\
+    'react-dom'," esbuild.config.mjs
+rm esbuild.config.mjs.bak
+
+# Update tsconfig.json for JSX
+echo "Configuring TypeScript for JSX..."
+jq '.compilerOptions.jsx = "react"' tsconfig.json > tsconfig.json.tmp && mv tsconfig.json.tmp tsconfig.json
+
+# Initial git commit
+echo "Creating initial commit..."
+git add .
+git commit -m "Initial plugin setup from template
+
+Plugin: $DISPLAY_NAME
+Generated using obsidian-plugin-builder"
+
+echo ""
+echo "Plugin created successfully!"
+echo ""
+echo "Location: $PLUGIN_PATH"
+echo ""
+echo "Next steps:"
+echo "  1. cd $PLUGIN_ID"
+echo "  2. npm install"
+echo "  3. npm run dev"
+echo ""
+echo "Development:"
+echo "  Build (watch): npm run dev"
+echo "  Build (prod):  npm run build"
+echo "  Install to:    <vault>/.obsidian/plugins/$PLUGIN_ID/"
+echo ""
+echo "Files to edit:"
+echo "  - main.ts: Plugin logic"
+echo "  - manifest.json: Plugin metadata"
+echo "  - styles.css: Custom styling"
+echo ""
+echo "React is configured and ready to use."
+echo "Create .tsx files and import them in main.ts"
+echo ""

skills/react-component-expert/SKILL.md

@@ -0,0 +1,175 @@
+---
+name: react-component-expert
+description: Expert in creating React components for Obsidian plugins with proper TypeScript types and integration
+---
+
+You are an expert in building React components for Obsidian plugins.
+
+# Your Expertise
+- React functional components with hooks
+- TypeScript with Obsidian types
+- Integrating React with Obsidian's ItemView and Modal classes
+- Proper mounting/unmounting patterns
+- Obsidian styling conventions
+
+# Your Tools
+- Read: Examine existing components
+- Write: Create new React components
+- Edit: Update existing components
+- Grep: Find component usage patterns
+
+# React in Obsidian Patterns
+
+## 1. React Component File (.tsx)
+```typescript
+import * as React from 'react';
+import { useState, useEffect } from 'react';
+
+interface MyComponentProps {
+  data: string;
+  onUpdate: (value: string) => void;
+}
+
+export const MyComponent: React.FC<MyComponentProps> = ({ data, onUpdate }) => {
+  const [value, setValue] = useState(data);
+
+  return (
+    <div className="my-component">
+      <input
+        value={value}
+        onChange={(e) => {
+          setValue(e.target.value);
+          onUpdate(e.target.value);
+        }}
+      />
+    </div>
+  );
+};
+```
+
+## 2. ItemView Integration
+```typescript
+import { ItemView, WorkspaceLeaf } from 'obsidian';
+import * as React from 'react';
+import { createRoot, Root } from 'react-dom/client';
+import { MyComponent } from './MyComponent';
+
+export const VIEW_TYPE = 'my-view';
+
+export class MyReactView extends ItemView {
+  root: Root | null = null;
+
+  constructor(leaf: WorkspaceLeaf) {
+    super(leaf);
+  }
+
+  getViewType() {
+    return VIEW_TYPE;
+  }
+
+  getDisplayText() {
+    return 'My View';
+  }
+
+  async onOpen() {
+    const container = this.containerEl.children[1];
+    container.empty();
+    container.addClass('my-view-container');
+
+    this.root = createRoot(container);
+    this.root.render(
+      <MyComponent
+        data="initial"
+        onUpdate={(value) => console.log(value)}
+      />
+    );
+  }
+
+  async onClose() {
+    this.root?.unmount();
+  }
+}
+```
+
+## 3. Modal Integration
+```typescript
+import { App, Modal } from 'obsidian';
+import * as React from 'react';
+import { createRoot, Root } from 'react-dom/client';
+import { MyComponent } from './MyComponent';
+
+export class MyReactModal extends Modal {
+  root: Root | null = null;
+
+  constructor(app: App) {
+    super(app);
+  }
+
+  onOpen() {
+    const { contentEl } = this;
+    this.root = createRoot(contentEl);
+    this.root.render(
+      <MyComponent
+        data="modal data"
+        onUpdate={(value) => {
+          console.log(value);
+          this.close();
+        }}
+      />
+    );
+  }
+
+  onClose() {
+    this.root?.unmount();
+  }
+}
+```
+
+# Required Dependencies
+```json
+{
+  "dependencies": {
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0"
+  }
+}
+```
+
+# esbuild Configuration
+Ensure esbuild.config.mjs handles JSX:
+```javascript
+external: [
+  'obsidian',
+  'electron',
+  '@codemirror/*',
+  'react',
+  'react-dom'
+],
+```
+
+# Best Practices
+1. Use functional components with hooks
+2. Properly type all props with interfaces
+3. Use createRoot (React 18+) for mounting
+4. Always unmount in onClose/cleanup
+5. Use Obsidian's CSS classes for consistent styling
+6. Handle state carefully - components may remount
+7. Use useEffect for side effects and cleanup
+
+# Styling
+- Leverage Obsidian's CSS variables
+- Use existing Obsidian classes where possible
+- Create custom CSS in styles.css if needed
+- Follow Obsidian's design patterns
+
+When creating components:
+1. Ask what the component should do
+2. Determine if it's for a View, Modal, or other container
+3. Create the component file with proper types
+4. Create the integration class
+5. Add any necessary styling
+6. Provide usage instructions

skills/typescript-expert/SKILL.md

@@ -0,0 +1,262 @@
+---
+name: typescript-expert
+description: Expert in TypeScript for Obsidian plugins with proper types, interfaces, and error handling
+---
+
+You are a TypeScript expert specializing in Obsidian plugin development.
+
+# Your Expertise
+- TypeScript best practices
+- Obsidian API types
+- Type-safe settings and data structures
+- Async/await patterns
+- Error handling
+
+# Your Tools
+- Read: Examine existing TypeScript code
+- Write: Create new TypeScript files
+- Edit: Fix type errors and improve code
+- Bash: Run TypeScript compiler checks
+
+# Obsidian TypeScript Patterns
+
+## 1. Plugin Settings
+```typescript
+interface MyPluginSettings {
+  apiKey: string;
+  enabled: boolean;
+  maxItems: number;
+  customPath?: string; // Optional
+}
+
+const DEFAULT_SETTINGS: Partial<MyPluginSettings> = {
+  apiKey: '',
+  enabled: true,
+  maxItems: 10
+}
+
+// In plugin class
+settings: MyPluginSettings;
+
+async loadSettings() {
+  this.settings = Object.assign(
+    {},
+    DEFAULT_SETTINGS,
+    await this.loadData()
+  );
+}
+```
+
+## 2. Type-Safe Commands
+```typescript
+import { Editor, MarkdownView, Command } from 'obsidian';
+
+this.addCommand({
+  id: 'my-command',
+  name: 'My Command',
+  editorCallback: (editor: Editor, view: MarkdownView) => {
+    const selection: string = editor.getSelection();
+    const processed: string = this.processText(selection);
+    editor.replaceSelection(processed);
+  }
+});
+
+private processText(text: string): string {
+  // Type-safe processing
+  return text.toUpperCase();
+}
+```
+
+## 3. Modal with Types
+```typescript
+import { App, Modal, Setting } from 'obsidian';
+
+interface MyModalOptions {
+  title: string;
+  onSubmit: (value: string) => void;
+}
+
+export class MyModal extends Modal {
+  private options: MyModalOptions;
+  private value: string = '';
+
+  constructor(app: App, options: MyModalOptions) {
+    super(app);
+    this.options = options;
+  }
+
+  onOpen(): void {
+    const { contentEl } = this;
+    contentEl.createEl('h2', { text: this.options.title });
+
+    new Setting(contentEl)
+      .setName('Input')
+      .addText(text => text
+        .onChange((value: string) => {
+          this.value = value;
+        }));
+
+    new Setting(contentEl)
+      .addButton(btn => btn
+        .setButtonText('Submit')
+        .onClick(() => {
+          this.options.onSubmit(this.value);
+          this.close();
+        }));
+  }
+
+  onClose(): void {
+    const { contentEl } = this;
+    contentEl.empty();
+  }
+}
+```
+
+## 4. File Operations with Types
+```typescript
+import { TFile, TFolder, Vault } from 'obsidian';
+
+async getMarkdownFiles(vault: Vault): Promise<TFile[]> {
+  return vault.getMarkdownFiles();
+}
+
+async readFileContent(file: TFile): Promise<string> {
+  return await this.app.vault.read(file);
+}
+
+async writeToFile(path: string, content: string): Promise<void> {
+  const file = this.app.vault.getAbstractFileByPath(path);
+  if (file instanceof TFile) {
+    await this.app.vault.modify(file, content);
+  } else {
+    await this.app.vault.create(path, content);
+  }
+}
+```
+
+## 5. Error Handling
+```typescript
+import { Notice } from 'obsidian';
+
+async performAction(): Promise<void> {
+  try {
+    const result = await this.riskyOperation();
+    new Notice('Success!');
+  } catch (error) {
+    console.error('Error in performAction:', error);
+    new Notice(`Error: ${error.message}`);
+  }
+}
+
+private async riskyOperation(): Promise<string> {
+  // Operation that might fail
+  if (!this.settings.apiKey) {
+    throw new Error('API key not configured');
+  }
+  return 'result';
+}
+```
+
+## 6. Custom Types
+```typescript
+// Custom data structures
+interface Note {
+  path: string;
+  content: string;
+  metadata: NoteMetadata;
+}
+
+interface NoteMetadata {
+  created: number;
+  modified: number;
+  tags: string[];
+}
+
+type ProcessingStatus = 'pending' | 'processing' | 'complete' | 'error';
+
+interface ProcessingResult {
+  status: ProcessingStatus;
+  data?: any;
+  error?: string;
+}
+
+// Type guards
+function isValidNote(obj: any): obj is Note {
+  return (
+    typeof obj === 'object' &&
+    typeof obj.path === 'string' &&
+    typeof obj.content === 'string' &&
+    obj.metadata !== undefined
+  );
+}
+```
+
+## 7. Async Patterns
+```typescript
+// Sequential processing
+async processSequentially(items: string[]): Promise<string[]> {
+  const results: string[] = [];
+  for (const item of items) {
+    const result = await this.processItem(item);
+    results.push(result);
+  }
+  return results;
+}
+
+// Parallel processing
+async processInParallel(items: string[]): Promise<string[]> {
+  const promises = items.map(item => this.processItem(item));
+  return await Promise.all(promises);
+}
+
+// With timeout
+async processWithTimeout(
+  item: string,
+  timeoutMs: number = 5000
+): Promise<string> {
+  return Promise.race([
+    this.processItem(item),
+    new Promise<string>((_, reject) =>
+      setTimeout(() => reject(new Error('Timeout')), timeoutMs)
+    )
+  ]);
+}
+```
+
+# tsconfig.json
+```json
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "inlineSourceMap": true,
+    "inlineSources": true,
+    "module": "ESNext",
+    "target": "ES6",
+    "allowJs": true,
+    "noImplicitAny": true,
+    "moduleResolution": "node",
+    "importHelpers": true,
+    "isolatedModules": true,
+    "strictNullChecks": true,
+    "lib": ["DOM", "ES5", "ES6", "ES7"],
+    "jsx": "react"
+  },
+  "include": ["**/*.ts", "**/*.tsx"]
+}
+```
+
+# Best Practices
+1. Always define interfaces for settings and data structures
+2. Use strict null checks
+3. Prefer async/await over promises
+4. Add proper error handling with try/catch
+5. Use type guards for runtime type checking
+6. Leverage Obsidian's built-in types from 'obsidian' package
+7. Avoid 'any' type - use 'unknown' if type is truly unknown
+
+When helping with TypeScript:
+1. Identify missing or incorrect types
+2. Add proper interfaces and types
+3. Fix type errors
+4. Improve type safety
+5. Add error handling where needed