directory-indexer 0.0.1 → 0.0.3

package/README.md

@@ -1,199 +1,144 @@
 # Directory Indexer
 
-**Turn your directories into an AI-powered knowledge base for your team.**
+**Turn your directories into an AI-powered knowledge base.**
 
-Directory Indexer is an MCP server that indexes local directories with semantic search. Give AI assistants the ability to find and read relevant files based on content similarity, not just filenames.
+[![npm](https://img.shields.io/npm/v/directory-indexer)](https://npmjs.com/package/directory-indexer)
+[![Crates.io](https://img.shields.io/crates/v/directory-indexer)](https://crates.io/crates/directory-indexer)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+[![CI](https://github.com/peteretelej/directory-indexer/workflows/CI/badge.svg)](https://github.com/peteretelej/directory-indexer/actions)
 
-## Problem
+Give AI assistants semantic search across your local files. Find relevant documents based on meaning, not just filenames.
 
-You have thousands of files across directories:
+## Quick Start
 
-- Incident response docs and runbooks
-- Code examples and architecture decisions
-- Meeting notes and project documentation
-- Configuration files and deployment guides
-
-Finding relevant files requires knowing exactly what to search for:
-
-- Filename search needs exact words from the filename
-- Text search needs specific terms that appear in the content
-- No way to find conceptually related files or similar solutions to problems
-
-## Solution
-
-[directory-indexer](https://github.com/peteretelej/directory-indexer) creates vector embeddings of your files and provides semantic search through MCP tools. AI assistants can find relevant documents based on meaning and context.
+```bash
+# Install via npm
+npm install -g directory-indexer
 
-**Example workflow:**
+# Index your directories
+directory-indexer index ~/Documents ~/work/docs
 
-1. Index your directories: `directory-indexer index ~/work/docs ~/incidents`
-2. Configure with Claude Desktop or any MCP client
-3. Ask: _"Find incidents similar to this Redis timeout error"_
-4. AI searches embeddings, finds relevant files, reads content, provides context
+# Start MCP server for AI assistants
+directory-indexer serve
+```
 
-## Architecture
+**Configure with Claude Desktop:**
 
-```
-┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
-│   AI Assistant  │◄──►│  MCP Server      │◄──►│  Vector Store   │
-│  (Claude, etc)  │    │  (Rust)          │    │  (Qdrant)       │
-└─────────────────┘    └──────────────────┘    └─────────────────┘
-                              │
-                              ▼
-                       ┌──────────────────┐
-                       │  File System     │
-                       │  Monitor         │
-                       └──────────────────┘
+```json
+{
+  "mcpServers": {
+    "directory-indexer": {
+      "command": "directory-indexer",
+      "args": ["serve"]
+    }
+  }
+}
 ```
 
-**Core components:**
+Now ask Claude: _"Find files similar to my Redis incident reports"_ and it will search your indexed documents semantically.
 
-- **MCP Server**: Implements Model Context Protocol, provides search tools
-- **File Processor**: Converts various formats (PDF, DOCX, etc.) to text (initially unimplemented)
-- **Indexing Engine**: Extracts content, creates embeddings, handles updates
-- **Vector Storage**: Qdrant for fast similarity search
-- **File Monitor**: Watches for changes, incremental updates
+## Requirements
 
-## MCP Tools
+- **Qdrant**: Vector database for semantic search
 
-- `index(directory_path)` - Index all files in directory
-- `search(query, directory_path)` - Semantic search across indexed files
-- `similar_files(file_path, limit)` - Find files similar to given file
-- `get_content(file_path, chunks?)` - Read file with optional chunk selection
-- `server_info()` - Show indexed directories and stats
-
-## CLI Commands
+```bash
+docker run -d --name qdrant \
+    -p 127.0.0.1:6333:6333 \
+    -v qdrant_storage:/qdrant/storage \
+    qdrant/qdrant
+```
 
-- `directory-indexer index <paths...>` - Index directories
-- `directory-indexer search <query> [path]` - Search indexed content
-- `directory-indexer similar <file> [--limit N]` - Find similar files
-- `directory-indexer get <file> [--chunks N-M]` - Get file content
-- `directory-indexer serve` - Start MCP server
-- `directory-indexer status` - Show indexing status
+**Embedding Provider** (choose one):
 
-## Installation
+- **Ollama** (recommended): Self-hosted embeddings
 
 ```bash
-# Install via npm
-npm install -g directory-indexer
-
-# Or run directly
-npx directory-indexer@latest
+# Install Ollama natively for GPU support (recommended)
+curl -fsSL https://ollama.ai/install.sh | sh
+# Visit https://ollama.ai for Windows installer
+ollama pull nomic-embed-text
+
+# OR use Docker (CPU-only, slower)
+docker run -d --name ollama \
+    -p 127.0.0.1:11434:11434 \
+    -v ollama_data:/root/.ollama \
+    ollama/ollama
+
+docker exec ollama ollama pull nomic-embed-text
 ```
 
-**Requirements:**
+- **OpenAI**: Requires API key
 
-- Qdrant (local or remote)
-- Embedding provider:
-  - Local: Ollama (free)
-  - Remote: OpenAI, Voyage AI, OpenRouter, or compatible API (requires API key)
-
-## Usage
+## Configuration
 
-### 1. Index directories
+Directory Indexer uses environment variables for configuration. Set these if your services run on different ports or require API keys:
 
 ```bash
-directory-indexer index ~/work/incidents ~/docs/runbooks
-```
+# Service endpoints (defaults shown)
+export QDRANT_ENDPOINT="http://localhost:6333"
+export OLLAMA_ENDPOINT="http://localhost:11434"
 
-### 2. Search from CLI
+# Optional database path (default: ~/.directory-indexer/data.db)
+export DIRECTORY_INDEXER_DB="/path/to/your/database.db"
 
-```bash
-# Semantic search
-directory-indexer search "Redis connection timeout" ~/work/incidents
-
-# Find similar files
-directory-indexer similar ~/work/incidents/icm-2024-0123.md
+# Optional Qdrant collection name (default: directory-indexer)
+# Note: Setting to "test" enables auto-cleanup for testing
+export DIRECTORY_INDEXER_QDRANT_COLLECTION="my-custom-collection"
 
-# Get file content with chunks
-directory-indexer get ~/work/runbooks/deployment.md --chunks 2-5
+# Optional API keys
+export QDRANT_API_KEY="your-qdrant-key"
+export OLLAMA_API_KEY="your-ollama-key"  # if using hosted Ollama
 ```
 
-### 3. Use with MCP clients
-
-Add to Cline, Claude Desktop, or Cursor config:
+**For MCP clients** (like Claude Desktop), configure with environment variables:
 
 ```json
 {
   "mcpServers": {
     "directory-indexer": {
       "command": "directory-indexer",
-      "args": ["serve"]
+      "args": ["serve"],
+      "env": {
+        "QDRANT_ENDPOINT": "http://localhost:6333",
+        "OLLAMA_ENDPOINT": "http://localhost:11434",
+        "DIRECTORY_INDEXER_DB": "/path/to/your/database.db"
+      }
     }
   }
 }
 ```
 
-### 4. Interactive with AI
-
-- _"Find documentation about our Redis setup"_
-- _"What incidents have we had with database timeouts?"_
-- _"Show me examples of error handling in our Go services"_
+## CLI Usage
 
-## Configuration
+```bash
+# Index your directories
+directory-indexer index ~/Documents ~/work/docs
 
-Default config at `~/.directory-indexer/config.json`:
+# Search semantically
+directory-indexer search "database timeout errors"
 
-```json
-{
-  "embedding": {
-    "provider": "ollama",
-    "model": "nomic-embed-text",
-    "endpoint": "http://localhost:11434"
-  },
-  "storage": {
-    "type": "qdrant",
-    "endpoint": "http://localhost:6333",
-    "collection": "documents"
-  },
-  "indexing": {
-    "chunk_size": 512,
-    "overlap": 50,
-    "max_file_size": 10485760,
-    "ignore_patterns": [".git", "node_modules", "target"]
-  },
-  "monitoring": {
-    "enabled": true,
-    "batch_size": 100
-  }
-}
-```
+# Find similar files
+directory-indexer similar ~/incidents/redis-outage.md
 
-**API Key handling:**
+# Get file content
+directory-indexer get ~/docs/api-guide.md
 
-- Only include `api_key` field when using remote providers (OpenAI, Voyage AI, OpenRouter)
-- Omit the field entirely for local Ollama
-- Store API keys securely with proper file permissions (`600`)
+# Show status
+directory-indexer status
+```
 
-## Supported File Types
+## Supported Files
 
-- **Text**: `.md`, `.txt`, `.rst`, `.org`
-- **Code**: Most programming languages with syntax awareness
+- **Text**: `.md`, `.txt`
+- **Code**: `.rs`, `.py`, `.js`, `.ts`, `.go`, `.java`, etc.
 - **Data**: `.json`, `.yaml`, `.csv`, `.toml`
 - **Config**: `.env`, `.conf`, `.ini`
-- **Web**: `.html`, `.xml`
-
-## Planned Support
-
-- **Documents**: `.pdf`, `.docx`, `.pptx` (requires file conversion preprocessing)
-- **Spreadsheets**: `.xlsx`, `.ods`
-- **Archives**: Extract and index contents of `.zip`, `.tar.gz`
-
-## Development
-
-**Tech stack:**
-
-- Rust (tokio async runtime)
-- Qdrant (vector database)
-- Ollama or OpenAI-compatible embedding API
-- Model Context Protocol
-- Platform-native file watching
 
-**Architecture decisions:**
+## Documentation
 
-- Rust for performance and memory safety
-- Qdrant for production-ready vector search
-- MCP for standardized AI assistant integration
-- Local-first with optional remote embedding APIs
+- **[API Reference](docs/designs/API.md)**: Complete CLI and MCP tool documentation
+- **[Contributing](docs/CONTRIBUTING.md)**: Development setup and guidelines
+- **[Design](docs/design.md)**: Architecture and technical decisions
 
 ## License
 

package/bin/directory-indexer.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+function getBinaryPath() {
+  const platform = process.platform;
+  const arch = process.arch;
+  
+  let binaryName = 'directory-indexer';
+  let platformDir = '';
+  
+  if (platform === 'win32') {
+    binaryName += '.exe';
+    platformDir = 'win32-x64';
+  } else if (platform === 'darwin') {
+    platformDir = arch === 'arm64' ? 'darwin-arm64' : 'darwin-x64';
+  } else if (platform === 'linux') {
+    platformDir = 'linux-x64';
+  } else {
+    console.error(`Unsupported platform: ${platform}-${arch}`);
+    process.exit(1);
+  }
+  
+  // Try different locations for the binary
+  const possiblePaths = [
+    // Pre-built binary from npm package
+    path.join(__dirname, '..', 'binaries', `${binaryName}-${platformDir}`),
+    // Development build
+    path.join(__dirname, '..', 'target', 'release', binaryName),
+    path.join(__dirname, '..', 'target', 'debug', binaryName),
+  ];
+  
+  for (const binaryPath of possiblePaths) {
+    if (fs.existsSync(binaryPath)) {
+      return binaryPath;
+    }
+  }
+  
+  console.error(`Binary not found for ${platform}-${arch}`);
+  console.error('Tried paths:', possiblePaths);
+  console.error('Run "cargo build --release" to build the binary');
+  process.exit(1);
+}
+
+function main() {
+  const binaryPath = getBinaryPath();
+  const args = process.argv.slice(2);
+  
+  const child = spawn(binaryPath, args, {
+    stdio: 'inherit',
+    windowsHide: false,
+  });
+  
+  child.on('error', (error) => {
+    console.error('Failed to start directory-indexer:', error.message);
+    process.exit(1);
+  });
+  
+  child.on('close', (code) => {
+    process.exit(code);
+  });
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { getBinaryPath };

package/package.json

@@ -1,28 +1,27 @@
 {
   "name": "directory-indexer",
-  "version": "0.0.1",
-  "description": "Turn your directories into an AI-powered knowledge base for your team. MCP server that indexes local directories with semantic search.",
-  "main": "index.js",
+  "version": "0.0.3",
+  "description": "AI-powered directory indexing with semantic search for MCP servers",
+  "main": "bin/directory-indexer.js",
   "bin": {
-    "directory-indexer": "./bin/cli.js"
-  },
-  "directories": {
-    "doc": "docs"
+    "directory-indexer": "bin/directory-indexer.js"
   },
   "scripts": {
-    "start": "node index.js",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "cargo build --release",
+    "build-all": "node scripts/build-all.js",
+    "test": "npm run unit-test",
+    "unit-test": "cargo test --lib && cargo test --test storage_tests",
+    "integration-test": "cargo test",
+    "lint": "cargo fmt --all -- --check && cargo clippy --all-targets --all-features -- -D warnings",
+    "postinstall": "node scripts/postinstall.js"
   },
   "keywords": [
     "mcp",
-    "semantic-search",
-    "vector-database",
-    "ai",
+    "search",
     "indexing",
-    "knowledge-base",
-    "claude",
-    "directory",
-    "search"
+    "ai",
+    "semantic",
+    "cli"
   ],
   "author": "Peter Etelej <peter@etelej.com>",
   "license": "MIT",
@@ -30,17 +29,30 @@
     "type": "git",
     "url": "https://github.com/peteretelej/directory-indexer.git"
   },
-  "homepage": "https://github.com/peteretelej/directory-indexer#readme",
+  "homepage": "https://github.com/peteretelej/directory-indexer",
   "bugs": {
     "url": "https://github.com/peteretelej/directory-indexer/issues"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=16.0.0"
   },
+  "os": [
+    "linux",
+    "darwin",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
   "files": [
-    "index.js",
     "bin/",
+    "scripts/",
+    "binaries/",
     "README.md",
     "LICENSE"
-  ]
-}
+  ],
+  "devDependencies": {
+    "cross-env": "^7.0.3"
+  }
+}

package/scripts/build-all.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const targets = [
+  { target: 'x86_64-unknown-linux-gnu', platform: 'linux', arch: 'x64' },
+  { target: 'x86_64-apple-darwin', platform: 'darwin', arch: 'x64' },
+  { target: 'aarch64-apple-darwin', platform: 'darwin', arch: 'arm64' },
+  { target: 'x86_64-pc-windows-gnu', platform: 'win32', arch: 'x64' },
+];
+
+function runCommand(command, args = [], options = {}) {
+  return new Promise((resolve, reject) => {
+    console.log(`Running: ${command} ${args.join(' ')}`);
+    const child = spawn(command, args, { stdio: 'inherit', ...options });
+    
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Command failed with exit code ${code}`));
+      }
+    });
+    
+    child.on('error', reject);
+  });
+}
+
+async function buildTarget(targetInfo) {
+  const { target, platform, arch } = targetInfo;
+  
+  console.log(`\n🏗️  Building for ${platform}-${arch} (${target})`);
+  
+  try {
+    // Add the target if not already installed
+    await runCommand('rustup', ['target', 'add', target]);
+    
+    // Build for the target
+    await runCommand('cargo', ['build', '--release', '--target', target]);
+    
+    // Copy binary to binaries directory
+    const binariesDir = path.join(__dirname, '..', 'binaries');
+    if (!fs.existsSync(binariesDir)) {
+      fs.mkdirSync(binariesDir, { recursive: true });
+    }
+    
+    const extension = platform === 'win32' ? '.exe' : '';
+    const sourcePath = path.join(__dirname, '..', 'target', target, 'release', `directory-indexer${extension}`);
+    const destPath = path.join(binariesDir, `directory-indexer-${platform}-${arch}${extension}`);
+    
+    if (fs.existsSync(sourcePath)) {
+      fs.copyFileSync(sourcePath, destPath);
+      fs.chmodSync(destPath, 0o755);
+      console.log(`✅ Built ${destPath}`);
+    } else {
+      throw new Error(`Binary not found at ${sourcePath}`);
+    }
+    
+  } catch (error) {
+    console.error(`❌ Failed to build ${platform}-${arch}:`, error.message);
+    throw error;
+  }
+}
+
+async function main() {
+  console.log('🚀 Building directory-indexer for all platforms...\n');
+  
+  // Build for all targets
+  for (const target of targets) {
+    try {
+      await buildTarget(target);
+    } catch (error) {
+      console.error(`Failed to build ${target.platform}-${target.arch}, continuing...`);
+    }
+  }
+  
+  console.log('\n✨ Build complete! Binaries are in the binaries/ directory.');
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    console.error('Build failed:', error);
+    process.exit(1);
+  });
+}

