underrow 2026.4.1

package/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(node:*)",
+      "Bash(npm link:*)",
+      "Bash(knowme --help)"
+    ]
+  }
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matt Currier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# KB
+KnowledgeBase driver
+
+* When running it watches for file changes in it's directory
+* When a file changes it chunks amd vector embeds it in FAISS and stores metadata
+  * Information Density = gzip-size / orig_size
+* Provides a sumple server that
+  * gives a vector search API
+  * gives fuzzy text search API
+  * host a web dashboard
+in

package/index.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+import { resolve } from 'path'
+import { startWatcher } from './src/watcher.js'
+import { createServer } from './src/server.js'
+import { Store } from './src/store.js'
+import { initEmbedder } from './src/embedder.js'
+
+const args = process.argv.slice(2)
+
+function flag(name, fallback) {
+  const i = args.indexOf(name)
+  if (i === -1) return fallback
+  return args.splice(i, 2)[1] || fallback
+}
+
+if (args.includes('--help') || args.includes('-h')) {
+  console.log(`underrow - watch a directory, embed content, search via UI & API
+
+Usage: underrow [dir] [options]
+
+Arguments:
+  dir              Directory to watch (default: current directory)
+
+Options:
+  --port, -p       Server port (default: 3737, env: KB_PORT)
+  --data, -d       Data storage directory (default: ./data, env: KB_DATA_DIR)
+  -h, --help       Show this help
+`)
+  process.exit(0)
+}
+
+const PORT = parseInt(flag('--port', flag('-p', process.env.KB_PORT || '3737')), 10)
+const DATA_DIR = resolve(flag('--data', flag('-d', process.env.KB_DATA_DIR || './data')))
+const WATCH_DIR = resolve(args[0] || process.env.KB_WATCH_DIR || process.cwd())
+
+async function main() {
+  console.log(`KB starting...`)
+  console.log(`  Watch dir : ${WATCH_DIR}`)
+  console.log(`  Data dir  : ${DATA_DIR}`)
+  console.log(`  Port      : ${PORT}`)
+
+  console.log('Loading embedding model...')
+  const embedder = await initEmbedder()
+  console.log('Embedding model ready.')
+
+  const store = new Store(DATA_DIR, embedder.dimensions)
+  store._embedder = embedder
+
+  startWatcher(WATCH_DIR, store, embedder)
+
+  const app = createServer(store, embedder)
+  app.listen(PORT, () => {
+    console.log(`KB server listening on http://localhost:${PORT}`)
+  })
+}
+
+main().catch(err => {
+  console.error('Fatal error:', err)
+  process.exit(1)
+})

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "underrow",
+  "version": "2026.4.1",
+  "description": "KnowledgeBase driver - file watcher with vector and fuzzy search",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "underrow": "index.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "dev": "node --watch index.js"
+  },
+  "keywords": ["knowledgebase", "vector-search", "faiss", "fuzzy-search"],
+  "license": "MIT",
+  "dependencies": {
+    "chokidar": "^3.6.0",
+    "express": "^4.21.0",
+    "faiss-node": "^0.5.1",
+    "fuse.js": "^7.0.0"
+  }
+}

package/public/index.html

