From 92b20d71a26eba353e5335523aeff9d940de4a02 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sat, 15 Nov 2025 03:30:49 +0000
Subject: [PATCH 1/3] Add initial scaffold for Ink AI Assistant companion app

Creates a new Electron-based companion app for AI-assisted ink development with:
- Project structure matching Inky's Electron stack
- Package.json with dependencies (Electron 30.0.4, Supabase, OpenAI client)
- Configuration system for local LLM (Ollama), Supabase vector storage, and inklecate integration
- Shared types and IPC channels for main/renderer communication
- Auto-detection of inklecate binary from Inky installation

This app will provide error detection, AI-assisted code generation, and an interactive chat interface for ink script development.
---
 ink-ai-assistant/package.json         |  51 ++++++++++++
 ink-ai-assistant/src/shared/config.js |  98 +++++++++++++++++++++++
 ink-ai-assistant/src/shared/types.js  | 110 ++++++++++++++++++++++++++
 3 files changed, 259 insertions(+)
 create mode 100644 ink-ai-assistant/package.json
 create mode 100644 ink-ai-assistant/src/shared/config.js
 create mode 100644 ink-ai-assistant/src/shared/types.js

diff --git a/ink-ai-assistant/package.json b/ink-ai-assistant/package.json
new file mode 100644
index 00000000..47b7be3b
--- /dev/null
+++ b/ink-ai-assistant/package.json
@@ -0,0 +1,51 @@
+{
+  "name": "ink-ai-assistant",
+  "version": "0.1.0",
+  "description": "AI-powered companion app for Ink script development with local LLM support",
+  "main": "src/main/main.js",
+  "scripts": {
+    "start": "electron .",
+    "dev": "electron . --dev",
+    "build": "electron-builder",
+    "build:mac": "electron-builder --mac",
+    "build:win": "electron-builder --win",
+    "build:linux": "electron-builder --linux",
+    "ingest-docs": "node src/main/ingest-documentation.js"
+  },
+  "author": "Ink AI Assistant Team",
+  "license": "MIT",
+  "dependencies": {
+    "@supabase/supabase-js": "^2.39.0",
+    "axios": "^1.6.0",
+    "chokidar": "^3.6.0",
+    "marked": "^11.0.0",
+    "openai": "^4.20.0"
+  },
+  "devDependencies": {
+    "electron": "^30.0.4",
+    "electron-builder": "^24.9.1"
+  },
+  "build": {
+    "appId": "com.inkassistant.app",
+    "productName": "Ink AI Assistant",
+    "directories": {
+      "output": "dist"
+    },
+    "files": [
+      "src/**/*",
+      "resources/**/*",
+      "package.json"
+    ],
+    "mac": {
+      "category": "public.app-category.developer-tools",
+      "icon": "resources/icon.icns"
+    },
+    "win": {
+      "icon": "resources/icon.ico"
+    },
+    "linux": {
+      "icon": "resources/icon.png",
+      "category": "Development"
+    }
+  }
+}
diff --git a/ink-ai-assistant/src/shared/config.js b/ink-ai-assistant/src/shared/config.js
new file mode 100644
index 00000000..d060cef8
--- /dev/null
+++ b/ink-ai-assistant/src/shared/config.js
@@ -0,0 +1,98 @@
+/**
+ * Configuration for Ink AI Assistant
+ * Modify these values to match your setup
+ */
+
+module.exports = {
+  // Local LLM configuration (OpenAI-compatible API)
+  llm: {
+    // Default to Ollama endpoint
+    baseURL: process.env.LLM_BASE_URL || 'http://localhost:11434/v1',
+    apiKey: process.env.LLM_API_KEY || 'ollama', // Ollama doesn't need real key
+    model: process.env.LLM_MODEL || 'llama3.1', // or 'codellama', 'mistral', etc.
+    temperature: 0.2, // Lower for more consistent code generation
+    maxTokens: 4000,
+  },
+
+  // Supabase configuration for vector storage
+  supabase: {
+    url: process.env.SUPABASE_URL || '',
+    anonKey: process.env.SUPABASE_ANON_KEY || '',
+    tableName: 'ink_documentation',
+    matchThreshold: 0.78, // Similarity threshold for vector search
+    matchCount: 5, // Number of relevant docs to retrieve
+  },
+
+  // Inklecate compiler configuration
+  inklecate: {
+    // Auto-detect platform
+    binary: getInklecatePath(),
+    timeout: 10000, // 10 seconds
+  },
+
+  // File watching configuration
+  fileWatcher: {
+    ignored: /(^|[\/\\])\../, // Ignore dotfiles
+    persistent: true,
+    ignoreInitial: false,
+    awaitWriteFinish: {
+      stabilityThreshold: 500,
+      pollInterval: 100,
+    },
+  },
+
+  // UI configuration
+  ui: {
+    theme: 'dark',
+    width: 900,
+    height: 700,
+    minWidth: 600,
+    minHeight: 400,
+  },
+};
+
+/**
+ * Get platform-specific inklecate binary path
+ * Tries to use Inky's bundled version first
+ */
+function getInklecatePath() {
+  const path = require('path');
+  const os = require('os');
+  const fs = require('fs');
+
+  const platform = os.platform();
+  let binaryName;
+
+  if (platform === 'darwin') {
+    binaryName = 'inklecate_mac';
+  } else if (platform === 'win32') {
+    binaryName = 'inklecate_win.exe';
+  } else if (platform === 'linux') {
+    binaryName = 'inklecate_linux';
+  } else {
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+
+  // Try to find Inky's bundled inklecate
+  const possiblePaths = [
+    // Same repo (if we're in the inky_digi folder)
+    path.join(__dirname, '../../../app/main-process/ink', binaryName),
+    // User might have inklecate in PATH
+    binaryName,
+    // Custom path from environment
+    process.env.INKLECATE_PATH,
+  ].filter(Boolean);
+
+  for (const binPath of possiblePaths) {
+    try {
+      if (fs.existsSync(binPath)) {
+        return binPath;
+      }
+    } catch (e) {
+      // Continue checking
+    }
+  }
+
+  // Fallback to expecting it in PATH
+  return binaryName;
+}
diff --git a/ink-ai-assistant/src/shared/types.js b/ink-ai-assistant/src/shared/types.js
new file mode 100644
index 00000000..4bb11c7a
--- /dev/null
+++ b/ink-ai-assistant/src/shared/types.js
@@ -0,0 +1,110 @@
+/**
+ * Shared types and constants for Ink AI Assistant
+ */
+
+// IPC channels for main <-> renderer communication
+const IPC_CHANNELS = {
+  // File operations
+  OPEN_FILE: 'open-file',
+  FILE_OPENED: 'file-opened',
+  FILE_CHANGED: 'file-changed',
+  SAVE_FILE: 'save-file',
+
+  // Compilation
+  COMPILE: 'compile',
+  COMPILE_RESULT: 'compile-result',
+  COMPILE_ERROR: 'compile-error',
+
+  // AI operations
+  SEND_MESSAGE: 'send-message',
+  AI_RESPONSE: 'ai-response',
+  AI_ERROR: 'ai-error',
+  AI_STREAMING: 'ai-streaming',
+
+  // Code generation
+  GENERATE_CODE: 'generate-code',
+  FIX_ERROR: 'fix-error',
+  EXPLAIN_CODE: 'explain-code',
+
+  // Configuration
+  GET_CONFIG: 'get-config',
+  SET_CONFIG: 'set-config',
+  CONFIG_UPDATED: 'config-updated',
+
+  // Documentation search
+  SEARCH_DOCS: 'search-docs',
+  DOCS_RESULT: 'docs-result',
+};
+
+// Error types from inklecate
+const ERROR_TYPES = {
+  ERROR: 'ERROR',
+  WARNING: 'WARNING',
+  TODO: 'TODO',
+  AUTHOR: 'AUTHOR',
+};
+
+// Message roles for chat
+const MESSAGE_ROLES = {
+  USER: 'user',
+  ASSISTANT: 'assistant',
+  SYSTEM: 'system',
+};
+
+// AI operation types
+const AI_OPERATIONS = {
+  CHAT: 'chat',
+  GENERATE: 'generate',
+  FIX: 'fix',
+  EXPLAIN: 'explain',
+  REFACTOR: 'refactor',
+};
+
+/**
+ * @typedef {Object} InkError
+ * @property {string} type - ERROR, WARNING, TODO, or AUTHOR
+ * @property {string} message - Error message
+ * @property {string} filename - File where error occurred
+ * @property {number} line - Line number (1-indexed)
+ * @property {number} column - Column number (1-indexed)
+ * @property {string} context - Surrounding code context
+ */
+
+/**
+ * @typedef {Object} CompilationResult
+ * @property {boolean} success - Whether compilation succeeded
+ * @property {InkError[]} errors - Array of errors/warnings
+ * @property {string} [output] - JSON output if successful
+ * @property {number} duration - Compilation time in ms
+ */
+
+/**
+ * @typedef {Object} ChatMessage
+ * @property {string} role - user, assistant, or system
+ * @property {string} content - Message content
+ * @property {number} timestamp - Unix timestamp
+ * @property {Object} [metadata] - Additional metadata
+ */
+
+/**
+ * @typedef {Object} DocumentChunk
+ * @property {string} content - Documentation content
+ * @property {Object} metadata - Metadata (section, title, etc.)
+ * @property {number} similarity - Similarity score (0-1)
+ */
+
+/**
+ * @typedef {Object} AIRequest
+ * @property {string} operation - Type of AI operation
+ * @property {string} prompt - User prompt
+ * @property {string} [code] - Current code context
+ * @property {InkError[]} [errors] - Errors to fix
+ * @property {DocumentChunk[]} [context] - Retrieved documentation
+ */
+
+module.exports = {
+  IPC_CHANNELS,
+  ERROR_TYPES,
+  MESSAGE_ROLES,
+  AI_OPERATIONS,
+};

From 598d196de29f809fa72a862a91a304ec40b66fb2 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sat, 15 Nov 2025 04:17:35 +0000
Subject: [PATCH 2/3] Remove ink-ai-assistant - moving to separate repository

---
 ink-ai-assistant/package.json         |  51 ------------
 ink-ai-assistant/src/shared/config.js |  98 -----------------------
 ink-ai-assistant/src/shared/types.js  | 110 --------------------------
 3 files changed, 259 deletions(-)
 delete mode 100644 ink-ai-assistant/package.json
 delete mode 100644 ink-ai-assistant/src/shared/config.js
 delete mode 100644 ink-ai-assistant/src/shared/types.js

diff --git a/ink-ai-assistant/package.json b/ink-ai-assistant/package.json
deleted file mode 100644
index 47b7be3b..00000000
--- a/ink-ai-assistant/package.json
+++ /dev/null
@@ -1,51 +0,0 @@
-{
-  "name": "ink-ai-assistant",
-  "version": "0.1.0",
-  "description": "AI-powered companion app for Ink script development with local LLM support",
-  "main": "src/main/main.js",
-  "scripts": {
-    "start": "electron .",
-    "dev": "electron . --dev",
-    "build": "electron-builder",
-    "build:mac": "electron-builder --mac",
-    "build:win": "electron-builder --win",
-    "build:linux": "electron-builder --linux",
-    "ingest-docs": "node src/main/ingest-documentation.js"
-  },
-  "author": "Ink AI Assistant Team",
-  "license": "MIT",
-  "dependencies": {
-    "@supabase/supabase-js": "^2.39.0",
-    "axios": "^1.6.0",
-    "chokidar": "^3.6.0",
-    "marked": "^11.0.0",
-    "openai": "^4.20.0"
-  },
-  "devDependencies": {
-    "electron": "^30.0.4",
-    "electron-builder": "^24.9.1"
-  },
-  "build": {
-    "appId": "com.inkassistant.app",
-    "productName": "Ink AI Assistant",
-    "directories": {
-      "output": "dist"
-    },
-    "files": [
-      "src/**/*",
-      "resources/**/*",
-      "package.json"
-    ],
-    "mac": {
-      "category": "public.app-category.developer-tools",
-      "icon": "resources/icon.icns"
-    },
-    "win": {
-      "icon": "resources/icon.ico"
-    },
-    "linux": {
-      "icon": "resources/icon.png",
-      "category": "Development"
-    }
-  }
-}
diff --git a/ink-ai-assistant/src/shared/config.js b/ink-ai-assistant/src/shared/config.js
deleted file mode 100644
index d060cef8..00000000
--- a/ink-ai-assistant/src/shared/config.js
+++ /dev/null
@@ -1,98 +0,0 @@
-/**
- * Configuration for Ink AI Assistant
- * Modify these values to match your setup
- */
-
-module.exports = {
-  // Local LLM configuration (OpenAI-compatible API)
-  llm: {
-    // Default to Ollama endpoint
-    baseURL: process.env.LLM_BASE_URL || 'http://localhost:11434/v1',
-    apiKey: process.env.LLM_API_KEY || 'ollama', // Ollama doesn't need real key
-    model: process.env.LLM_MODEL || 'llama3.1', // or 'codellama', 'mistral', etc.
-    temperature: 0.2, // Lower for more consistent code generation
-    maxTokens: 4000,
-  },
-
-  // Supabase configuration for vector storage
-  supabase: {
-    url: process.env.SUPABASE_URL || '',
-    anonKey: process.env.SUPABASE_ANON_KEY || '',
-    tableName: 'ink_documentation',
-    matchThreshold: 0.78, // Similarity threshold for vector search
-    matchCount: 5, // Number of relevant docs to retrieve
-  },
-
-  // Inklecate compiler configuration
-  inklecate: {
-    // Auto-detect platform
-    binary: getInklecatePath(),
-    timeout: 10000, // 10 seconds
-  },
-
-  // File watching configuration
-  fileWatcher: {
-    ignored: /(^|[\/\\])\../, // Ignore dotfiles
-    persistent: true,
-    ignoreInitial: false,
-    awaitWriteFinish: {
-      stabilityThreshold: 500,
-      pollInterval: 100,
-    },
-  },
-
-  // UI configuration
-  ui: {
-    theme: 'dark',
-    width: 900,
-    height: 700,
-    minWidth: 600,
-    minHeight: 400,
-  },
-};
-
-/**
- * Get platform-specific inklecate binary path
- * Tries to use Inky's bundled version first
- */
-function getInklecatePath() {
-  const path = require('path');
-  const os = require('os');
-  const fs = require('fs');
-
-  const platform = os.platform();
-  let binaryName;
-
-  if (platform === 'darwin') {
-    binaryName = 'inklecate_mac';
-  } else if (platform === 'win32') {
-    binaryName = 'inklecate_win.exe';
-  } else if (platform === 'linux') {
-    binaryName = 'inklecate_linux';
-  } else {
-    throw new Error(`Unsupported platform: ${platform}`);
-  }
-
-  // Try to find Inky's bundled inklecate
-  const possiblePaths = [
-    // Same repo (if we're in the inky_digi folder)
-    path.join(__dirname, '../../../app/main-process/ink', binaryName),
-    // User might have inklecate in PATH
-    binaryName,
-    // Custom path from environment
-    process.env.INKLECATE_PATH,
-  ].filter(Boolean);
-
-  for (const binPath of possiblePaths) {
-    try {
-      if (fs.existsSync(binPath)) {
-        return binPath;
-      }
-    } catch (e) {
-      // Continue checking
-    }
-  }
-
-  // Fallback to expecting it in PATH
-  return binaryName;
-}
diff --git a/ink-ai-assistant/src/shared/types.js b/ink-ai-assistant/src/shared/types.js
deleted file mode 100644
index 4bb11c7a..00000000
--- a/ink-ai-assistant/src/shared/types.js
+++ /dev/null
@@ -1,110 +0,0 @@
-/**
- * Shared types and constants for Ink AI Assistant
- */
-
-// IPC channels for main <-> renderer communication
-const IPC_CHANNELS = {
-  // File operations
-  OPEN_FILE: 'open-file',
-  FILE_OPENED: 'file-opened',
-  FILE_CHANGED: 'file-changed',
-  SAVE_FILE: 'save-file',
-
-  // Compilation
-  COMPILE: 'compile',
-  COMPILE_RESULT: 'compile-result',
-  COMPILE_ERROR: 'compile-error',
-
-  // AI operations
-  SEND_MESSAGE: 'send-message',
-  AI_RESPONSE: 'ai-response',
-  AI_ERROR: 'ai-error',
-  AI_STREAMING: 'ai-streaming',
-
-  // Code generation
-  GENERATE_CODE: 'generate-code',
-  FIX_ERROR: 'fix-error',
-  EXPLAIN_CODE: 'explain-code',
-
-  // Configuration
-  GET_CONFIG: 'get-config',
-  SET_CONFIG: 'set-config',
-  CONFIG_UPDATED: 'config-updated',
-
-  // Documentation search
-  SEARCH_DOCS: 'search-docs',
-  DOCS_RESULT: 'docs-result',
-};
-
-// Error types from inklecate
-const ERROR_TYPES = {
-  ERROR: 'ERROR',
-  WARNING: 'WARNING',
-  TODO: 'TODO',
-  AUTHOR: 'AUTHOR',
-};
-
-// Message roles for chat
-const MESSAGE_ROLES = {
-  USER: 'user',
-  ASSISTANT: 'assistant',
-  SYSTEM: 'system',
-};
-
-// AI operation types
-const AI_OPERATIONS = {
-  CHAT: 'chat',
-  GENERATE: 'generate',
-  FIX: 'fix',
-  EXPLAIN: 'explain',
-  REFACTOR: 'refactor',
-};
-
-/**
- * @typedef {Object} InkError
- * @property {string} type - ERROR, WARNING, TODO, or AUTHOR
- * @property {string} message - Error message
- * @property {string} filename - File where error occurred
- * @property {number} line - Line number (1-indexed)
- * @property {number} column - Column number (1-indexed)
- * @property {string} context - Surrounding code context
- */
-
-/**
- * @typedef {Object} CompilationResult
- * @property {boolean} success - Whether compilation succeeded
- * @property {InkError[]} errors - Array of errors/warnings
- * @property {string} [output] - JSON output if successful
- * @property {number} duration - Compilation time in ms
- */
-
-/**
- * @typedef {Object} ChatMessage
- * @property {string} role - user, assistant, or system
- * @property {string} content - Message content
- * @property {number} timestamp - Unix timestamp
- * @property {Object} [metadata] - Additional metadata
- */
-
-/**
- * @typedef {Object} DocumentChunk
- * @property {string} content - Documentation content
- * @property {Object} metadata - Metadata (section, title, etc.)
- * @property {number} similarity - Similarity score (0-1)
- */
-
-/**
- * @typedef {Object} AIRequest
- * @property {string} operation - Type of AI operation
- * @property {string} prompt - User prompt
- * @property {string} [code] - Current code context
- * @property {InkError[]} [errors] - Errors to fix
- * @property {DocumentChunk[]} [context] - Retrieved documentation
- */
-
-module.exports = {
-  IPC_CHANNELS,
-  ERROR_TYPES,
-  MESSAGE_ROLES,
-  AI_OPERATIONS,
-};

From 21fae222b3371495fba46c0b84f638022d60d43c Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 16 Nov 2025 23:46:29 +0000
Subject: [PATCH 3/3] Add Ink AI Assistant - complete companion app for
 AI-powered ink development

Full-featured Electron app for AI-assisted ink script creation:
- Local LLM integration (Ollama/LM Studio)
- Real-time error detection and fixing
- Interactive chat interface
- RAG-powered documentation search
- File watching and auto-compilation
- Supabase vector storage support

Ready to use: npm install && npm start

Download this folder to use as standalone project at:
https://github.com/digeriuz77/ink-assistant
---
 ink-ai-assistant/.env.example                 |  22 +
 ink-ai-assistant/.gitignore                   |  42 ++
 ink-ai-assistant/QUICKSTART.md                | 216 +++++++++
 ink-ai-assistant/README.md                    | 244 ++++++++++
 ink-ai-assistant/package.json                 |  51 ++
 ink-ai-assistant/src/main/compiler.js         | 204 ++++++++
 ink-ai-assistant/src/main/errorParser.js      | 216 +++++++++
 ink-ai-assistant/src/main/fileWatcher.js      | 176 +++++++
 .../src/main/ingest-documentation.js          | 193 ++++++++
 ink-ai-assistant/src/main/llmClient.js        | 238 ++++++++++
 ink-ai-assistant/src/main/main.js             | 375 +++++++++++++++
 ink-ai-assistant/src/main/vectorStore.js      | 252 ++++++++++
 ink-ai-assistant/src/renderer/chat.js         | 412 ++++++++++++++++
 ink-ai-assistant/src/renderer/index.html      |  93 ++++
 ink-ai-assistant/src/renderer/preload.js      |  43 ++
 ink-ai-assistant/src/renderer/styles.css      | 448 ++++++++++++++++++
 ink-ai-assistant/src/shared/config.js         | 101 ++++
 ink-ai-assistant/src/shared/types.js          | 110 +++++
 ink-ai-assistant/supabase-setup.sql           |  54 +++
 19 files changed, 3490 insertions(+)
 create mode 100644 ink-ai-assistant/.env.example
 create mode 100644 ink-ai-assistant/.gitignore
 create mode 100644 ink-ai-assistant/QUICKSTART.md
 create mode 100644 ink-ai-assistant/README.md
 create mode 100644 ink-ai-assistant/package.json
 create mode 100644 ink-ai-assistant/src/main/compiler.js
 create mode 100644 ink-ai-assistant/src/main/errorParser.js
 create mode 100644 ink-ai-assistant/src/main/fileWatcher.js
 create mode 100644 ink-ai-assistant/src/main/ingest-documentation.js
 create mode 100644 ink-ai-assistant/src/main/llmClient.js
 create mode 100644 ink-ai-assistant/src/main/main.js
 create mode 100644 ink-ai-assistant/src/main/vectorStore.js
 create mode 100644 ink-ai-assistant/src/renderer/chat.js
 create mode 100644 ink-ai-assistant/src/renderer/index.html
 create mode 100644 ink-ai-assistant/src/renderer/preload.js
 create mode 100644 ink-ai-assistant/src/renderer/styles.css
 create mode 100644 ink-ai-assistant/src/shared/config.js
 create mode 100644 ink-ai-assistant/src/shared/types.js
 create mode 100644 ink-ai-assistant/supabase-setup.sql

diff --git a/ink-ai-assistant/.env.example b/ink-ai-assistant/.env.example
new file mode 100644
index 00000000..9a405656
--- /dev/null
+++ b/ink-ai-assistant/.env.example
@@ -0,0 +1,22 @@
+# Local LLM Configuration (OpenAI-compatible API)
+# For Ollama (default): http://localhost:11434/v1
+# For LM Studio: http://localhost:1234/v1
+# For LocalAI: http://localhost:8080/v1
+LLM_BASE_URL=http://localhost:11434/v1
+
+# Model name (depends on your LLM provider)
+# Ollama: llama3.1, codellama, mistral, etc.
+# LM Studio: Whatever model you loaded
+LLM_MODEL=llama3.1
+
+# API key (Ollama doesn't need a real key, just use 'ollama')
+LLM_API_KEY=ollama
+
+# Supabase Configuration
+# Get these from your Supabase project settings
+SUPABASE_URL=https://your-project-id.supabase.co
+SUPABASE_ANON_KEY=your-anon-key-here
+
+# Optional: Custom inklecate binary path
+# Leave blank to auto-detect
+INKLECATE_PATH=
diff --git a/ink-ai-assistant/.gitignore b/ink-ai-assistant/.gitignore
new file mode 100644
index 00000000..1f500474
--- /dev/null
+++ b/ink-ai-assistant/.gitignore
@@ -0,0 +1,42 @@
+# Dependencies
+node_modules/
+package-lock.json
+
+# Environment variables
+.env
+.env.local
+
+# Build outputs
+dist/
+build/
+*.app
+*.exe
+*.dmg
+*.AppImage
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS files
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# Logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Electron
+out/
+.webpack/
+
+# Temporary files
+*.tmp
+.cache/
diff --git a/ink-ai-assistant/QUICKSTART.md b/ink-ai-assistant/QUICKSTART.md
new file mode 100644
index 00000000..5cc30775
--- /dev/null
+++ b/ink-ai-assistant/QUICKSTART.md
@@ -0,0 +1,216 @@
+# Quick Start Guide
+
+Get your Ink AI Assistant up and running in minutes!
+
+## Prerequisites
+
+1. **Inky Installed** - You need the Inky editor with inklecate
+   - Download from: https://github.com/inkle/inky
+   - Or you already have it at `/home/user/inky_digi`
+
+2. **Node.js** - Version 16 or higher
+   ```bash
+   node --version  # Should be v16.0.0 or higher
+   ```
+
+3. **Local LLM** - Choose one:
+   - **Ollama** (Recommended - easiest)
+   - LM Studio
+   - LocalAI
+   - Any OpenAI-compatible API
+
+## Step 1: Install Ollama & Pull a Model
+
+```bash
+# Install Ollama
+curl -fsSL https://ollama.com/install.sh | sh
+
+# Pull a code-capable model
+ollama pull llama3.1
+
+# Optional: Pull embedding model for better RAG
+ollama pull nomic-embed-text
+
+# Start Ollama (if not auto-started)
+ollama serve
+```
+
+## Step 2: Install Dependencies
+
+```bash
+cd /home/user/ink-ai-assistant
+npm install
+```
+
+## Step 3: Configure Environment
+
+```bash
+# Copy example env file
+cp .env.example .env
+
+# Edit .env file
+nano .env  # or use your preferred editor
+```
+
+**Minimum configuration** (works without Supabase):
+```env
+LLM_BASE_URL=http://localhost:11434/v1
+LLM_MODEL=llama3.1
+LLM_API_KEY=ollama
+```
+
+**Full configuration** (with RAG):
+```env
+LLM_BASE_URL=http://localhost:11434/v1
+LLM_MODEL=llama3.1
+LLM_API_KEY=ollama
+
+# Get these from https://supabase.com (free tier available)
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_ANON_KEY=your-anon-key-here
+```
+
+## Step 4: Set Up Supabase (Optional but Recommended)
+
+### 4a. Create Supabase Project
+1. Go to https://supabase.com
+2. Create free account
+3. Create new project
+4. Wait for setup (~2 minutes)
+
+### 4b. Run SQL Setup
+1. Go to SQL Editor in Supabase dashboard
+2. Copy contents of `supabase-setup.sql`
+3. Paste and run
+
+### 4c. Get Credentials
+1. Go to Settings → API
+2. Copy:
+   - `URL` → SUPABASE_URL
+   - `anon public` key → SUPABASE_ANON_KEY
+3. Add to `.env` file
+
+### 4d. Ingest Documentation
+```bash
+npm run ingest-docs
+```
+
+You should see:
+```
+🚀 Starting documentation ingestion...
+📄 Found documentation: ...
+✅ Successfully ingested X documentation chunks!
+```
+
+## Step 5: Run the App!
+
+```bash
+npm start
+```
+
+The Ink AI Assistant window should open!
+
+## Verify Setup
+
+### Check Ollama
+```bash
+# In terminal:
+curl http://localhost:11434/api/tags
+
+# Should list your installed models
+```
+
+### Check Inklecate
+```bash
+# The app will auto-detect inklecate from Inky installation
+# If it fails, set custom path:
+export INKLECATE_PATH=/path/to/inklecate
+```
+
+### Test the App
+1. Click "Open Ink File"
+2. Select an .ink file (or create a test file)
+3. Try asking: "How do I create choices in ink?"
+4. The AI should respond!
+
+## Common Issues
+
+### "Could not find inklecate"
+**Solution:**
+```bash
+# Set path to your inklecate binary
+export INKLECATE_PATH=/home/user/inky_digi/app/main-process/ink/inklecate_linux
+```
+
+### "Could not connect to local LLM"
+**Solution:**
+```bash
+# Make sure Ollama is running
+ollama serve
+
+# Test it:
+curl http://localhost:11434/api/tags
+```
+
+### "Vector store not configured"
+This is OK! The app works without Supabase, just with limited RAG features.
+
+To enable full RAG:
+1. Set up Supabase (see Step 4)
+2. Add credentials to `.env`
+3. Run `npm run ingest-docs`
+
+## Usage Tips
+
+### Quick Actions
+- **🔧 Fix Errors** - Auto-fix compilation errors
+- **💡 Explain** - Get explanations about ink syntax
+- **✨ Generate Code** - Create ink code from descriptions
+
+### Example Questions
+```
+"How do I create sticky choices?"
+"Generate a branching dialogue with 3 choices"
+"What's wrong with this code?" (paste ink code)
+"Explain diverts and knots"
+```
+
+### Workflow
+1. Open your .ink file in Inky (your normal editor)
+2. Open Ink AI Assistant in a separate window
+3. Edit in Inky, get help from the assistant
+4. When you save, the assistant auto-detects errors
+5. Ask for fixes, explanations, or generate new code
+
+## Development Mode
+
+```bash
+# Run with DevTools open
+npm run dev
+```
+
+## Building for Distribution
+
+```bash
+# Build for your platform
+npm run build
+
+# Or platform-specific:
+npm run build:mac
+npm run build:win
+npm run build:linux
+```
+
+## Next Steps
+
+- Read the full [README.md](README.md) for more details
+- Explore the [ink documentation](https://github.com/inkle/ink/blob/master/Documentation/WritingWithInk.md)
+- Join the ink community on Discord
+
+## Need Help?
+
+- Check the [README.md](README.md)
+- Open an issue on GitHub
+- Make sure Ollama is running and accessible
+
+Happy writing! ✨
diff --git a/ink-ai-assistant/README.md b/ink-ai-assistant/README.md
new file mode 100644
index 00000000..45a12986
--- /dev/null
+++ b/ink-ai-assistant/README.md
@@ -0,0 +1,244 @@
+# Ink AI Assistant
+
+AI-powered companion app for Ink script development with local LLM support.
+
+## What is this?
+
+This is a **separate Electron app** that works alongside [Inky](https://github.com/inkle/inky) (the official Ink editor) to provide:
+
+- ✨ **AI-assisted code generation** - Generate ink scripts using natural language
+- 🔍 **Error detection & fixing** - Automatic error detection with AI-powered fixes
+- 💬 **Interactive chat interface** - Ask questions about ink syntax and get help
+- 📚 **Documentation search** - RAG-powered search through ink documentation
+- 🔄 **Live file watching** - Monitors your .ink files for errors as you work
+
+## Architecture
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   INKY               │         │  INK AI ASSISTANT    │
+│   (editor)           │         │  (this app)          │
+│                      │         │                      │
+│   - Edit .ink files  │         │  - Watch same files  │
+│   - Syntax highlight │◄────────┤  - Chat interface    │
+│   - Live preview     │  same   │  - AI suggestions    │
+│                      │  files  │  - Error fixes       │
+└──────┬───────────────┘         └──────┬───────────────┘
+       │                                │
+       │                                │
+       └────────┬───────────────────────┘
+                │
+                ▼
+         your-story.ink
+```
+
+## Prerequisites
+
+### 1. Inky Installation
+You need Inky installed to use its `inklecate` compiler. The app will auto-detect it from:
+- `/home/user/inky_digi/` (if installed as sibling directory)
+- `~/inky_digi/` or `~/Inky/` (common locations)
+- Custom path via `INKLECATE_PATH` environment variable
+
+### 2. Local LLM (OpenAI-compatible API)
+Install one of these local LLM servers:
+
+**Ollama (Recommended):**
+```bash
+# Install Ollama
+curl -fsSL https://ollama.com/install.sh | sh
+
+# Pull a model
+ollama pull llama3.1
+# or
+ollama pull codellama
+```
+
+**Alternatives:**
+- [LM Studio](https://lmstudio.ai/)
+- [LocalAI](https://localai.io/)
+- [Text Generation WebUI](https://github.com/oobabooga/text-generation-webui)
+
+### 3. Supabase (for vector storage)
+Create a free Supabase project at [supabase.com](https://supabase.com) for documentation search.
+
+## Installation
+
+```bash
+# Navigate to this directory
+cd /home/user/ink-ai-assistant
+
+# Install dependencies
+npm install
+
+# Set up environment variables (create .env file)
+cp .env.example .env
+# Edit .env with your settings
+```
+
+## Configuration
+
+Create a `.env` file:
+
+```env
+# Local LLM settings (Ollama)
+LLM_BASE_URL=http://localhost:11434/v1
+LLM_MODEL=llama3.1
+LLM_API_KEY=ollama
+
+# Supabase settings
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_ANON_KEY=your-anon-key-here
+
+# Optional: Custom inklecate path
+INKLECATE_PATH=/path/to/inklecate
+```
+
+## Usage
+
+### Running the App
+
+```bash
+# Development mode
+npm start
+
+# Or
+npm run dev
+```
+
+### Ingesting Documentation
+
+Before first use, ingest the ink documentation into your vector database:
+
+```bash
+npm run ingest-docs
+```
+
+This will:
+1. Read the Ink documentation from Inky's bundled files
+2. Split it into chunks
+3. Generate embeddings
+4. Store in Supabase vector storage
+
+### Workflow
+
+1. **Open Inky** - Edit your .ink files as usual
+2. **Open Ink AI Assistant** - This companion app in a separate window
+3. **Work normally** - The assistant watches your files
+4. **Get help** - Ask questions, fix errors, generate code via chat
+
+## Features
+
+### 1. Error Detection & Fixing
+```
+You save story.ink with an error
+  ↓
+AI Assistant detects compilation error
+  ↓
+Suggests fix based on documentation
+  ↓
+You apply fix with one click
+```
+
+### 2. AI Code Generation
+```
+Chat: "Create a choice with three options about going to the park"
+  ↓
+AI generates proper ink syntax
+  ↓
+You copy/paste into Inky
+```
+
+### 3. Documentation Search
+```
+Chat: "How do I use sticky choices?"
+  ↓
+RAG retrieves relevant docs
+  ↓
+AI explains with examples
+```
+
+## Project Structure
+
+```
+ink-ai-assistant/
+├── src/
+│   ├── main/               # Electron main process
+│   │   ├── main.js         # App entry point
+│   │   ├── compiler.js     # Inklecate integration
+│   │   ├── errorParser.js  # Parse compiler errors
+│   │   ├── llmClient.js    # Local LLM client
+│   │   ├── vectorStore.js  # Supabase integration
+│   │   └── fileWatcher.js  # Watch .ink files
+│   ├── renderer/           # UI (frontend)
+│   │   ├── index.html      # Main window
+│   │   ├── chat.js         # Chat interface
+│   │   └── styles.css      # Styling
+│   └── shared/             # Shared code
+│       ├── config.js       # Configuration
+│       └── types.js        # Type definitions
+├── resources/              # App assets
+├── package.json
+└── README.md
+```
+
+## Technology Stack
+
+- **Electron 30.0.4** - Desktop app framework (matches Inky)
+- **OpenAI SDK** - Works with local LLMs via OpenAI-compatible API
+- **Supabase** - Vector storage for RAG
+- **Chokidar** - File watching
+- **Marked** - Markdown parsing
+
+## Development
+
+### Building
+
+```bash
+# Build for current platform
+npm run build
+
+# Platform-specific builds
+npm run build:mac
+npm run build:win
+npm run build:linux
+```
+
+### Adding Features
+
+The app is modular - each feature lives in its own module:
+- Add LLM providers → `src/main/llmClient.js`
+- Modify error parsing → `src/main/errorParser.js`
+- Customize UI → `src/renderer/`
+
+## Troubleshooting
+
+### Can't find inklecate
+```bash
+# Set custom path
+export INKLECATE_PATH=/path/to/inklecate_binary
+```
+
+### Local LLM not responding
+```bash
+# Check if Ollama is running
+curl http://localhost:11434/api/tags
+
+# Start Ollama
+ollama serve
+```
+
+### Supabase connection issues
+- Check your `.env` file has correct credentials
+- Ensure Supabase project has pgvector extension enabled
+- Run `npm run ingest-docs` to populate the database
+
+## License
+
+MIT
+
+## Credits
+
+- Built for [Ink](https://www.inklestudios.com/ink/) by inkle
+- Companion to [Inky](https://github.com/inkle/inky) editor
+- Uses local LLMs for privacy and offline operation
diff --git a/ink-ai-assistant/package.json b/ink-ai-assistant/package.json
new file mode 100644
index 00000000..47b7be3b
--- /dev/null
+++ b/ink-ai-assistant/package.json
@@ -0,0 +1,51 @@
+{
+  "name": "ink-ai-assistant",
+  "version": "0.1.0",
+  "description": "AI-powered companion app for Ink script development with local LLM support",
+  "main": "src/main/main.js",
+  "scripts": {
+    "start": "electron .",
+    "dev": "electron . --dev",
+    "build": "electron-builder",
+    "build:mac": "electron-builder --mac",
+    "build:win": "electron-builder --win",
+    "build:linux": "electron-builder --linux",
+    "ingest-docs": "node src/main/ingest-documentation.js"
+  },
+  "author": "Ink AI Assistant Team",
+  "license": "MIT",
+  "dependencies": {
+    "@supabase/supabase-js": "^2.39.0",
+    "axios": "^1.6.0",
+    "chokidar": "^3.6.0",
+    "marked": "^11.0.0",
+    "openai": "^4.20.0"
+  },
+  "devDependencies": {
+    "electron": "^30.0.4",
+    "electron-builder": "^24.9.1"
+  },
+  "build": {
+    "appId": "com.inkassistant.app",
+    "productName": "Ink AI Assistant",
+    "directories": {
+      "output": "dist"
+    },
+    "files": [
+      "src/**/*",
+      "resources/**/*",
+      "package.json"
+    ],
+    "mac": {
+      "category": "public.app-category.developer-tools",
+      "icon": "resources/icon.icns"
+    },
+    "win": {
+      "icon": "resources/icon.ico"
+    },
+    "linux": {
+      "icon": "resources/icon.png",
+      "category": "Development"
+    }
+  }
+}
diff --git a/ink-ai-assistant/src/main/compiler.js b/ink-ai-assistant/src/main/compiler.js
new file mode 100644
index 00000000..6f3e05bc
--- /dev/null
+++ b/ink-ai-assistant/src/main/compiler.js
@@ -0,0 +1,204 @@
+/**
+ * Inklecate Compiler Integration
+ * Wraps inklecate binary to compile .ink files and capture errors
+ */
+
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const config = require('../shared/config');
+
+class InkCompiler {
+  constructor() {
+    this.inklecatePath = config.inklecate.binary;
+    this.timeout = config.inklecate.timeout;
+  }
+
+  /**
+   * Compile an ink file
+   * @param {string} inkFilePath - Path to .ink file
+   * @param {Object} options - Compilation options
+   * @returns {Promise<CompilationResult>}
+   */
+  async compile(inkFilePath, options = {}) {
+    return new Promise((resolve, reject) => {
+      const startTime = Date.now();
+
+      // Validate file exists
+      if (!fs.existsSync(inkFilePath)) {
+        return reject(new Error(`File not found: ${inkFilePath}`));
+      }
+
+      // Prepare output path (JSON file)
+      const outputPath = options.outputPath || inkFilePath.replace(/\.ink$/, '.json');
+
+      // Build inklecate arguments
+      const args = [
+        '-o', outputPath,  // Output JSON file
+        inkFilePath,       // Input ink file
+      ];
+
+      if (options.countAllVisits) {
+        args.push('-c');
+      }
+
+      // Spawn inklecate process
+      const process = spawn(this.inklecatePath, args);
+
+      let stdout = '';
+      let stderr = '';
+
+      process.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      process.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      // Timeout handler
+      const timeoutId = setTimeout(() => {
+        process.kill();
+        reject(new Error(`Compilation timeout after ${this.timeout}ms`));
+      }, this.timeout);
+
+      process.on('close', (code) => {
+        clearTimeout(timeoutId);
+        const duration = Date.now() - startTime;
+
+        // Parse output
+        const result = {
+          success: code === 0,
+          errors: this.parseOutput(stdout + stderr, inkFilePath),
+          duration,
+          exitCode: code,
+        };
+
+        // If successful, read the JSON output
+        if (result.success && fs.existsSync(outputPath)) {
+          try {
+            result.output = fs.readFileSync(outputPath, 'utf8');
+          } catch (e) {
+            // JSON read failed, but compilation succeeded
+          }
+        }
+
+        resolve(result);
+      });
+
+      process.on('error', (err) => {
+        clearTimeout(timeoutId);
+        reject(new Error(`Failed to spawn inklecate: ${err.message}`));
+      });
+    });
+  }
+
+  /**
+   * Quick validation without generating JSON
+   * @param {string} inkFilePath - Path to .ink file
+   * @returns {Promise<CompilationResult>}
+   */
+  async validate(inkFilePath) {
+    // Use /dev/null or NUL as output to avoid writing files
+    const nullDevice = process.platform === 'win32' ? 'NUL' : '/dev/null';
+    return this.compile(inkFilePath, { outputPath: nullDevice });
+  }
+
+  /**
+   * Parse inklecate output into structured errors
+   * @param {string} output - Raw compiler output
+   * @param {string} baseFile - Base file path for relative paths
+   * @returns {Array<InkError>}
+   */
+  parseOutput(output, baseFile) {
+    const errors = [];
+    const lines = output.split('\n');
+
+    // Pattern: ERROR: filename.ink line X: message
+    // Pattern: WARNING: filename.ink line X: message
+    // Pattern: TODO: filename.ink line X: message
+    const errorPattern = /^(ERROR|WARNING|TODO|AUTHOR):\s+([^:]+):?\s+line\s+(\d+):\s*(.+)$/i;
+
+    for (const line of lines) {
+      const match = line.match(errorPattern);
+      if (match) {
+        const [, type, filename, lineNum, message] = match;
+
+        errors.push({
+          type: type.toUpperCase(),
+          message: message.trim(),
+          filename: filename.trim(),
+          line: parseInt(lineNum, 10),
+          column: 0, // inklecate doesn't provide column info
+          raw: line,
+        });
+      }
+    }
+
+    return errors;
+  }
+
+  /**
+   * Check if inklecate is available
+   * @returns {Promise<boolean>}
+   */
+  async isAvailable() {
+    try {
+      const result = await new Promise((resolve) => {
+        const process = spawn(this.inklecatePath, ['--version']);
+        let found = false;
+
+        process.on('close', (code) => {
+          resolve(code === 0 || found);
+        });
+
+        process.stdout.on('data', () => {
+          found = true;
+        });
+
+        process.on('error', () => {
+          resolve(false);
+        });
+
+        setTimeout(() => {
+          process.kill();
+          resolve(false);
+        }, 2000);
+      });
+
+      return result;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /**
+   * Get inklecate version
+   * @returns {Promise<string>}
+   */
+  async getVersion() {
+    return new Promise((resolve) => {
+      const process = spawn(this.inklecatePath, ['--version']);
+      let version = 'unknown';
+
+      process.stdout.on('data', (data) => {
+        version = data.toString().trim();
+      });
+
+      process.on('close', () => {
+        resolve(version);
+      });
+
+      process.on('error', () => {
+        resolve('unknown');
+      });
+
+      setTimeout(() => {
+        process.kill();
+        resolve('unknown');
+      }, 2000);
+    });
+  }
+}
+
+module.exports = InkCompiler;
diff --git a/ink-ai-assistant/src/main/errorParser.js b/ink-ai-assistant/src/main/errorParser.js
new file mode 100644
index 00000000..0ca0dc88
--- /dev/null
+++ b/ink-ai-assistant/src/main/errorParser.js
@@ -0,0 +1,216 @@
+/**
+ * Error Parser
+ * Enhances compiler errors with source code context
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class ErrorParser {
+  /**
+   * Enhance errors with source code context
+   * @param {Array<InkError>} errors - Raw errors from compiler
+   * @param {number} contextLines - Lines of context before/after error
+   * @returns {Array<InkError>} Enhanced errors with context
+   */
+  enhanceErrors(errors, contextLines = 3) {
+    return errors.map(error => this.enhanceError(error, contextLines));
+  }
+
+  /**
+   * Enhance single error with context
+   * @param {InkError} error - Raw error
+   * @param {number} contextLines - Lines of context
+   * @returns {InkError} Enhanced error
+   */
+  enhanceError(error, contextLines = 3) {
+    try {
+      // Read source file
+      const source = fs.readFileSync(error.filename, 'utf8');
+      const lines = source.split('\n');
+
+      // Calculate context range
+      const errorLine = error.line - 1; // Convert to 0-indexed
+      const startLine = Math.max(0, errorLine - contextLines);
+      const endLine = Math.min(lines.length - 1, errorLine + contextLines);
+
+      // Extract context
+      const contextLines_arr = [];
+      for (let i = startLine; i <= endLine; i++) {
+        contextLines_arr.push({
+          lineNum: i + 1,
+          content: lines[i],
+          isError: i === errorLine,
+        });
+      }
+
+      // Add context to error
+      return {
+        ...error,
+        context: {
+          lines: contextLines_arr,
+          errorLine: lines[errorLine],
+          startLine: startLine + 1,
+          endLine: endLine + 1,
+        },
+      };
+    } catch (e) {
+      // If we can't read the file, return error as-is
+      return error;
+    }
+  }
+
+  /**
+   * Group errors by file
+   * @param {Array<InkError>} errors - Errors to group
+   * @returns {Object} Errors grouped by filename
+   */
+  groupByFile(errors) {
+    const grouped = {};
+
+    for (const error of errors) {
+      const filename = error.filename;
+      if (!grouped[filename]) {
+        grouped[filename] = [];
+      }
+      grouped[filename].push(error);
+    }
+
+    return grouped;
+  }
+
+  /**
+   * Group errors by type
+   * @param {Array<InkError>} errors - Errors to group
+   * @returns {Object} Errors grouped by type (ERROR, WARNING, etc.)
+   */
+  groupByType(errors) {
+    const grouped = {
+      ERROR: [],
+      WARNING: [],
+      TODO: [],
+      AUTHOR: [],
+    };
+
+    for (const error of errors) {
+      const type = error.type.toUpperCase();
+      if (grouped[type]) {
+        grouped[type].push(error);
+      }
+    }
+
+    return grouped;
+  }
+
+  /**
+   * Format error for display
+   * @param {InkError} error - Error to format
+   * @returns {string} Formatted error message
+   */
+  formatError(error) {
+    const icon = this.getErrorIcon(error.type);
+    let output = `${icon} ${error.type}: ${error.message}\n`;
+    output += `   at ${error.filename}:${error.line}\n`;
+
+    if (error.context) {
+      output += '\n';
+      for (const line of error.context.lines) {
+        const marker = line.isError ? '→' : ' ';
+        output += `   ${marker} ${String(line.lineNum).padStart(4)}: ${line.content}\n`;
+      }
+    }
+
+    return output;
+  }
+
+  /**
+   * Get icon for error type
+   * @param {string} type - Error type
+   * @returns {string} Icon
+   */
+  getErrorIcon(type) {
+    const icons = {
+      ERROR: '🔴',
+      WARNING: '⚠️',
+      TODO: '📝',
+      AUTHOR: '✍️',
+    };
+    return icons[type.toUpperCase()] || '•';
+  }
+
+  /**
+   * Generate AI-friendly error summary
+   * @param {Array<InkError>} errors - Errors to summarize
+   * @returns {string} Summary for LLM context
+   */
+  summarizeForAI(errors) {
+    if (errors.length === 0) {
+      return 'No errors found. The ink file compiled successfully.';
+    }
+
+    let summary = `Found ${errors.length} issue(s) in the ink file:\n\n`;
+
+    const byType = this.groupByType(errors);
+
+    if (byType.ERROR.length > 0) {
+      summary += `ERRORS (${byType.ERROR.length}):\n`;
+      for (const error of byType.ERROR) {
+        summary += `- Line ${error.line}: ${error.message}\n`;
+        if (error.context) {
+          summary += `  Code: ${error.context.errorLine}\n`;
+        }
+      }
+      summary += '\n';
+    }
+
+    if (byType.WARNING.length > 0) {
+      summary += `WARNINGS (${byType.WARNING.length}):\n`;
+      for (const error of byType.WARNING) {
+        summary += `- Line ${error.line}: ${error.message}\n`;
+      }
+      summary += '\n';
+    }
+
+    return summary.trim();
+  }
+
+  /**
+   * Suggest common fixes based on error message
+   * @param {InkError} error - Error to analyze
+   * @returns {Array<string>} Suggested fixes
+   */
+  suggestQuickFixes(error) {
+    const suggestions = [];
+    const msg = error.message.toLowerCase();
+
+    // Common patterns
+    if (msg.includes('unexpected token') || msg.includes('expected')) {
+      suggestions.push('Check for missing or extra punctuation');
+      suggestions.push('Verify syntax matches ink documentation');
+    }
+
+    if (msg.includes('divert') || msg.includes('->')) {
+      suggestions.push('Ensure knot/stitch names are defined');
+      suggestions.push('Check divert target spelling');
+    }
+
+    if (msg.includes('choice') || msg.includes('*') || msg.includes('+')) {
+      suggestions.push('Choices must start with * or +');
+      suggestions.push('Ensure proper indentation for nested choices');
+    }
+
+    if (msg.includes('variable')) {
+      suggestions.push('Declare variables with VAR before use');
+      suggestions.push('Check variable name spelling');
+    }
+
+    if (msg.includes('knot') || msg.includes('stitch')) {
+      suggestions.push('Knot names must start with ==');
+      suggestions.push('Stitch names must start with =');
+    }
+
+    return suggestions;
+  }
+}
+
+module.exports = ErrorParser;
diff --git a/ink-ai-assistant/src/main/fileWatcher.js b/ink-ai-assistant/src/main/fileWatcher.js
new file mode 100644
index 00000000..e1f2c1e8
--- /dev/null
+++ b/ink-ai-assistant/src/main/fileWatcher.js
@@ -0,0 +1,176 @@
+/**
+ * File Watcher
+ * Monitors .ink files for changes and triggers compilation
+ */
+
+const chokidar = require('chokidar');
+const path = require('path');
+const config = require('../shared/config');
+const InkCompiler = require('./compiler');
+const ErrorParser = require('./errorParser');
+
+class FileWatcher {
+  constructor() {
+    this.watcher = null;
+    this.watchedPaths = new Set();
+    this.compiler = new InkCompiler();
+    this.errorParser = new ErrorParser();
+    this.callbacks = {
+      onFileChange: null,
+      onError: null,
+      onCompilationComplete: null,
+    };
+  }
+
+  /**
+   * Start watching a directory or file
+   * @param {string|Array<string>} paths - Paths to watch
+   * @param {Object} callbacks - Event callbacks
+   */
+  watch(paths, callbacks = {}) {
+    this.callbacks = { ...this.callbacks, ...callbacks };
+
+    const pathsArray = Array.isArray(paths) ? paths : [paths];
+
+    // Add .ink pattern to watch
+    const inkPaths = pathsArray.map(p => {
+      // If directory, watch all .ink files
+      if (!p.endsWith('.ink')) {
+        return path.join(p, '**/*.ink');
+      }
+      return p;
+    });
+
+    this.watcher = chokidar.watch(inkPaths, {
+      ...config.fileWatcher,
+      ignoreInitial: false, // Compile on start
+    });
+
+    // Set up event handlers
+    this.watcher
+      .on('add', (filepath) => this.handleFileEvent('add', filepath))
+      .on('change', (filepath) => this.handleFileEvent('change', filepath))
+      .on('unlink', (filepath) => this.handleFileEvent('unlink', filepath))
+      .on('error', (error) => this.handleError(error));
+
+    inkPaths.forEach(p => this.watchedPaths.add(p));
+
+    console.log('Watching ink files:', inkPaths);
+  }
+
+  /**
+   * Handle file system events
+   * @param {string} event - Event type
+   * @param {string} filepath - File path
+   */
+  async handleFileEvent(event, filepath) {
+    console.log(`File ${event}:`, filepath);
+
+    // Notify about file change
+    if (this.callbacks.onFileChange) {
+      this.callbacks.onFileChange(event, filepath);
+    }
+
+    // Compile on add or change
+    if (event === 'add' || event === 'change') {
+      await this.compileFile(filepath);
+    }
+  }
+
+  /**
+   * Compile an ink file and report results
+   * @param {string} filepath - Path to ink file
+   */
+  async compileFile(filepath) {
+    try {
+      console.log('Compiling:', filepath);
+
+      const result = await this.compiler.validate(filepath);
+
+      // Enhance errors with context
+      if (result.errors.length > 0) {
+        result.errors = this.errorParser.enhanceErrors(result.errors);
+      }
+
+      // Notify about compilation result
+      if (this.callbacks.onCompilationComplete) {
+        this.callbacks.onCompilationComplete(filepath, result);
+      }
+
+      if (result.success) {
+        console.log(`✓ ${filepath} compiled successfully`);
+      } else {
+        console.log(`✗ ${filepath} has ${result.errors.length} error(s)`);
+      }
+
+      return result;
+    } catch (error) {
+      console.error('Compilation error:', error);
+      this.handleError(error);
+      return null;
+    }
+  }
+
+  /**
+   * Handle errors
+   * @param {Error} error - Error object
+   */
+  handleError(error) {
+    console.error('File watcher error:', error);
+    if (this.callbacks.onError) {
+      this.callbacks.onError(error);
+    }
+  }
+
+  /**
+   * Stop watching
+   */
+  async stop() {
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+      this.watchedPaths.clear();
+      console.log('File watcher stopped');
+    }
+  }
+
+  /**
+   * Get watched paths
+   * @returns {Array<string>} Watched paths
+   */
+  getWatchedPaths() {
+    return Array.from(this.watchedPaths);
+  }
+
+  /**
+   * Add path to watch list
+   * @param {string} filepath - Path to add
+   */
+  addPath(filepath) {
+    if (this.watcher) {
+      this.watcher.add(filepath);
+      this.watchedPaths.add(filepath);
+    }
+  }
+
+  /**
+   * Remove path from watch list
+   * @param {string} filepath - Path to remove
+   */
+  removePath(filepath) {
+    if (this.watcher) {
+      this.watcher.unwatch(filepath);
+      this.watchedPaths.delete(filepath);
+    }
+  }
+
+  /**
+   * Check if watching any files
+   * @returns {boolean}
+   */
+  isWatching() {
+    return this.watcher !== null && this.watchedPaths.size > 0;
+  }
+}
+
+module.exports = FileWatcher;
diff --git a/ink-ai-assistant/src/main/ingest-documentation.js b/ink-ai-assistant/src/main/ingest-documentation.js
new file mode 100644
index 00000000..1597476f
--- /dev/null
+++ b/ink-ai-assistant/src/main/ingest-documentation.js
@@ -0,0 +1,193 @@
+/**
+ * Documentation Ingestion Script
+ * Reads ink documentation and stores it in Supabase vector database
+ *
+ * Usage: node src/main/ingest-documentation.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+const VectorStore = require('./vectorStore');
+
+class DocumentationIngester {
+  constructor() {
+    this.vectorStore = new VectorStore();
+    this.chunkSize = 1000; // characters per chunk
+    this.chunkOverlap = 200; // overlap between chunks
+  }
+
+  /**
+   * Main ingestion process
+   */
+  async ingest() {
+    console.log('🚀 Starting documentation ingestion...\n');
+
+    if (!this.vectorStore.isAvailable()) {
+      console.error('❌ Vector store not configured!');
+      console.error('Set SUPABASE_URL and SUPABASE_ANON_KEY in .env file');
+      process.exit(1);
+    }
+
+    try {
+      // Find documentation file
+      const docPath = this.findDocumentation();
+      if (!docPath) {
+        console.error('❌ Documentation not found!');
+        console.error('Expected: WritingWithInk.md from Inky installation');
+        process.exit(1);
+      }
+
+      console.log(`📄 Found documentation: ${docPath}\n`);
+
+      // Read documentation
+      const content = fs.readFileSync(docPath, 'utf8');
+      console.log(`📊 Documentation size: ${(content.length / 1024).toFixed(2)} KB\n`);
+
+      // Split into sections
+      const sections = this.splitIntoSections(content);
+      console.log(`📑 Split into ${sections.length} sections\n`);
+
+      // Clear existing documentation
+      console.log('🗑️  Clearing existing documentation...');
+      await this.vectorStore.clearAll();
+
+      // Insert sections
+      console.log('💾 Inserting documentation...');
+      let inserted = 0;
+
+      for (const section of sections) {
+        const chunks = this.chunkText(section.content);
+
+        for (const chunk of chunks) {
+          const success = await this.vectorStore.insertDocument(chunk, {
+            section: section.title,
+            source: 'WritingWithInk.md',
+            type: 'documentation',
+          });
+
+          if (success) {
+            inserted++;
+            process.stdout.write(`\r   Inserted: ${inserted} chunks`);
+          }
+        }
+      }
+
+      console.log(`\n\n✅ Successfully ingested ${inserted} documentation chunks!`);
+
+      // Verify
+      const count = await this.vectorStore.getCount();
+      console.log(`📊 Total documents in database: ${count}\n`);
+
+      // Test search
+      console.log('🔍 Testing search...');
+      const results = await this.vectorStore.search('how do I use choices?', 3);
+      console.log(`   Found ${results.length} relevant results\n`);
+
+      console.log('🎉 Ingestion complete!');
+
+    } catch (error) {
+      console.error('❌ Error:', error.message);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Find documentation file
+   */
+  findDocumentation() {
+    const possiblePaths = [
+      // Sibling inky_digi installation
+      path.join(__dirname, '../../../../inky_digi/resources/Documentation/WritingWithInk.md'),
+      // User home directory
+      path.join(require('os').homedir(), 'inky_digi/resources/Documentation/WritingWithInk.md'),
+      path.join(require('os').homedir(), 'Inky/resources/Documentation/WritingWithInk.md'),
+      // Custom path from environment
+      process.env.INK_DOCS_PATH,
+    ].filter(Boolean);
+
+    for (const docPath of possiblePaths) {
+      if (fs.existsSync(docPath)) {
+        return docPath;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Split documentation into major sections
+   */
+  splitIntoSections(content) {
+    const sections = [];
+    const lines = content.split('\n');
+
+    let currentSection = { title: 'Introduction', content: '' };
+
+    for (const line of lines) {
+      // Detect markdown headers (# Title)
+      const headerMatch = line.match(/^#\s+(.+)$/);
+
+      if (headerMatch) {
+        // Save previous section
+        if (currentSection.content.trim()) {
+          sections.push(currentSection);
+        }
+
+        // Start new section
+        currentSection = {
+          title: headerMatch[1].trim(),
+          content: '',
+        };
+      } else {
+        currentSection.content += line + '\n';
+      }
+    }
+
+    // Add last section
+    if (currentSection.content.trim()) {
+      sections.push(currentSection);
+    }
+
+    return sections;
+  }
+
+  /**
+   * Chunk text into smaller pieces with overlap
+   */
+  chunkText(text) {
+    const chunks = [];
+    const words = text.split(/\s+/);
+
+    let currentChunk = '';
+    let currentSize = 0;
+
+    for (const word of words) {
+      if (currentSize + word.length > this.chunkSize && currentChunk) {
+        chunks.push(currentChunk.trim());
+
+        // Create overlap
+        const overlapWords = currentChunk.split(/\s+/).slice(-20);
+        currentChunk = overlapWords.join(' ') + ' ';
+        currentSize = currentChunk.length;
+      }
+
+      currentChunk += word + ' ';
+      currentSize += word.length + 1;
+    }
+
+    // Add last chunk
+    if (currentChunk.trim()) {
+      chunks.push(currentChunk.trim());
+    }
+
+    return chunks;
+  }
+}
+
+// Run ingestion if called directly
+if (require.main === module) {
+  const ingester = new DocumentationIngester();
+  ingester.ingest().catch(console.error);
+}
+
+module.exports = DocumentationIngester;
diff --git a/ink-ai-assistant/src/main/llmClient.js b/ink-ai-assistant/src/main/llmClient.js
new file mode 100644
index 00000000..19820c27
--- /dev/null
+++ b/ink-ai-assistant/src/main/llmClient.js
@@ -0,0 +1,238 @@
+/**
+ * Local LLM Client
+ * Works with OpenAI-compatible APIs (Ollama, LM Studio, LocalAI, etc.)
+ */
+
+const OpenAI = require('openai');
+const config = require('../shared/config');
+
+class LLMClient {
+  constructor() {
+    this.client = new OpenAI({
+      baseURL: config.llm.baseURL,
+      apiKey: config.llm.apiKey,
+    });
+    this.model = config.llm.model;
+    this.temperature = config.llm.temperature;
+    this.maxTokens = config.llm.maxTokens;
+  }
+
+  /**
+   * Send a chat completion request
+   * @param {Array<ChatMessage>} messages - Conversation history
+   * @param {Object} options - Override options
+   * @returns {Promise<string>} AI response
+   */
+  async chat(messages, options = {}) {
+    try {
+      const response = await this.client.chat.completions.create({
+        model: options.model || this.model,
+        messages: messages,
+        temperature: options.temperature ?? this.temperature,
+        max_tokens: options.maxTokens || this.maxTokens,
+        stream: false,
+      });
+
+      return response.choices[0]?.message?.content || '';
+    } catch (error) {
+      throw new Error(`LLM request failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Stream chat completion
+   * @param {Array<ChatMessage>} messages - Conversation history
+   * @param {Function} onChunk - Callback for each chunk
+   * @param {Object} options - Override options
+   * @returns {Promise<string>} Complete response
+   */
+  async chatStream(messages, onChunk, options = {}) {
+    try {
+      const stream = await this.client.chat.completions.create({
+        model: options.model || this.model,
+        messages: messages,
+        temperature: options.temperature ?? this.temperature,
+        max_tokens: options.maxTokens || this.maxTokens,
+        stream: true,
+      });
+
+      let fullResponse = '';
+
+      for await (const chunk of stream) {
+        const content = chunk.choices[0]?.delta?.content || '';
+        if (content) {
+          fullResponse += content;
+          onChunk(content);
+        }
+      }
+
+      return fullResponse;
+    } catch (error) {
+      throw new Error(`LLM stream failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Generate ink code based on prompt
+   * @param {string} prompt - User request
+   * @param {string} context - Existing code context
+   * @returns {Promise<string>} Generated ink code
+   */
+  async generateInkCode(prompt, context = '') {
+    const systemPrompt = `You are an expert in the ink scripting language for interactive fiction.
+Generate clean, syntactically correct ink code based on user requests.
+
+Key ink syntax rules:
+- Knots start with ==
+- Stitches start with =
+- Choices use * (once-only) or + (sticky)
+- Diverts use ->
+- Variables declared with VAR
+- Logic uses curly braces {}
+- Comments use //
+
+Always generate valid, well-formatted ink code.`;
+
+    const messages = [
+      { role: 'system', content: systemPrompt },
+    ];
+
+    if (context) {
+      messages.push({
+        role: 'user',
+        content: `Here's the existing code for context:\n\`\`\`ink\n${context}\n\`\`\``,
+      });
+    }
+
+    messages.push({
+      role: 'user',
+      content: `Generate ink code for: ${prompt}\n\nProvide only the ink code, no explanations.`,
+    });
+
+    return await this.chat(messages, { temperature: 0.3 });
+  }
+
+  /**
+   * Fix ink errors using AI
+   * @param {string} code - Current ink code
+   * @param {Array<InkError>} errors - Compilation errors
+   * @param {string} documentation - Relevant docs from RAG
+   * @returns {Promise<Object>} { fixedCode, explanation }
+   */
+  async fixErrors(code, errors, documentation = '') {
+    const systemPrompt = `You are an expert in the ink scripting language.
+Fix compilation errors in ink code based on the error messages and documentation provided.
+Provide both the fixed code and a brief explanation of the changes.`;
+
+    const errorSummary = errors.map((e, i) =>
+      `${i + 1}. Line ${e.line}: ${e.message}`
+    ).join('\n');
+
+    let userPrompt = `Fix the following ink code errors:\n\n${errorSummary}\n\nCurrent code:\n\`\`\`ink\n${code}\n\`\`\``;
+
+    if (documentation) {
+      userPrompt += `\n\nRelevant documentation:\n${documentation}`;
+    }
+
+    userPrompt += `\n\nProvide:
+1. The fixed code (in a code block)
+2. A brief explanation of what was wrong and how you fixed it`;
+
+    const messages = [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userPrompt },
+    ];
+
+    const response = await this.chat(messages);
+
+    // Parse response to extract code and explanation
+    const codeMatch = response.match(/```(?:ink)?\n([\s\S]*?)\n```/);
+    const fixedCode = codeMatch ? codeMatch[1] : response;
+
+    return {
+      fixedCode,
+      explanation: response,
+    };
+  }
+
+  /**
+   * Explain ink code or concepts
+   * @param {string} query - What to explain
+   * @param {string} code - Code context (optional)
+   * @param {string} documentation - Relevant docs from RAG
+   * @returns {Promise<string>} Explanation
+   */
+  async explain(query, code = '', documentation = '') {
+    const systemPrompt = `You are an expert in the ink scripting language.
+Provide clear, helpful explanations about ink syntax, features, and best practices.
+Use examples when helpful.`;
+
+    let userPrompt = query;
+
+    if (code) {
+      userPrompt += `\n\nCode:\n\`\`\`ink\n${code}\n\`\`\``;
+    }
+
+    if (documentation) {
+      userPrompt += `\n\nRelevant documentation:\n${documentation}`;
+    }
+
+    const messages = [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userPrompt },
+    ];
+
+    return await this.chat(messages);
+  }
+
+  /**
+   * General chat about ink
+   * @param {Array<ChatMessage>} conversationHistory - Full conversation
+   * @param {string} documentation - Relevant docs from RAG
+   * @returns {Promise<string>} Response
+   */
+  async chatAboutInk(conversationHistory, documentation = '') {
+    const systemPrompt = `You are an expert assistant for the ink scripting language.
+Help users write better ink stories by answering questions, generating code, and fixing errors.
+Be concise but thorough. Use examples when helpful.
+
+${documentation ? `\nRelevant documentation:\n${documentation}` : ''}`;
+
+    const messages = [
+      { role: 'system', content: systemPrompt },
+      ...conversationHistory,
+    ];
+
+    return await this.chat(messages);
+  }
+
+  /**
+   * Check if LLM is available
+   * @returns {Promise<boolean>}
+   */
+  async isAvailable() {
+    try {
+      await this.chat([
+        { role: 'user', content: 'Hi' }
+      ], { maxTokens: 10 });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get model info
+   * @returns {Object} Model configuration
+   */
+  getConfig() {
+    return {
+      baseURL: config.llm.baseURL,
+      model: this.model,
+      temperature: this.temperature,
+      maxTokens: this.maxTokens,
+    };
+  }
+}
+
+module.exports = LLMClient;
diff --git a/ink-ai-assistant/src/main/main.js b/ink-ai-assistant/src/main/main.js
new file mode 100644
index 00000000..f7702df9
--- /dev/null
+++ b/ink-ai-assistant/src/main/main.js
@@ -0,0 +1,375 @@
+/**
+ * Main Process - Electron Entry Point
+ * Coordinates all backend services and IPC communication
+ */
+
+const { app, BrowserWindow, ipcMain, dialog } = require('electron');
+const path = require('path');
+const fs = require('fs');
+
+const config = require('../shared/config');
+const { IPC_CHANNELS } = require('../shared/types');
+const InkCompiler = require('./compiler');
+const ErrorParser = require('./errorParser');
+const LLMClient = require('./llmClient');
+const VectorStore = require('./vectorStore');
+const FileWatcher = require('./fileWatcher');
+
+class InkAIAssistant {
+  constructor() {
+    this.mainWindow = null;
+    this.compiler = new InkCompiler();
+    this.errorParser = new ErrorParser();
+    this.llm = new LLMClient();
+    this.vectorStore = new VectorStore();
+    this.fileWatcher = new FileWatcher();
+    this.conversationHistory = [];
+    this.currentFile = null;
+  }
+
+  /**
+   * Initialize the application
+   */
+  async init() {
+    await app.whenReady();
+    await this.createWindow();
+    this.setupIPC();
+    await this.checkDependencies();
+
+    // Set up file watcher callbacks
+    this.fileWatcher.watch([], {
+      onFileChange: (event, filepath) => {
+        this.sendToRenderer(IPC_CHANNELS.FILE_CHANGED, { event, filepath });
+      },
+      onCompilationComplete: (filepath, result) => {
+        this.handleCompilationResult(filepath, result);
+      },
+      onError: (error) => {
+        this.sendToRenderer(IPC_CHANNELS.COMPILE_ERROR, { error: error.message });
+      },
+    });
+  }
+
+  /**
+   * Create main window
+   */
+  async createWindow() {
+    this.mainWindow = new BrowserWindow({
+      width: config.ui.width,
+      height: config.ui.height,
+      minWidth: config.ui.minWidth,
+      minHeight: config.ui.minHeight,
+      webPreferences: {
+        nodeIntegration: false,
+        contextIsolation: true,
+        preload: path.join(__dirname, '../renderer/preload.js'),
+      },
+      title: 'Ink AI Assistant',
+      backgroundColor: '#1e1e1e',
+    });
+
+    await this.mainWindow.loadFile(path.join(__dirname, '../renderer/index.html'));
+
+    // Open DevTools in development
+    if (process.argv.includes('--dev')) {
+      this.mainWindow.webContents.openDevTools();
+    }
+  }
+
+  /**
+   * Set up IPC handlers
+   */
+  setupIPC() {
+    // File operations
+    ipcMain.handle(IPC_CHANNELS.OPEN_FILE, async () => {
+      return await this.openFile();
+    });
+
+    ipcMain.handle(IPC_CHANNELS.SAVE_FILE, async (event, { filepath, content }) => {
+      return await this.saveFile(filepath, content);
+    });
+
+    // Compilation
+    ipcMain.handle(IPC_CHANNELS.COMPILE, async (event, { filepath }) => {
+      return await this.compileFile(filepath);
+    });
+
+    // AI operations
+    ipcMain.handle(IPC_CHANNELS.SEND_MESSAGE, async (event, { message, context }) => {
+      return await this.handleChatMessage(message, context);
+    });
+
+    ipcMain.handle(IPC_CHANNELS.GENERATE_CODE, async (event, { prompt, context }) => {
+      return await this.generateCode(prompt, context);
+    });
+
+    ipcMain.handle(IPC_CHANNELS.FIX_ERROR, async (event, { code, errors }) => {
+      return await this.fixErrors(code, errors);
+    });
+
+    ipcMain.handle(IPC_CHANNELS.EXPLAIN_CODE, async (event, { query, code }) => {
+      return await this.explainCode(query, code);
+    });
+
+    // Documentation search
+    ipcMain.handle(IPC_CHANNELS.SEARCH_DOCS, async (event, { query }) => {
+      return await this.searchDocs(query);
+    });
+
+    // Configuration
+    ipcMain.handle(IPC_CHANNELS.GET_CONFIG, () => {
+      return {
+        llm: this.llm.getConfig(),
+        vectorStoreAvailable: this.vectorStore.isAvailable(),
+        inklecateAvailable: this.inklecateAvailable,
+      };
+    });
+  }
+
+  /**
+   * Check if dependencies are available
+   */
+  async checkDependencies() {
+    // Check inklecate
+    this.inklecateAvailable = await this.compiler.isAvailable();
+    if (!this.inklecateAvailable) {
+      dialog.showErrorBox(
+        'Inklecate Not Found',
+        'Could not find inklecate compiler. Please install Inky or set INKLECATE_PATH.'
+      );
+    }
+
+    // Check LLM
+    const llmAvailable = await this.llm.isAvailable();
+    if (!llmAvailable) {
+      dialog.showMessageBox(this.mainWindow, {
+        type: 'warning',
+        title: 'Local LLM Not Available',
+        message: 'Could not connect to local LLM. Make sure Ollama or another OpenAI-compatible server is running.',
+        buttons: ['OK'],
+      });
+    }
+
+    // Check vector store
+    if (!this.vectorStore.isAvailable()) {
+      console.log('Vector store not configured. RAG features will be limited.');
+    }
+  }
+
+  /**
+   * Open ink file dialog
+   */
+  async openFile() {
+    const result = await dialog.showOpenDialog(this.mainWindow, {
+      properties: ['openFile', 'openDirectory'],
+      filters: [
+        { name: 'Ink Files', extensions: ['ink'] },
+        { name: 'All Files', extensions: ['*'] },
+      ],
+    });
+
+    if (result.canceled || result.filePaths.length === 0) {
+      return null;
+    }
+
+    const filepath = result.filePaths[0];
+
+    // Check if it's a directory or file
+    const stats = fs.statSync(filepath);
+    if (stats.isDirectory()) {
+      // Watch directory
+      this.fileWatcher.addPath(filepath);
+      return { type: 'directory', path: filepath };
+    } else {
+      // Watch file
+      this.currentFile = filepath;
+      this.fileWatcher.addPath(filepath);
+
+      const content = fs.readFileSync(filepath, 'utf8');
+      return { type: 'file', path: filepath, content };
+    }
+  }
+
+  /**
+   * Save file
+   */
+  async saveFile(filepath, content) {
+    try {
+      fs.writeFileSync(filepath, content, 'utf8');
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Compile ink file
+   */
+  async compileFile(filepath) {
+    try {
+      const result = await this.compiler.validate(filepath);
+
+      // Enhance errors
+      if (result.errors.length > 0) {
+        result.errors = this.errorParser.enhanceErrors(result.errors);
+      }
+
+      return result;
+    } catch (error) {
+      return { success: false, error: error.message, errors: [] };
+    }
+  }
+
+  /**
+   * Handle compilation result from file watcher
+   */
+  handleCompilationResult(filepath, result) {
+    this.sendToRenderer(IPC_CHANNELS.COMPILE_RESULT, {
+      filepath,
+      result,
+    });
+
+    // Auto-notify about errors
+    if (!result.success && result.errors.length > 0) {
+      const summary = this.errorParser.summarizeForAI(result.errors);
+      this.sendToRenderer(IPC_CHANNELS.AI_RESPONSE, {
+        message: `🔍 Detected ${result.errors.length} error(s) in ${path.basename(filepath)}:\n\n${summary}\n\nWould you like me to suggest fixes?`,
+        auto: true,
+      });
+    }
+  }
+
+  /**
+   * Handle chat message
+   */
+  async handleChatMessage(message, context = {}) {
+    try {
+      // Add user message to history
+      this.conversationHistory.push({
+        role: 'user',
+        content: message,
+      });
+
+      // Search documentation for relevant context
+      let documentation = '';
+      if (this.vectorStore.isAvailable()) {
+        const docs = await this.vectorStore.search(message);
+        documentation = this.vectorStore.formatForContext(docs);
+      }
+
+      // Get AI response
+      const response = await this.llm.chatAboutInk(
+        this.conversationHistory,
+        documentation
+      );
+
+      // Add assistant response to history
+      this.conversationHistory.push({
+        role: 'assistant',
+        content: response,
+      });
+
+      return { success: true, response };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Generate ink code
+   */
+  async generateCode(prompt, context = '') {
+    try {
+      const code = await this.llm.generateInkCode(prompt, context);
+      return { success: true, code };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Fix errors with AI
+   */
+  async fixErrors(code, errors) {
+    try {
+      // Get relevant documentation
+      let documentation = '';
+      if (this.vectorStore.isAvailable()) {
+        const errorSummary = errors.map(e => e.message).join(' ');
+        const docs = await this.vectorStore.search(errorSummary);
+        documentation = this.vectorStore.formatForContext(docs);
+      }
+
+      const result = await this.llm.fixErrors(code, errors, documentation);
+      return { success: true, ...result };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Explain code or concept
+   */
+  async explainCode(query, code = '') {
+    try {
+      // Get relevant documentation
+      let documentation = '';
+      if (this.vectorStore.isAvailable()) {
+        const docs = await this.vectorStore.search(query);
+        documentation = this.vectorStore.formatForContext(docs);
+      }
+
+      const explanation = await this.llm.explain(query, code, documentation);
+      return { success: true, explanation };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Search documentation
+   */
+  async searchDocs(query) {
+    try {
+      if (!this.vectorStore.isAvailable()) {
+        return { success: false, error: 'Vector store not configured' };
+      }
+
+      const results = await this.vectorStore.search(query);
+      return { success: true, results };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Send message to renderer
+   */
+  sendToRenderer(channel, data) {
+    if (this.mainWindow && !this.mainWindow.isDestroyed()) {
+      this.mainWindow.webContents.send(channel, data);
+    }
+  }
+}
+
+// Create and initialize app
+const assistant = new InkAIAssistant();
+
+app.on('ready', () => assistant.init());
+
+app.on('window-all-closed', () => {
+  if (process.platform !== 'darwin') {
+    app.quit();
+  }
+});
+
+app.on('activate', () => {
+  if (BrowserWindow.getAllWindows().length === 0) {
+    assistant.createWindow();
+  }
+});
+
+// Cleanup on quit
+app.on('before-quit', async () => {
+  await assistant.fileWatcher.stop();
+});
diff --git a/ink-ai-assistant/src/main/vectorStore.js b/ink-ai-assistant/src/main/vectorStore.js
new file mode 100644
index 00000000..c712134c
--- /dev/null
+++ b/ink-ai-assistant/src/main/vectorStore.js
@@ -0,0 +1,252 @@
+/**
+ * Supabase Vector Store
+ * Manages documentation embeddings for RAG
+ */
+
+const { createClient } = require('@supabase/supabase-js');
+const OpenAI = require('openai');
+const config = require('../shared/config');
+
+class VectorStore {
+  constructor() {
+    // Initialize Supabase client
+    if (config.supabase.url && config.supabase.anonKey) {
+      this.supabase = createClient(
+        config.supabase.url,
+        config.supabase.anonKey
+      );
+    } else {
+      this.supabase = null;
+      console.warn('Supabase not configured. RAG features disabled.');
+    }
+
+    // Initialize embedding client (using local LLM for embeddings)
+    this.embeddingClient = new OpenAI({
+      baseURL: config.llm.baseURL,
+      apiKey: config.llm.apiKey,
+    });
+
+    this.tableName = config.supabase.tableName;
+    this.matchThreshold = config.supabase.matchThreshold;
+    this.matchCount = config.supabase.matchCount;
+  }
+
+  /**
+   * Check if vector store is available
+   * @returns {boolean}
+   */
+  isAvailable() {
+    return this.supabase !== null;
+  }
+
+  /**
+   * Generate embedding for text
+   * @param {string} text - Text to embed
+   * @returns {Promise<Array<number>>} Embedding vector
+   */
+  async generateEmbedding(text) {
+    try {
+      // Try local embedding model first (if available)
+      const response = await this.embeddingClient.embeddings.create({
+        model: 'nomic-embed-text', // Ollama embedding model
+        input: text,
+      });
+
+      return response.data[0].embedding;
+    } catch (error) {
+      // Fallback: Use simple TF-IDF or bag-of-words (less effective)
+      console.warn('Embedding generation failed, using fallback:', error.message);
+      return this.generateSimpleEmbedding(text);
+    }
+  }
+
+  /**
+   * Simple embedding fallback (bag-of-words hash)
+   * Not as good as real embeddings, but better than nothing
+   * @param {string} text - Text to embed
+   * @returns {Array<number>} Simple embedding
+   */
+  generateSimpleEmbedding(text) {
+    // Create a 384-dimensional vector (common embedding size)
+    const dims = 384;
+    const embedding = new Array(dims).fill(0);
+
+    // Hash words into embedding space
+    const words = text.toLowerCase().match(/\w+/g) || [];
+    for (const word of words) {
+      const hash = this.simpleHash(word) % dims;
+      embedding[hash] += 1;
+    }
+
+    // Normalize
+    const magnitude = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
+    return magnitude > 0 ? embedding.map(val => val / magnitude) : embedding;
+  }
+
+  /**
+   * Simple string hash
+   * @param {string} str - String to hash
+   * @returns {number} Hash value
+   */
+  simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = ((hash << 5) - hash) + char;
+      hash = hash & hash; // Convert to 32-bit integer
+    }
+    return Math.abs(hash);
+  }
+
+  /**
+   * Search for similar documents
+   * @param {string} query - Search query
+   * @param {number} limit - Number of results
+   * @returns {Promise<Array<DocumentChunk>>} Similar documents
+   */
+  async search(query, limit = null) {
+    if (!this.isAvailable()) {
+      return [];
+    }
+
+    try {
+      // Generate embedding for query
+      const queryEmbedding = await this.generateEmbedding(query);
+
+      // Search using Supabase RPC function
+      const { data, error } = await this.supabase.rpc('match_documents', {
+        query_embedding: queryEmbedding,
+        match_threshold: this.matchThreshold,
+        match_count: limit || this.matchCount,
+      });
+
+      if (error) {
+        console.error('Vector search error:', error);
+        return [];
+      }
+
+      return data || [];
+    } catch (error) {
+      console.error('Search failed:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Insert document chunk
+   * @param {string} content - Document content
+   * @param {Object} metadata - Document metadata
+   * @returns {Promise<boolean>} Success
+   */
+  async insertDocument(content, metadata = {}) {
+    if (!this.isAvailable()) {
+      return false;
+    }
+
+    try {
+      const embedding = await this.generateEmbedding(content);
+
+      const { error } = await this.supabase
+        .from(this.tableName)
+        .insert({
+          content,
+          metadata,
+          embedding,
+        });
+
+      if (error) {
+        console.error('Insert error:', error);
+        return false;
+      }
+
+      return true;
+    } catch (error) {
+      console.error('Insert failed:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Batch insert documents
+   * @param {Array<Object>} documents - Array of {content, metadata}
+   * @returns {Promise<number>} Number of documents inserted
+   */
+  async batchInsert(documents) {
+    if (!this.isAvailable()) {
+      return 0;
+    }
+
+    let inserted = 0;
+
+    for (const doc of documents) {
+      const success = await this.insertDocument(doc.content, doc.metadata);
+      if (success) inserted++;
+    }
+
+    return inserted;
+  }
+
+  /**
+   * Clear all documents
+   * @returns {Promise<boolean>} Success
+   */
+  async clearAll() {
+    if (!this.isAvailable()) {
+      return false;
+    }
+
+    try {
+      const { error } = await this.supabase
+        .from(this.tableName)
+        .delete()
+        .neq('id', 0); // Delete all
+
+      return !error;
+    } catch (error) {
+      console.error('Clear failed:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Get document count
+   * @returns {Promise<number>} Number of documents
+   */
+  async getCount() {
+    if (!this.isAvailable()) {
+      return 0;
+    }
+
+    try {
+      const { count, error } = await this.supabase
+        .from(this.tableName)
+        .select('*', { count: 'exact', head: true });
+
+      return error ? 0 : count;
+    } catch (error) {
+      return 0;
+    }
+  }
+
+  /**
+   * Format search results for LLM context
+   * @param {Array<DocumentChunk>} results - Search results
+   * @returns {string} Formatted documentation
+   */
+  formatForContext(results) {
+    if (results.length === 0) {
+      return '';
+    }
+
+    let context = 'Relevant ink documentation:\n\n';
+
+    for (const doc of results) {
+      const section = doc.metadata?.section || 'Documentation';
+      context += `## ${section}\n${doc.content}\n\n`;
+    }
+
+    return context.trim();
+  }
+}
+
+module.exports = VectorStore;
diff --git a/ink-ai-assistant/src/renderer/chat.js b/ink-ai-assistant/src/renderer/chat.js
new file mode 100644
index 00000000..f8a5bb4d
--- /dev/null
+++ b/ink-ai-assistant/src/renderer/chat.js
@@ -0,0 +1,412 @@
+/**
+ * Chat Interface - Renderer Process
+ * Handles UI interactions and communication with main process
+ */
+
+// DOM Elements
+const chatMessages = document.getElementById('chat-messages');
+const chatInput = document.getElementById('chat-input');
+const sendBtn = document.getElementById('send-btn');
+const openFileBtn = document.getElementById('openFileBtn');
+const currentFileEl = document.getElementById('current-file');
+const compilationStatusEl = document.getElementById('compilation-status');
+const errorsListEl = document.getElementById('errors-list');
+const statusIndicator = document.getElementById('status-indicator');
+const statusText = document.getElementById('status-text');
+
+// State
+let currentFile = null;
+let currentErrors = [];
+let isProcessing = false;
+
+// Initialize
+document.addEventListener('DOMContentLoaded', async () => {
+  setupEventListeners();
+  await checkConfig();
+});
+
+/**
+ * Set up event listeners
+ */
+function setupEventListeners() {
+  // Send message
+  sendBtn.addEventListener('click', sendMessage);
+  chatInput.addEventListener('keydown', (e) => {
+    if (e.key === 'Enter' && !e.shiftKey) {
+      e.preventDefault();
+      sendMessage();
+    }
+  });
+
+  // Auto-resize textarea
+  chatInput.addEventListener('input', () => {
+    chatInput.style.height = 'auto';
+    chatInput.style.height = chatInput.scrollHeight + 'px';
+  });
+
+  // Open file
+  openFileBtn.addEventListener('click', openFile);
+
+  // Quick actions
+  document.querySelectorAll('.quick-action-btn').forEach(btn => {
+    btn.addEventListener('click', () => {
+      const action = btn.dataset.action;
+      handleQuickAction(action);
+    });
+  });
+
+  // Listen for events from main process
+  window.electronAPI.onFileChanged((data) => {
+    updateStatus(`File ${data.event}: ${data.filepath}`);
+  });
+
+  window.electronAPI.onCompileResult((data) => {
+    handleCompilationResult(data);
+  });
+
+  window.electronAPI.onAIResponse((data) => {
+    if (data.auto) {
+      addMessage(data.message, 'assistant');
+    }
+  });
+}
+
+/**
+ * Check configuration and display status
+ */
+async function checkConfig() {
+  const config = await window.electronAPI.getConfig();
+
+  if (!config.inklecateAvailable) {
+    addMessage('⚠️ Warning: inklecate compiler not found. Please install Inky or set INKLECATE_PATH.', 'error');
+  }
+
+  if (!config.vectorStoreAvailable) {
+    addMessage('ℹ️ Note: Vector storage not configured. Documentation search will be limited. Set SUPABASE_URL and SUPABASE_ANON_KEY for full RAG features.', 'assistant');
+  }
+}
+
+/**
+ * Open file dialog
+ */
+async function openFile() {
+  const result = await window.electronAPI.openFile();
+
+  if (!result) return;
+
+  if (result.type === 'file') {
+    currentFile = result.path;
+    updateCurrentFile(result.path);
+    addMessage(`📄 Opened file: ${result.path.split('/').pop()}`, 'assistant');
+  } else if (result.type === 'directory') {
+    addMessage(`📁 Watching directory: ${result.path}`, 'assistant');
+  }
+}
+
+/**
+ * Send chat message
+ */
+async function sendMessage() {
+  const message = chatInput.value.trim();
+  if (!message || isProcessing) return;
+
+  // Add user message
+  addMessage(message, 'user');
+  chatInput.value = '';
+  chatInput.style.height = 'auto';
+
+  // Show loading
+  isProcessing = true;
+  const loadingId = showLoading();
+  setStatus('processing');
+
+  try {
+    const response = await window.electronAPI.sendMessage(message, {
+      currentFile,
+      errors: currentErrors,
+    });
+
+    if (response.success) {
+      addMessage(response.response, 'assistant');
+    } else {
+      addMessage(`Error: ${response.error}`, 'error');
+    }
+  } catch (error) {
+    addMessage(`Error: ${error.message}`, 'error');
+  } finally {
+    removeLoading(loadingId);
+    isProcessing = false;
+    setStatus('ready');
+  }
+}
+
+/**
+ * Handle quick actions
+ */
+async function handleQuickAction(action) {
+  if (isProcessing) return;
+
+  switch (action) {
+    case 'fix':
+      if (currentErrors.length === 0) {
+        addMessage('No errors to fix!', 'assistant');
+        return;
+      }
+      await fixErrors();
+      break;
+
+    case 'explain':
+      chatInput.value = 'Explain this: ';
+      chatInput.focus();
+      break;
+
+    case 'generate':
+      chatInput.value = 'Generate ink code for: ';
+      chatInput.focus();
+      break;
+  }
+}
+
+/**
+ * Fix errors with AI
+ */
+async function fixErrors() {
+  if (!currentFile) {
+    addMessage('No file opened!', 'error');
+    return;
+  }
+
+  isProcessing = true;
+  const loadingId = showLoading();
+  setStatus('fixing');
+
+  try {
+    // Read current file content (simplified - in real app would read from editor)
+    const fs = require('fs');
+    const code = fs.readFileSync(currentFile, 'utf8');
+
+    const response = await window.electronAPI.fixError(code, currentErrors);
+
+    if (response.success) {
+      addMessage('🔧 **Suggested Fixes:**\n\n' + response.explanation, 'assistant');
+    } else {
+      addMessage(`Error: ${response.error}`, 'error');
+    }
+  } catch (error) {
+    addMessage(`Error: ${error.message}`, 'error');
+  } finally {
+    removeLoading(loadingId);
+    isProcessing = false;
+    setStatus('ready');
+  }
+}
+
+/**
+ * Handle compilation result
+ */
+function handleCompilationResult(data) {
+  const { filepath, result } = data;
+
+  // Update compilation status
+  if (result.success) {
+    compilationStatusEl.innerHTML = `
+      <div style="color: var(--accent-green);">
+        ✓ Compiled successfully
+        <div style="font-size: 0.75rem; margin-top: 0.25rem; color: var(--text-secondary);">
+          ${result.duration}ms
+        </div>
+      </div>
+    `;
+    currentErrors = [];
+    errorsListEl.innerHTML = '<p class="no-errors">No errors ✓</p>';
+  } else {
+    compilationStatusEl.innerHTML = `
+      <div style="color: var(--accent-red);">
+        ✗ ${result.errors.length} error(s)
+        <div style="font-size: 0.75rem; margin-top: 0.25rem; color: var(--text-secondary);">
+          ${result.duration}ms
+        </div>
+      </div>
+    `;
+    currentErrors = result.errors;
+    displayErrors(result.errors);
+  }
+}
+
+/**
+ * Display errors in sidebar
+ */
+function displayErrors(errors) {
+  if (errors.length === 0) {
+    errorsListEl.innerHTML = '<p class="no-errors">No errors ✓</p>';
+    return;
+  }
+
+  errorsListEl.innerHTML = errors.map(error => `
+    <div class="error-item ${error.type.toLowerCase()}">
+      <div class="error-header">
+        ${getErrorIcon(error.type)}
+        ${error.type}
+      </div>
+      <div class="error-line">Line ${error.line}</div>
+      <div class="error-message">${escapeHtml(error.message)}</div>
+    </div>
+  `).join('');
+}
+
+/**
+ * Get error icon
+ */
+function getErrorIcon(type) {
+  const icons = {
+    ERROR: '🔴',
+    WARNING: '⚠️',
+    TODO: '📝',
+    AUTHOR: '✍️',
+  };
+  return icons[type] || '•';
+}
+
+/**
+ * Update current file display
+ */
+function updateCurrentFile(filepath) {
+  const filename = filepath.split('/').pop();
+  currentFileEl.innerHTML = `
+    <div style="font-weight: 600;">${escapeHtml(filename)}</div>
+    <div style="font-size: 0.75rem; color: var(--text-secondary); margin-top: 0.25rem;">
+      ${escapeHtml(filepath)}
+    </div>
+  `;
+}
+
+/**
+ * Add message to chat
+ */
+function addMessage(content, type = 'assistant') {
+  const messageDiv = document.createElement('div');
+  messageDiv.className = `message ${type}`;
+
+  const contentDiv = document.createElement('div');
+  contentDiv.className = 'message-content';
+
+  // Simple markdown-like formatting
+  const formatted = formatMessage(content);
+  contentDiv.innerHTML = formatted;
+
+  messageDiv.appendChild(contentDiv);
+  chatMessages.appendChild(messageDiv);
+
+  // Scroll to bottom
+  chatMessages.scrollTop = chatMessages.scrollHeight;
+}
+
+/**
+ * Format message with basic markdown
+ */
+function formatMessage(text) {
+  // Code blocks
+  text = text.replace(/```(\w+)?\n([\s\S]*?)\n```/g, (match, lang, code) => {
+    return `<pre><code>${escapeHtml(code)}</code></pre>`;
+  });
+
+  // Inline code
+  text = text.replace(/`([^`]+)`/g, '<code>$1</code>');
+
+  // Bold
+  text = text.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>');
+
+  // Links (simple)
+  text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2" target="_blank">$1</a>');
+
+  // Paragraphs
+  text = text.split('\n\n').map(p => {
+    if (p.startsWith('<pre>') || p.startsWith('<ul>') || p.startsWith('<ol>')) {
+      return p;
+    }
+    return `<p>${p.replace(/\n/g, '<br>')}</p>`;
+  }).join('');
+
+  return text;
+}
+
+/**
+ * Show loading indicator
+ */
+function showLoading() {
+  const loadingDiv = document.createElement('div');
+  loadingDiv.className = 'message assistant';
+  loadingDiv.id = `loading-${Date.now()}`;
+
+  const contentDiv = document.createElement('div');
+  contentDiv.className = 'message-content';
+  contentDiv.innerHTML = `
+    <div class="loading">
+      <div class="loading-dot"></div>
+      <div class="loading-dot"></div>
+      <div class="loading-dot"></div>
+    </div>
+  `;
+
+  loadingDiv.appendChild(contentDiv);
+  chatMessages.appendChild(loadingDiv);
+  chatMessages.scrollTop = chatMessages.scrollHeight;
+
+  return loadingDiv.id;
+}
+
+/**
+ * Remove loading indicator
+ */
+function removeLoading(id) {
+  const loadingEl = document.getElementById(id);
+  if (loadingEl) {
+    loadingEl.remove();
+  }
+}
+
+/**
+ * Update status indicator
+ */
+function updateStatus(message) {
+  statusText.textContent = message;
+}
+
+/**
+ * Set status indicator
+ */
+function setStatus(status) {
+  const statusMap = {
+    ready: { color: 'var(--accent-green)', text: 'Ready' },
+    processing: { color: 'var(--accent-blue)', text: 'Processing...' },
+    fixing: { color: 'var(--accent-yellow)', text: 'Fixing errors...' },
+    error: { color: 'var(--accent-red)', text: 'Error' },
+  };
+
+  const config = statusMap[status] || statusMap.ready;
+  statusIndicator.style.background = config.color;
+  statusText.textContent = config.text;
+}
+
+/**
+ * Escape HTML
+ */
+function escapeHtml(text) {
+  const div = document.createElement('div');
+  div.textContent = text;
+  return div.innerHTML;
+}
+
+/**
+ * Show toast notification
+ */
+function showToast(message, type = 'success') {
+  const toast = document.createElement('div');
+  toast.className = `toast ${type}`;
+  toast.textContent = message;
+  document.body.appendChild(toast);
+
+  setTimeout(() => {
+    toast.remove();
+  }, 3000);
+}
diff --git a/ink-ai-assistant/src/renderer/index.html b/ink-ai-assistant/src/renderer/index.html
new file mode 100644
index 00000000..a394600f
--- /dev/null
+++ b/ink-ai-assistant/src/renderer/index.html
@@ -0,0 +1,93 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta http-equiv="Content-Security-Policy" content="default-src 'self'; style-src 'self' 'unsafe-inline';">
+  <title>Ink AI Assistant</title>
+  <link rel="stylesheet" href="styles.css">
+</head>
+<body>
+  <div class="container">
+    <!-- Header -->
+    <header class="header">
+      <h1 class="title">
+        <span class="icon">✨</span>
+        Ink AI Assistant
+      </h1>
+      <div class="header-actions">
+        <button id="openFileBtn" class="btn btn-primary">Open Ink File</button>
+        <div class="status">
+          <span id="status-indicator" class="status-dot"></span>
+          <span id="status-text">Ready</span>
+        </div>
+      </div>
+    </header>
+
+    <!-- Main Content -->
+    <div class="main-content">
+      <!-- Sidebar (File Info & Errors) -->
+      <aside class="sidebar">
+        <div class="sidebar-section">
+          <h3>Current File</h3>
+          <div id="current-file" class="file-info">
+            <p class="no-file">No file opened</p>
+          </div>
+        </div>
+
+        <div class="sidebar-section">
+          <h3>Compilation Status</h3>
+          <div id="compilation-status" class="compilation-status">
+            <p class="no-status">No compilation yet</p>
+          </div>
+        </div>
+
+        <div class="sidebar-section errors-section">
+          <h3>Errors & Warnings</h3>
+          <div id="errors-list" class="errors-list">
+            <p class="no-errors">No errors</p>
+          </div>
+        </div>
+      </aside>
+
+      <!-- Chat Area -->
+      <main class="chat-area">
+        <div id="chat-messages" class="chat-messages">
+          <div class="message assistant">
+            <div class="message-content">
+              <p><strong>Welcome to Ink AI Assistant!</strong></p>
+              <p>I can help you:</p>
+              <ul>
+                <li>Generate ink code from descriptions</li>
+                <li>Fix compilation errors</li>
+                <li>Explain ink syntax and concepts</li>
+                <li>Answer questions about ink</li>
+              </ul>
+              <p>Open an ink file to get started, or just ask me anything!</p>
+            </div>
+          </div>
+        </div>
+
+        <div class="chat-input-container">
+          <div class="quick-actions">
+            <button class="quick-action-btn" data-action="fix">🔧 Fix Errors</button>
+            <button class="quick-action-btn" data-action="explain">💡 Explain</button>
+            <button class="quick-action-btn" data-action="generate">✨ Generate Code</button>
+          </div>
+          <div class="input-wrapper">
+            <textarea
+              id="chat-input"
+              class="chat-input"
+              placeholder="Ask me anything about ink..."
+              rows="1"
+            ></textarea>
+            <button id="send-btn" class="btn btn-send">Send</button>
+          </div>
+        </div>
+      </main>
+    </div>
+  </div>
+
+  <script src="chat.js"></script>
+</body>
+</html>
diff --git a/ink-ai-assistant/src/renderer/preload.js b/ink-ai-assistant/src/renderer/preload.js
new file mode 100644
index 00000000..1ac005ae
--- /dev/null
+++ b/ink-ai-assistant/src/renderer/preload.js
@@ -0,0 +1,43 @@
+/**
+ * Preload Script
+ * Safely exposes IPC communication to renderer process
+ */
+
+const { contextBridge, ipcRenderer } = require('electron');
+const { IPC_CHANNELS } = require('../shared/types');
+
+// Expose protected methods that allow the renderer process to use
+// ipcRenderer without exposing the entire object
+contextBridge.exposeInMainWorld('electronAPI', {
+  // File operations
+  openFile: () => ipcRenderer.invoke(IPC_CHANNELS.OPEN_FILE),
+  saveFile: (filepath, content) =>
+    ipcRenderer.invoke(IPC_CHANNELS.SAVE_FILE, { filepath, content }),
+
+  // Compilation
+  compile: (filepath) => ipcRenderer.invoke(IPC_CHANNELS.COMPILE, { filepath }),
+
+  // AI operations
+  sendMessage: (message, context) =>
+    ipcRenderer.invoke(IPC_CHANNELS.SEND_MESSAGE, { message, context }),
+  generateCode: (prompt, context) =>
+    ipcRenderer.invoke(IPC_CHANNELS.GENERATE_CODE, { prompt, context }),
+  fixError: (code, errors) =>
+    ipcRenderer.invoke(IPC_CHANNELS.FIX_ERROR, { code, errors }),
+  explainCode: (query, code) =>
+    ipcRenderer.invoke(IPC_CHANNELS.EXPLAIN_CODE, { query, code }),
+
+  // Documentation
+  searchDocs: (query) => ipcRenderer.invoke(IPC_CHANNELS.SEARCH_DOCS, { query }),
+
+  // Configuration
+  getConfig: () => ipcRenderer.invoke(IPC_CHANNELS.GET_CONFIG),
+
+  // Listeners
+  onFileChanged: (callback) =>
+    ipcRenderer.on(IPC_CHANNELS.FILE_CHANGED, (event, data) => callback(data)),
+  onCompileResult: (callback) =>
+    ipcRenderer.on(IPC_CHANNELS.COMPILE_RESULT, (event, data) => callback(data)),
+  onAIResponse: (callback) =>
+    ipcRenderer.on(IPC_CHANNELS.AI_RESPONSE, (event, data) => callback(data)),
+});
diff --git a/ink-ai-assistant/src/renderer/styles.css b/ink-ai-assistant/src/renderer/styles.css
new file mode 100644
index 00000000..d4a79804
--- /dev/null
+++ b/ink-ai-assistant/src/renderer/styles.css
@@ -0,0 +1,448 @@
+/**
+ * Ink AI Assistant - Styles
+ * Dark theme matching Inky's aesthetic
+ */
+
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+:root {
+  --bg-primary: #1e1e1e;
+  --bg-secondary: #252525;
+  --bg-tertiary: #2d2d2d;
+  --bg-hover: #333333;
+
+  --text-primary: #d4d4d4;
+  --text-secondary: #9d9d9d;
+  --text-accent: #4ec9b0;
+
+  --border-color: #3e3e3e;
+
+  --accent-blue: #007acc;
+  --accent-green: #4ec9b0;
+  --accent-red: #f44747;
+  --accent-yellow: #dcdcaa;
+
+  --error-bg: #5a1d1d;
+  --warning-bg: #5a5a1d;
+  --success-bg: #1d5a1d;
+
+  --shadow: 0 2px 8px rgba(0, 0, 0, 0.3);
+
+  --font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+  --font-mono: 'Courier New', Courier, monospace;
+}
+
+body {
+  font-family: var(--font-family);
+  background: var(--bg-primary);
+  color: var(--text-primary);
+  height: 100vh;
+  overflow: hidden;
+}
+
+.container {
+  display: flex;
+  flex-direction: column;
+  height: 100vh;
+}
+
+/* Header */
+.header {
+  background: var(--bg-secondary);
+  border-bottom: 1px solid var(--border-color);
+  padding: 1rem 1.5rem;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.title {
+  font-size: 1.25rem;
+  font-weight: 600;
+  color: var(--text-accent);
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+
+.icon {
+  font-size: 1.5rem;
+}
+
+.header-actions {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+}
+
+.status {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  font-size: 0.875rem;
+  color: var(--text-secondary);
+}
+
+.status-dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  background: var(--accent-green);
+  animation: pulse 2s ease-in-out infinite;
+}
+
+@keyframes pulse {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.5; }
+}
+
+/* Main Content */
+.main-content {
+  display: flex;
+  flex: 1;
+  overflow: hidden;
+}
+
+/* Sidebar */
+.sidebar {
+  width: 300px;
+  background: var(--bg-secondary);
+  border-right: 1px solid var(--border-color);
+  overflow-y: auto;
+  flex-shrink: 0;
+}
+
+.sidebar-section {
+  padding: 1rem;
+  border-bottom: 1px solid var(--border-color);
+}
+
+.sidebar-section h3 {
+  font-size: 0.875rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  color: var(--text-secondary);
+  margin-bottom: 0.75rem;
+}
+
+.file-info, .compilation-status, .errors-list {
+  font-size: 0.875rem;
+}
+
+.no-file, .no-status, .no-errors {
+  color: var(--text-secondary);
+  font-style: italic;
+}
+
+.error-item {
+  background: var(--bg-tertiary);
+  padding: 0.75rem;
+  margin-bottom: 0.5rem;
+  border-radius: 4px;
+  border-left: 3px solid var(--accent-red);
+  cursor: pointer;
+  transition: background 0.2s;
+}
+
+.error-item:hover {
+  background: var(--bg-hover);
+}
+
+.error-item.warning {
+  border-left-color: var(--accent-yellow);
+}
+
+.error-header {
+  font-weight: 600;
+  margin-bottom: 0.25rem;
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+
+.error-line {
+  font-size: 0.75rem;
+  color: var(--text-secondary);
+}
+
+.error-message {
+  margin-top: 0.5rem;
+  font-size: 0.875rem;
+  color: var(--text-primary);
+}
+
+/* Chat Area */
+.chat-area {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+}
+
+.chat-messages {
+  flex: 1;
+  overflow-y: auto;
+  padding: 1.5rem;
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+
+.message {
+  max-width: 80%;
+  animation: slideIn 0.2s ease-out;
+}
+
+@keyframes slideIn {
+  from {
+    opacity: 0;
+    transform: translateY(10px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.message.user {
+  align-self: flex-end;
+}
+
+.message.assistant {
+  align-self: flex-start;
+}
+
+.message-content {
+  background: var(--bg-secondary);
+  padding: 1rem;
+  border-radius: 8px;
+  box-shadow: var(--shadow);
+}
+
+.message.user .message-content {
+  background: var(--accent-blue);
+  color: white;
+}
+
+.message-content p {
+  margin-bottom: 0.75rem;
+}
+
+.message-content p:last-child {
+  margin-bottom: 0;
+}
+
+.message-content ul, .message-content ol {
+  margin-left: 1.5rem;
+  margin-bottom: 0.75rem;
+}
+
+.message-content li {
+  margin-bottom: 0.25rem;
+}
+
+.message-content code {
+  background: var(--bg-tertiary);
+  padding: 0.125rem 0.25rem;
+  border-radius: 3px;
+  font-family: var(--font-mono);
+  font-size: 0.875rem;
+}
+
+.message-content pre {
+  background: var(--bg-primary);
+  padding: 1rem;
+  border-radius: 4px;
+  overflow-x: auto;
+  margin: 0.75rem 0;
+}
+
+.message-content pre code {
+  background: none;
+  padding: 0;
+}
+
+.message.assistant .message-content {
+  border-left: 3px solid var(--accent-green);
+}
+
+.message.error .message-content {
+  background: var(--error-bg);
+  border-left: 3px solid var(--accent-red);
+}
+
+/* Chat Input */
+.chat-input-container {
+  border-top: 1px solid var(--border-color);
+  background: var(--bg-secondary);
+  padding: 1rem 1.5rem;
+}
+
+.quick-actions {
+  display: flex;
+  gap: 0.5rem;
+  margin-bottom: 0.75rem;
+}
+
+.quick-action-btn {
+  background: var(--bg-tertiary);
+  border: 1px solid var(--border-color);
+  color: var(--text-primary);
+  padding: 0.5rem 0.75rem;
+  border-radius: 4px;
+  font-size: 0.875rem;
+  cursor: pointer;
+  transition: all 0.2s;
+}
+
+.quick-action-btn:hover {
+  background: var(--bg-hover);
+  border-color: var(--accent-blue);
+}
+
+.input-wrapper {
+  display: flex;
+  gap: 0.75rem;
+}
+
+.chat-input {
+  flex: 1;
+  background: var(--bg-tertiary);
+  border: 1px solid var(--border-color);
+  color: var(--text-primary);
+  padding: 0.75rem;
+  border-radius: 4px;
+  font-family: var(--font-family);
+  font-size: 0.875rem;
+  resize: none;
+  min-height: 40px;
+  max-height: 120px;
+  transition: border-color 0.2s;
+}
+
+.chat-input:focus {
+  outline: none;
+  border-color: var(--accent-blue);
+}
+
+/* Buttons */
+.btn {
+  background: var(--accent-blue);
+  color: white;
+  border: none;
+  padding: 0.5rem 1rem;
+  border-radius: 4px;
+  font-size: 0.875rem;
+  font-weight: 500;
+  cursor: pointer;
+  transition: all 0.2s;
+}
+
+.btn:hover {
+  background: #006bb3;
+}
+
+.btn:active {
+  transform: scale(0.98);
+}
+
+.btn-primary {
+  background: var(--accent-green);
+}
+
+.btn-primary:hover {
+  background: #3fa88a;
+}
+
+.btn-send {
+  padding: 0.75rem 1.5rem;
+}
+
+.btn:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+/* Loading indicator */
+.loading {
+  display: flex;
+  gap: 0.25rem;
+  padding: 0.5rem 0;
+}
+
+.loading-dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  background: var(--text-secondary);
+  animation: bounce 1.4s ease-in-out infinite;
+}
+
+.loading-dot:nth-child(2) {
+  animation-delay: 0.2s;
+}
+
+.loading-dot:nth-child(3) {
+  animation-delay: 0.4s;
+}
+
+@keyframes bounce {
+  0%, 60%, 100% {
+    transform: translateY(0);
+  }
+  30% {
+    transform: translateY(-10px);
+  }
+}
+
+/* Scrollbar */
+::-webkit-scrollbar {
+  width: 8px;
+  height: 8px;
+}
+
+::-webkit-scrollbar-track {
+  background: var(--bg-primary);
+}
+
+::-webkit-scrollbar-thumb {
+  background: var(--bg-tertiary);
+  border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: var(--bg-hover);
+}
+
+/* Success/error messages */
+.toast {
+  position: fixed;
+  bottom: 2rem;
+  right: 2rem;
+  background: var(--bg-secondary);
+  padding: 1rem 1.5rem;
+  border-radius: 4px;
+  box-shadow: var(--shadow);
+  border-left: 3px solid var(--accent-green);
+  animation: slideInRight 0.3s ease-out;
+  z-index: 1000;
+}
+
+.toast.error {
+  border-left-color: var(--accent-red);
+}
+
+@keyframes slideInRight {
+  from {
+    opacity: 0;
+    transform: translateX(100px);
+  }
+  to {
+    opacity: 1;
+    transform: translateX(0);
+  }
+}
diff --git a/ink-ai-assistant/src/shared/config.js b/ink-ai-assistant/src/shared/config.js
new file mode 100644
index 00000000..1adae2ad
--- /dev/null
+++ b/ink-ai-assistant/src/shared/config.js
@@ -0,0 +1,101 @@
+/**
+ * Configuration for Ink AI Assistant
+ * Modify these values to match your setup
+ */
+
+module.exports = {
+  // Local LLM configuration (OpenAI-compatible API)
+  llm: {
+    // Default to Ollama endpoint
+    baseURL: process.env.LLM_BASE_URL || 'http://localhost:11434/v1',
+    apiKey: process.env.LLM_API_KEY || 'ollama', // Ollama doesn't need real key
+    model: process.env.LLM_MODEL || 'llama3.1', // or 'codellama', 'mistral', etc.
+    temperature: 0.2, // Lower for more consistent code generation
+    maxTokens: 4000,
+  },
+
+  // Supabase configuration for vector storage
+  supabase: {
+    url: process.env.SUPABASE_URL || '',
+    anonKey: process.env.SUPABASE_ANON_KEY || '',
+    tableName: 'ink_documentation',
+    matchThreshold: 0.78, // Similarity threshold for vector search
+    matchCount: 5, // Number of relevant docs to retrieve
+  },
+
+  // Inklecate compiler configuration
+  inklecate: {
+    // Auto-detect platform
+    binary: getInklecatePath(),
+    timeout: 10000, // 10 seconds
+  },
+
+  // File watching configuration
+  fileWatcher: {
+    ignored: /(^|[\/\\])\../, // Ignore dotfiles
+    persistent: true,
+    ignoreInitial: false,
+    awaitWriteFinish: {
+      stabilityThreshold: 500,
+      pollInterval: 100,
+    },
+  },
+
+  // UI configuration
+  ui: {
+    theme: 'dark',
+    width: 900,
+    height: 700,
+    minWidth: 600,
+    minHeight: 400,
+  },
+};
+
+/**
+ * Get platform-specific inklecate binary path
+ * Tries to use Inky's bundled version first
+ */
+function getInklecatePath() {
+  const path = require('path');
+  const os = require('os');
+  const fs = require('fs');
+
+  const platform = os.platform();
+  let binaryName;
+
+  if (platform === 'darwin') {
+    binaryName = 'inklecate_mac';
+  } else if (platform === 'win32') {
+    binaryName = 'inklecate_win.exe';
+  } else if (platform === 'linux') {
+    binaryName = 'inklecate_linux';
+  } else {
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+
+  // Try to find Inky's bundled inklecate
+  const possiblePaths = [
+    // Inky installed alongside (sibling directory)
+    path.join(__dirname, '../../../inky_digi/app/main-process/ink', binaryName),
+    // User's home directory Inky installation (common locations)
+    path.join(os.homedir(), 'inky_digi/app/main-process/ink', binaryName),
+    path.join(os.homedir(), 'Inky/app/main-process/ink', binaryName),
+    // Custom path from environment variable
+    process.env.INKLECATE_PATH,
+    // User might have inklecate in PATH
+    binaryName,
+  ].filter(Boolean);
+
+  for (const binPath of possiblePaths) {
+    try {
+      if (fs.existsSync(binPath)) {
+        return binPath;
+      }
+    } catch (e) {
+      // Continue checking
+    }
+  }
+
+  // Fallback to expecting it in PATH
+  return binaryName;
+}
diff --git a/ink-ai-assistant/src/shared/types.js b/ink-ai-assistant/src/shared/types.js
new file mode 100644
index 00000000..4bb11c7a
--- /dev/null
+++ b/ink-ai-assistant/src/shared/types.js
@@ -0,0 +1,110 @@
+/**
+ * Shared types and constants for Ink AI Assistant
+ */
+
+// IPC channels for main <-> renderer communication
+const IPC_CHANNELS = {
+  // File operations
+  OPEN_FILE: 'open-file',
+  FILE_OPENED: 'file-opened',
+  FILE_CHANGED: 'file-changed',
+  SAVE_FILE: 'save-file',
+
+  // Compilation
+  COMPILE: 'compile',
+  COMPILE_RESULT: 'compile-result',
+  COMPILE_ERROR: 'compile-error',
+
+  // AI operations
+  SEND_MESSAGE: 'send-message',
+  AI_RESPONSE: 'ai-response',
+  AI_ERROR: 'ai-error',
+  AI_STREAMING: 'ai-streaming',
+
+  // Code generation
+  GENERATE_CODE: 'generate-code',
+  FIX_ERROR: 'fix-error',
+  EXPLAIN_CODE: 'explain-code',
+
+  // Configuration
+  GET_CONFIG: 'get-config',
+  SET_CONFIG: 'set-config',
+  CONFIG_UPDATED: 'config-updated',
+
+  // Documentation search
+  SEARCH_DOCS: 'search-docs',
+  DOCS_RESULT: 'docs-result',
+};
+
+// Error types from inklecate
+const ERROR_TYPES = {
+  ERROR: 'ERROR',
+  WARNING: 'WARNING',
+  TODO: 'TODO',
+  AUTHOR: 'AUTHOR',
+};
+
+// Message roles for chat
+const MESSAGE_ROLES = {
+  USER: 'user',
+  ASSISTANT: 'assistant',
+  SYSTEM: 'system',
+};
+
+// AI operation types
+const AI_OPERATIONS = {
+  CHAT: 'chat',
+  GENERATE: 'generate',
+  FIX: 'fix',
+  EXPLAIN: 'explain',
+  REFACTOR: 'refactor',
+};
+
+/**
+ * @typedef {Object} InkError
+ * @property {string} type - ERROR, WARNING, TODO, or AUTHOR
+ * @property {string} message - Error message
+ * @property {string} filename - File where error occurred
+ * @property {number} line - Line number (1-indexed)
+ * @property {number} column - Column number (1-indexed)
+ * @property {string} context - Surrounding code context
+ */
+
+/**
+ * @typedef {Object} CompilationResult
+ * @property {boolean} success - Whether compilation succeeded
+ * @property {InkError[]} errors - Array of errors/warnings
+ * @property {string} [output] - JSON output if successful
+ * @property {number} duration - Compilation time in ms
+ */
+
+/**
+ * @typedef {Object} ChatMessage
+ * @property {string} role - user, assistant, or system
+ * @property {string} content - Message content
+ * @property {number} timestamp - Unix timestamp
+ * @property {Object} [metadata] - Additional metadata
+ */
+
+/**
+ * @typedef {Object} DocumentChunk
+ * @property {string} content - Documentation content
+ * @property {Object} metadata - Metadata (section, title, etc.)
+ * @property {number} similarity - Similarity score (0-1)
+ */
+
+/**
+ * @typedef {Object} AIRequest
+ * @property {string} operation - Type of AI operation
+ * @property {string} prompt - User prompt
+ * @property {string} [code] - Current code context
+ * @property {InkError[]} [errors] - Errors to fix
+ * @property {DocumentChunk[]} [context] - Retrieved documentation
+ */
+
+module.exports = {
+  IPC_CHANNELS,
+  ERROR_TYPES,
+  MESSAGE_ROLES,
+  AI_OPERATIONS,
+};
diff --git a/ink-ai-assistant/supabase-setup.sql b/ink-ai-assistant/supabase-setup.sql
new file mode 100644
index 00000000..87b0af4a
--- /dev/null
+++ b/ink-ai-assistant/supabase-setup.sql
@@ -0,0 +1,54 @@
+-- Supabase Setup for Ink AI Assistant
+-- Run this in your Supabase SQL editor
+
+-- Enable pgvector extension
+create extension if not exists vector;
+
+-- Create documentation table
+create table if not exists ink_documentation (
+  id bigserial primary key,
+  content text not null,
+  metadata jsonb,
+  embedding vector(384), -- Adjust dimension based on your embedding model
+  created_at timestamp with time zone default timezone('utc'::text, now())
+);
+
+-- Create index for faster vector search
+create index on ink_documentation using ivfflat (embedding vector_cosine_ops)
+  with (lists = 100);
+
+-- Create function for similarity search
+create or replace function match_documents (
+  query_embedding vector(384),
+  match_threshold float default 0.78,
+  match_count int default 5
+)
+returns table (
+  id bigint,
+  content text,
+  metadata jsonb,
+  similarity float
+)
+language sql stable
+as $$
+  select
+    ink_documentation.id,
+    ink_documentation.content,
+    ink_documentation.metadata,
+    1 - (ink_documentation.embedding <=> query_embedding) as similarity
+  from ink_documentation
+  where 1 - (ink_documentation.embedding <=> query_embedding) > match_threshold
+  order by ink_documentation.embedding <=> query_embedding
+  limit match_count;
+$$;
+
+-- Grant permissions (adjust for your auth setup)
+-- For public access (development only):
+-- grant usage on schema public to anon;
+-- grant select on ink_documentation to anon;
+-- grant execute on function match_documents to anon;
+
+-- For authenticated users:
+-- grant usage on schema public to authenticated;
+-- grant all on ink_documentation to authenticated;
+-- grant execute on function match_documents to authenticated;