package/scripts/cleanup-act.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+
+# Cleanup script for act containers and networks
+# Act doesn't clean up after itself, causing port conflicts
+
+echo "🧹 Cleaning up act containers and networks..."
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Count act containers
+ACT_CONTAINERS=$(docker ps -aq --filter "name=act-" | wc -l)
+ACT_NETWORKS=$(docker network ls | grep act | wc -l)
+
+if [ "$ACT_CONTAINERS" -eq 0 ] && [ "$ACT_NETWORKS" -eq 0 ]; then
+    echo -e "${GREEN}✅ No act containers or networks to clean up${NC}"
+    exit 0
+fi
+
+echo -e "${YELLOW}Found $ACT_CONTAINERS act containers and $ACT_NETWORKS act networks${NC}"
+
+# Stop act containers
+if [ "$ACT_CONTAINERS" -gt 0 ]; then
+    echo -e "${YELLOW}Stopping act containers...${NC}"
+    docker stop $(docker ps -q --filter "name=act-") 2>/dev/null || true
+    
+    echo -e "${YELLOW}Removing act containers...${NC}"
+    docker rm $(docker ps -aq --filter "name=act-") 2>/dev/null || true
+fi
+
+# Remove act networks
+if [ "$ACT_NETWORKS" -gt 0 ]; then
+    echo -e "${YELLOW}Removing act networks...${NC}"
+    docker network ls | grep act | awk '{print $1}' | xargs -r docker network rm 2>/dev/null || true
+fi
+
+echo -e "${GREEN}🎉 Act cleanup completed!${NC}"
+
+# Show what's still running
+echo -e "${YELLOW}Currently running containers:${NC}"
+docker ps --format "table {{.Names}}\t{{.Ports}}" | head -10