@@ -0,0 +1,271 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>KB - Knowledge Base</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      background: #0f1117;
+      color: #e1e4e8;
+      min-height: 100vh;
+    }
+
+    header {
+      background: #161b22;
+      border-bottom: 1px solid #30363d;
+      padding: 1rem 2rem;
+      display: flex;
+      align-items: center;
+      gap: 1rem;
+    }
+
+    header h1 {
+      font-size: 1.4rem;
+      font-weight: 600;
+      color: #58a6ff;
+    }
+
+    .stats {
+      margin-left: auto;
+      font-size: 0.85rem;
+      color: #8b949e;
+      display: flex;
+      gap: 1.5rem;
+    }
+
+    .stats span { color: #58a6ff; font-weight: 600; }
+
+    .container {
+      max-width: 960px;
+      margin: 2rem auto;
+      padding: 0 1rem;
+    }
+
+    .search-box {
+      display: flex;
+      gap: 0.5rem;
+      margin-bottom: 1.5rem;
+    }
+
+    .search-box input {
+      flex: 1;
+      padding: 0.75rem 1rem;
+      background: #161b22;
+      border: 1px solid #30363d;
+      border-radius: 6px;
+      color: #e1e4e8;
+      font-size: 1rem;
+      outline: none;
+    }
+
+    .search-box input:focus { border-color: #58a6ff; }
+
+    .search-box select {
+      padding: 0.75rem;
+      background: #161b22;
+      border: 1px solid #30363d;
+      border-radius: 6px;
+      color: #e1e4e8;
+      font-size: 0.9rem;
+      cursor: pointer;
+    }
+
+    .search-box button {
+      padding: 0.75rem 1.5rem;
+      background: #238636;
+      border: none;
+      border-radius: 6px;
+      color: #fff;
+      font-size: 1rem;
+      cursor: pointer;
+      font-weight: 500;
+    }
+
+    .search-box button:hover { background: #2ea043; }
+
+    .results { display: flex; flex-direction: column; gap: 0.75rem; }
+
+    .result-card {
+      background: #161b22;
+      border: 1px solid #30363d;
+      border-radius: 8px;
+      padding: 1rem 1.25rem;
+      transition: border-color 0.15s;
+    }
+
+    .result-card:hover { border-color: #58a6ff; }
+
+    .result-header {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      margin-bottom: 0.5rem;
+    }
+
+    .result-path {
+      font-size: 0.85rem;
+      color: #58a6ff;
+      font-family: monospace;
+    }
+
+    .result-meta {
+      font-size: 0.75rem;
+      color: #8b949e;
+      display: flex;
+      gap: 1rem;
+    }
+
+    .result-text {
+      font-size: 0.9rem;
+      color: #c9d1d9;
+      line-height: 1.5;
+      white-space: pre-wrap;
+      max-height: 150px;
+      overflow-y: auto;
+      font-family: monospace;
+      background: #0d1117;
+      padding: 0.75rem;
+      border-radius: 4px;
+      margin-top: 0.5rem;
+    }
+
+    .empty-state {
+      text-align: center;
+      padding: 3rem;
+      color: #8b949e;
+    }
+
+    .density-bar {
+      display: inline-block;
+      width: 50px;
+      height: 8px;
+      background: #21262d;
+      border-radius: 4px;
+      overflow: hidden;
+      vertical-align: middle;
+    }
+
+    .density-bar .fill {
+      height: 100%;
+      border-radius: 4px;
+      background: #3fb950;
+    }
+  </style>
+</head>
+<body>
+  <header>
+    <h1>KB</h1>
+    <div class="stats">
+      <div>Files: <span id="stat-files">-</span></div>
+      <div>Chunks: <span id="stat-chunks">-</span></div>
+      <div>Avg Density: <span id="stat-density">-</span></div>
+    </div>
+  </header>
+
+  <div class="container">
+    <div class="search-box">
+      <input type="text" id="query" placeholder="Search your knowledge base..." autofocus />
+      <select id="mode">
+        <option value="vector">Vector</option>
+        <option value="fuzzy">Fuzzy</option>
+      </select>
+      <button onclick="doSearch()">Search</button>
+    </div>
+
+    <div class="results" id="results">
+      <div class="empty-state">
+        <p>Enter a query to search your indexed files.</p>
+      </div>
+    </div>
+  </div>
+
+  <script>
+    const queryInput = document.getElementById('query')
+    const modeSelect = document.getElementById('mode')
+    const resultsDiv = document.getElementById('results')
+
+    queryInput.addEventListener('keydown', e => {
+      if (e.key === 'Enter') doSearch()
+    })
+
+    async function loadStats() {
+      try {
+        const res = await fetch('/api/stats')
+        const data = await res.json()
+        document.getElementById('stat-files').textContent = data.totalFiles
+        document.getElementById('stat-chunks').textContent = data.totalChunks
+        document.getElementById('stat-density').textContent = data.avgDensity.toFixed(3)
+      } catch {}
+    }
+
+    async function doSearch() {
+      const query = queryInput.value.trim()
+      if (!query) return
+
+      const mode = modeSelect.value
+      let results
+
+      try {
+        if (mode === 'vector') {
+          const res = await fetch('/api/search/vector', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ query, k: 20 }),
+          })
+          const data = await res.json()
+          results = data.results
+        } else {
+          const res = await fetch(`/api/search/fuzzy?q=${encodeURIComponent(query)}`)
+          const data = await res.json()
+          results = data.results
+        }
+
+        renderResults(results)
+      } catch (err) {
+        resultsDiv.innerHTML = `<div class="empty-state">Error: ${err.message}</div>`
+      }
+    }
+
+    function renderResults(results) {
+      if (!results || results.length === 0) {
+        resultsDiv.innerHTML = '<div class="empty-state">No results found.</div>'
+        return
+      }
+
+      resultsDiv.innerHTML = results.map(r => `
+        <div class="result-card">
+          <div class="result-header">
+            <span class="result-path">${escapeHtml(r.filePath)}</span>
+            <div class="result-meta">
+              <span>chunk ${r.chunkIndex}</span>
+              <span>score: ${r.score?.toFixed(3) ?? '-'}</span>
+              <span>
+                density: ${r.density?.toFixed(3) ?? '-'}
+                <span class="density-bar">
+                  <span class="fill" style="width: ${(r.density ?? 0) * 100}%"></span>
+                </span>
+              </span>
+            </div>
+          </div>
+          <div class="result-text">${escapeHtml(r.text)}</div>
+        </div>
+      `).join('')
+    }
+
+    function escapeHtml(str) {
+      return str
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+    }
+
+    loadStats()
+    setInterval(loadStats, 5000)
+  </script>
+</body>
+</html>

package/src/chunker.js

@@ -0,0 +1,26 @@
+const DEFAULT_CHUNK_SIZE = 512
+const DEFAULT_OVERLAP = 64
+
+export function chunkText(text, { chunkSize = DEFAULT_CHUNK_SIZE, overlap = DEFAULT_OVERLAP } = {}) {
+  const chunks = []
+  const lines = text.split('\n')
+  let current = ''
+
+  for (const line of lines) {
+    if (current.length + line.length + 1 > chunkSize && current.length > 0) {
+      chunks.push(current.trim())
+      // keep overlap from end of previous chunk
+      const words = current.split(/\s+/)
+      const overlapWords = words.slice(-Math.ceil(overlap / 5))
+      current = overlapWords.join(' ') + '\n' + line
+    } else {
+      current += (current ? '\n' : '') + line
+    }
+  }
+
+  if (current.trim()) {
+    chunks.push(current.trim())
+  }
+
+  return chunks
+}

package/src/density.js

@@ -0,0 +1,8 @@
+import { gzipSync } from 'zlib'
+
+export function informationDensity(text) {
+  const orig = Buffer.byteLength(text, 'utf8')
+  if (orig === 0) return 0
+  const compressed = gzipSync(Buffer.from(text, 'utf8'))
+  return compressed.length / orig
+}

package/src/embedder.js

@@ -0,0 +1,84 @@
+/**
+ * Lightweight local text embedder using character n-gram hashing.
+ * No external model download required - creates fixed-size vectors
+ * using hash projections of character and word n-grams.
+ */
+
+const DIMENSIONS = 384
+const CHAR_NGRAM_SIZES = [3, 4, 5]
+const WORD_NGRAM_SIZES = [1, 2]
+
+function hashCode(str) {
+  let h = 0
+  for (let i = 0; i < str.length; i++) {
+    h = ((h << 5) - h + str.charCodeAt(i)) | 0
+  }
+  return h
+}
+
+function hashToIndex(str, dim) {
+  const h = hashCode(str)
+  return ((h % dim) + dim) % dim
+}
+
+function hashToSign(str) {
+  return (hashCode(str + '_sign') & 1) === 0 ? 1 : -1
+}
+
+function extractCharNgrams(text) {
+  const ngrams = []
+  const lower = text.toLowerCase()
+  for (const n of CHAR_NGRAM_SIZES) {
+    for (let i = 0; i <= lower.length - n; i++) {
+      ngrams.push(lower.slice(i, i + n))
+    }
+  }
+  return ngrams
+}
+
+function extractWordNgrams(text) {
+  const words = text.toLowerCase().split(/\s+/).filter(w => w.length > 0)
+  const ngrams = []
+  for (const n of WORD_NGRAM_SIZES) {
+    for (let i = 0; i <= words.length - n; i++) {
+      ngrams.push(words.slice(i, i + n).join(' '))
+    }
+  }
+  return ngrams
+}
+
+function normalize(vec) {
+  let norm = 0
+  for (let i = 0; i < vec.length; i++) norm += vec[i] * vec[i]
+  norm = Math.sqrt(norm)
+  if (norm === 0) return vec
+  for (let i = 0; i < vec.length; i++) vec[i] /= norm
+  return vec
+}
+
+function embedText(text) {
+  const vec = new Float64Array(DIMENSIONS)
+
+  // Character n-gram features (weighted higher)
+  const charNgrams = extractCharNgrams(text)
+  for (const ng of charNgrams) {
+    const idx = hashToIndex(ng, DIMENSIONS)
+    vec[idx] += hashToSign(ng) * 1.0
+  }
+
+  // Word n-gram features (weighted higher for semantic meaning)
+  const wordNgrams = extractWordNgrams(text)
+  for (const ng of wordNgrams) {
+    const idx = hashToIndex('w_' + ng, DIMENSIONS)
+    vec[idx] += hashToSign('w_' + ng) * 2.0
+  }
+
+  return Array.from(normalize(vec))
+}
+
+export async function initEmbedder() {
+  return {
+    dimensions: DIMENSIONS,
+    embed: async (text) => embedText(text),
+  }
+}

package/src/server.js

@@ -0,0 +1,57 @@
+import express from 'express'
+import { resolve } from 'path'
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+export function createServer(store, embedder) {
+  const app = express()
+
+  app.use(express.json())
+  app.use(express.static(resolve(__dirname, '..', 'public')))
+
+  // Vector search
+  app.post('/api/search/vector', async (req, res) => {
+    const { query, k = 10 } = req.body
+
+    if (!query) {
+      return res.status(400).json({ error: 'query is required' })
+    }
+
+    try {
+      const vec = await embedder.embed(query)
+      const results = store.vectorSearch(vec, k)
+      res.json({ results })
+    } catch (err) {
+      res.status(500).json({ error: err.message })
+    }
+  })
+
+  // Fuzzy text search
+  app.get('/api/search/fuzzy', (req, res) => {
+    const { q, limit = 20, threshold = 0.4 } = req.query
+
+    if (!q) {
+      return res.status(400).json({ error: 'q query parameter is required' })
+    }
+
+    const results = store.fuzzySearch(q, {
+      limit: parseInt(limit, 10),
+      threshold: parseFloat(threshold),
+    })
+    res.json({ results })
+  })
+
+  // Stats
+  app.get('/api/stats', (req, res) => {
+    res.json(store.getStats())
+  })
+
+  // All metadata
+  app.get('/api/documents', (req, res) => {
+    res.json(store.getAllMetadata())
+  })
+
+  return app
+}

package/src/store.js

@@ -0,0 +1,131 @@
+import faiss from 'faiss-node'
+const { IndexFlatIP } = faiss
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from 'fs'
+import { join } from 'path'
+import Fuse from 'fuse.js'
+
+export class Store {
+  constructor(dataDir, dimensions) {
+    this.dataDir = dataDir
+    this.dimensions = dimensions
+    this.indexPath = join(dataDir, 'faiss.index')
+    this.metaPath = join(dataDir, 'metadata.json')
+
+    mkdirSync(dataDir, { recursive: true })
+
+    this.metadata = [] // array of { id, filePath, chunkIndex, text, density, mtime }
+    this.index = new IndexFlatIP(dimensions) // inner product (cosine sim on normalized vecs)
+
+    this._load()
+  }
+
+  _load() {
+    if (existsSync(this.metaPath)) {
+      try {
+        this.metadata = JSON.parse(readFileSync(this.metaPath, 'utf8'))
+      } catch {
+        this.metadata = []
+      }
+    }
+    if (existsSync(this.indexPath) && this.metadata.length > 0) {
+      try {
+        this.index = IndexFlatIP.read(this.indexPath)
+      } catch {
+        this.index = new IndexFlatIP(this.dimensions)
+      }
+    }
+  }
+
+  save() {
+    writeFileSync(this.metaPath, JSON.stringify(this.metadata, null, 2))
+    if (this.metadata.length > 0) {
+      this.index.write(this.indexPath)
+    }
+  }
+
+  removeFile(filePath) {
+    const remaining = []
+    const removeIds = new Set()
+
+    for (let i = 0; i < this.metadata.length; i++) {
+      if (this.metadata[i].filePath === filePath) {
+        removeIds.add(i)
+      } else {
+        remaining.push(this.metadata[i])
+      }
+    }
+
+    if (removeIds.size === 0) return
+
+    // Rebuild index without removed entries
+    const newIndex = new IndexFlatIP(this.dimensions)
+    // We need to re-add all vectors except removed ones
+    // Unfortunately faiss-node doesn't support removal, so we reconstruct
+    for (let i = 0; i < this.metadata.length; i++) {
+      if (!removeIds.has(i)) {
+        const vec = this.index.reconstruct(i)
+        newIndex.add(vec)
+      }
+    }
+
+    this.metadata = remaining
+    this.index = newIndex
+    this.save()
+  }
+
+  addChunks(filePath, chunks, vectors, densities, mtime) {
+    for (let i = 0; i < chunks.length; i++) {
+      this.metadata.push({
+        id: this.metadata.length,
+        filePath,
+        chunkIndex: i,
+        text: chunks[i],
+        density: densities[i],
+        mtime: mtime.toISOString(),
+      })
+      this.index.add(vectors[i])
+    }
+    this.save()
+  }
+
+  vectorSearch(queryVector, k = 10) {
+    if (this.metadata.length === 0) return []
+    const clampedK = Math.min(k, this.metadata.length)
+    const result = this.index.search(queryVector, clampedK)
+
+    return result.labels.map((idx, i) => ({
+      ...this.metadata[idx],
+      score: result.distances[i],
+    }))
+  }
+
+  fuzzySearch(query, options = {}) {
+    const fuse = new Fuse(this.metadata, {
+      keys: ['text', 'filePath'],
+      includeScore: true,
+      threshold: options.threshold ?? 0.4,
+    })
+
+    const results = fuse.search(query, { limit: options.limit ?? 20 })
+    return results.map(r => ({
+      ...r.item,
+      score: 1 - r.score, // invert so higher = better
+    }))
+  }
+
+  getStats() {
+    const files = new Set(this.metadata.map(m => m.filePath))
+    return {
+      totalChunks: this.metadata.length,
+      totalFiles: files.size,
+      files: [...files],
+      avgDensity: this.metadata.length > 0
+        ? this.metadata.reduce((sum, m) => sum + m.density, 0) / this.metadata.length
+        : 0,
+    }
+  }
+
+  getAllMetadata() {
+    return this.metadata
+  }
+}

package/src/watcher.js

@@ -0,0 +1,108 @@
+import chokidar from 'chokidar'
+import { readFileSync, statSync } from 'fs'
+import { relative, resolve } from 'path'
+import { chunkText } from './chunker.js'
+import { informationDensity } from './density.js'
+
+const TEXT_EXTENSIONS = new Set([
+  '.txt', '.md', '.js', '.ts', '.jsx', '.tsx', '.py', '.rb', '.go',
+  '.rs', '.java', '.c', '.cpp', '.h', '.hpp', '.css', '.html', '.xml',
+  '.json', '.yaml', '.yml', '.toml', '.ini', '.cfg', '.conf', '.sh',
+  '.bash', '.zsh', '.fish', '.sql', '.csv', '.log', '.env', '.gitignore',
+  '.dockerfile', '.makefile', '.cmake', '.gradle', '.properties',
+])
+
+const IGNORE_PATTERNS = [
+  '**/node_modules/**',
+  '**/data/**',
+  '**/.git/**',
+  '**/dist/**',
+  '**/build/**',
+  '**/*.lock',
+  '**/package-lock.json',
+]
+
+function isTextFile(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf('.')).toLowerCase()
+  return TEXT_EXTENSIONS.has(ext) || ext === ''
+}
+
+async function processFile(filePath, store, embedder) {
+  if (!isTextFile(filePath)) return
+
+  let text
+  try {
+    text = readFileSync(filePath, 'utf8')
+  } catch {
+    return
+  }
+
+  if (!text.trim()) return
+
+  const stat = statSync(filePath)
+  const relPath = relative(process.cwd(), filePath)
+
+  console.log(`Processing: ${relPath}`)
+
+  // Remove old entries for this file
+  store.removeFile(relPath)
+
+  const chunks = chunkText(text)
+  const densities = chunks.map(c => informationDensity(c))
+  const vectors = []
+
+  for (const chunk of chunks) {
+    const vec = await embedder.embed(chunk)
+    vectors.push(vec)
+  }
+
+  store.addChunks(relPath, chunks, vectors, densities, stat.mtime)
+  console.log(`  Indexed ${chunks.length} chunks (avg density: ${(densities.reduce((a, b) => a + b, 0) / densities.length).toFixed(3)})`)
+}
+
+export function startWatcher(dir, store, embedder) {
+  const watcher = chokidar.watch(dir, {
+    ignored: IGNORE_PATTERNS,
+    persistent: true,
+    ignoreInitial: false,
+  })
+
+  const queue = []
+  let processing = false
+
+  async function processQueue() {
+    if (processing) return
+    processing = true
+
+    while (queue.length > 0) {
+      const { filePath } = queue.shift()
+      try {
+        await processFile(filePath, store, embedder)
+      } catch (err) {
+        console.error(`Error processing ${filePath}:`, err.message)
+      }
+    }
+
+    processing = false
+  }
+
+  function enqueue(filePath) {
+    // Deduplicate
+    if (!queue.some(q => q.filePath === filePath)) {
+      queue.push({ filePath: resolve(filePath) })
+    }
+    processQueue()
+  }
+
+  watcher
+    .on('add', enqueue)
+    .on('change', enqueue)
+    .on('unlink', filePath => {
+      const relPath = relative(process.cwd(), resolve(filePath))
+      console.log(`Removed: ${relPath}`)
+      store.removeFile(relPath)
+    })
+
+  console.log(`Watching ${dir} for changes...`)
+  return watcher
+}