package/scripts/postinstall.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+function makeExecutable(filePath) {
+  if (fs.existsSync(filePath)) {
+    try {
+      fs.chmodSync(filePath, 0o755);
+      console.log(`Made ${filePath} executable`);
+    } catch (error) {
+      console.warn(`Failed to make ${filePath} executable:`, error.message);
+    }
+  }
+}
+
+function main() {
+  const platform = process.platform;
+  const arch = process.arch;
+  
+  // Make the wrapper script executable
+  const wrapperPath = path.join(__dirname, '..', 'bin', 'directory-indexer.js');
+  makeExecutable(wrapperPath);
+  
+  // Make the platform-specific binary executable
+  let binaryName, platformSuffix;
+  
+  if (platform === 'win32') {
+    binaryName = 'directory-indexer.exe-win32-x64';
+  } else if (platform === 'darwin') {
+    binaryName = arch === 'arm64' ? 'directory-indexer-darwin-arm64' : 'directory-indexer-darwin-x64';
+  } else if (platform === 'linux') {
+    binaryName = 'directory-indexer-linux-x64';
+  }
+  
+  if (binaryName) {
+    const binaryPath = path.join(__dirname, '..', 'binaries', binaryName);
+    makeExecutable(binaryPath);
+  }
+  
+  console.log('directory-indexer installed successfully!');
+  console.log('Run "directory-indexer --help" to get started.');
+}
+
+if (require.main === module) {
+  main();
+}

package/scripts/pre-push

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+# Pre-push hook for directory-indexer
+# Run essential quality checks before pushing code
+
+set -e
+
+echo "Running pre-push checks..."
+
+# Check if we're in a Rust project
+if [ ! -f "Cargo.toml" ]; then
+    echo "ERROR: Cargo.toml not found. This script should be run from the project root."
+    exit 1
+fi
+
+echo "Running clippy (linter)..."
+# Check main library code with strict linting
+cargo clippy --lib --all-features -- -D warnings -D clippy::uninlined_format_args
+# Check other targets with standard linting (tests can be less strict)
+cargo clippy --bins --all-features -- -D warnings
+
+echo "Checking code formatting..."
+cargo fmt --check
+
+echo "Running essential tests..."
+# Only run fast, essential tests - skip the slow integration tests
+cargo test --lib
+cargo test --test error_scenarios_tests  
+cargo test --test storage_tests
+
+echo "Checking for security vulnerabilities..."
+if command -v cargo-audit >/dev/null 2>&1; then
+    cargo audit
+else
+    echo "Installing cargo-audit..."
+    cargo install cargo-audit
+    cargo audit
+fi
+
+echo "All pre-push checks passed!"

package/scripts/start-dev-services.sh

@@ -0,0 +1,108 @@
+#!/bin/bash
+
+# Development services startup script
+# Sets up isolated development environment using environment variables
+
+set -e
+
+echo "Starting development services for directory-indexer..."
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Standard ports for development
+DEV_QDRANT_PORT=6333
+DEV_OLLAMA_PORT=11434
+
+# Check if Docker is running
+if ! docker info >/dev/null 2>&1; then
+    echo -e "${RED}Docker is not running. Please start Docker first.${NC}"
+    exit 1
+fi
+
+# Start Qdrant on standard port
+echo -e "${YELLOW}Starting Qdrant on port $DEV_QDRANT_PORT...${NC}"
+docker stop qdrant-dev || true
+docker rm qdrant-dev || true
+
+docker run -d \
+    --name qdrant-dev \
+    -p $DEV_QDRANT_PORT:6333 \
+    -v qdrant_dev_storage:/qdrant/storage \
+    qdrant/qdrant
+
+# Wait for Qdrant to be ready
+echo -e "${YELLOW}Waiting for Qdrant to be ready...${NC}"
+for i in {1..30}; do
+    if curl -s http://localhost:$DEV_QDRANT_PORT/ >/dev/null 2>&1; then
+        echo -e "${GREEN}Qdrant is ready on http://localhost:$DEV_QDRANT_PORT${NC}"
+        break
+    fi
+    if [ $i -eq 30 ]; then
+        echo -e "${RED}Qdrant failed to start after 30 seconds${NC}"
+        exit 1
+    fi
+    sleep 1
+done
+
+# Start Ollama on standard port
+echo -e "${YELLOW}Starting Ollama on port $DEV_OLLAMA_PORT...${NC}"
+docker stop ollama-dev || true
+docker rm ollama-dev || true
+
+docker run -d \
+    --name ollama-dev \
+    -p $DEV_OLLAMA_PORT:11434 \
+    -v ollama_dev_data:/root/.ollama \
+    ollama/ollama
+
+# Wait for Ollama to be ready
+echo -e "${YELLOW}Waiting for Ollama to be ready...${NC}"
+for i in {1..30}; do
+    if curl -s http://localhost:$DEV_OLLAMA_PORT/api/tags >/dev/null 2>&1; then
+        echo -e "${GREEN}Ollama is ready on http://localhost:$DEV_OLLAMA_PORT${NC}"
+        break
+    fi
+    if [ $i -eq 30 ]; then
+        echo -e "${RED}Ollama failed to start after 30 seconds${NC}"
+        exit 1
+    fi
+    sleep 1
+done
+
+# Pull required embedding model
+echo -e "${YELLOW}Ensuring nomic-embed-text model is available...${NC}"
+if docker exec ollama-dev ollama list | grep -q "nomic-embed-text"; then
+    echo -e "${GREEN}nomic-embed-text model already available${NC}"
+else
+    echo -e "${YELLOW}Pulling nomic-embed-text model (this may take a while)...${NC}"
+    docker exec ollama-dev ollama pull nomic-embed-text
+    echo -e "${GREEN}nomic-embed-text model ready${NC}"
+fi
+
+# Set environment variables for development
+export QDRANT_ENDPOINT="http://localhost:$DEV_QDRANT_PORT"
+export OLLAMA_ENDPOINT="http://localhost:$DEV_OLLAMA_PORT"
+
+echo -e "${GREEN}Development services are ready!${NC}"
+echo
+echo -e "${YELLOW}Services:${NC}"
+echo "  Qdrant: http://localhost:$DEV_QDRANT_PORT"
+echo "  Ollama: http://localhost:$DEV_OLLAMA_PORT"
+echo
+echo -e "${YELLOW}Environment variables set:${NC}"
+echo "  QDRANT_ENDPOINT=$QDRANT_ENDPOINT"
+echo "  OLLAMA_ENDPOINT=$OLLAMA_ENDPOINT"
+echo
+echo -e "${YELLOW}To use these services in your current shell:${NC}"
+echo "  export QDRANT_ENDPOINT=$QDRANT_ENDPOINT"
+echo "  export OLLAMA_ENDPOINT=$OLLAMA_ENDPOINT"
+echo
+echo -e "${YELLOW}To stop services:${NC}"
+echo "  ./scripts/stop-dev-services.sh"
+echo
+echo -e "${YELLOW}To run tests with dev services:${NC}"
+echo "  QDRANT_ENDPOINT=$QDRANT_ENDPOINT OLLAMA_ENDPOINT=$OLLAMA_ENDPOINT cargo test --test connectivity_tests"

package/scripts/stop-dev-services.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+
+# Development services stop script
+
+set -e
+
+echo "Stopping development services..."
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Stop and remove Qdrant dev container
+if docker ps -q --filter "name=qdrant-dev" | grep -q .; then
+    echo -e "${YELLOW}Stopping Qdrant development container...${NC}"
+    docker stop qdrant-dev
+    docker rm qdrant-dev
+    echo -e "${GREEN}Qdrant development container stopped${NC}"
+else
+    echo -e "${YELLOW}Qdrant development container not running${NC}"
+fi
+
+# Stop and remove Ollama dev container
+if docker ps -q --filter "name=ollama-dev" | grep -q .; then
+    echo -e "${YELLOW}Stopping Ollama development container...${NC}"
+    docker stop ollama-dev
+    docker rm ollama-dev
+    echo -e "${GREEN}Ollama development container stopped${NC}"
+else
+    echo -e "${YELLOW}Ollama development container not running${NC}"
+fi
+
+echo -e "${GREEN}Development services stopped!${NC}"
+echo
+echo -e "${YELLOW}Note:${NC} Data volumes are preserved:"
+echo "  qdrant_dev_storage"
+echo "  ollama_dev_data"
+echo
+echo -e "${YELLOW}To completely remove data volumes:${NC}"
+echo "  docker volume rm qdrant_dev_storage ollama_dev_data"

package/bin/cli.js

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-
-const packageJson = require('../package.json');
-
-console.log(`${packageJson.name} v${packageJson.version}`);
-console.log('This is a placeholder package. Full implementation coming soon!');
-console.log('');
-console.log('Planned commands:');
-console.log('  directory-indexer index <paths...>     - Index directories');
-console.log('  directory-indexer search <query>       - Search indexed content');
-console.log('  directory-indexer similar <file>       - Find similar files');
-console.log('  directory-indexer serve                 - Start MCP server');
-console.log('  directory-indexer status                - Show indexing status');
-console.log('');
-console.log('GitHub: https://github.com/peteretelej/directory-indexer');
-
-process.exit(0);

package/index.js

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-
-console.log('Directory Indexer v0.0.1');
-console.log('This is a placeholder package. Full implementation coming soon!');
-console.log('');
-console.log('Stay tuned for:');
-console.log('- MCP server for semantic directory indexing');
-console.log('- Vector-based file search with AI assistants');
-console.log('- Support for multiple file formats');
-console.log('');
-console.log('GitHub: https://github.com/peteretelej/directory-indexer');
-
-process.exit(0);