profclaw 0.0.1-beta.1

package/dist/voice/wake-word.js

@@ -0,0 +1,145 @@
+/**
+ * Wake Word Detection Stub
+ *
+ * profClaw uses shortcut/button activation instead of always-on wake word
+ * detection so it does not burn API credits while idle. This module provides
+ * the interface and a simple energy-based detection fallback for callers that
+ * want basic "someone started talking" triggering without a real ML engine.
+ *
+ * Supported engines:
+ *   - 'none'      - disabled (no-op)
+ *   - 'energy'    - amplitude threshold (not real keyword spotting)
+ *   - 'porcupine' - stub, reserved for future add-on
+ */
+import { logger } from '../utils/logger.js';
+// Factory
+/**
+ * Create a wake word detector for the given configuration.
+ * Currently only 'energy' and 'none' are implemented.
+ * Requesting 'porcupine' falls back to 'energy' with a warning.
+ */
+export function createWakeWordDetector(config) {
+    const resolvedEngine = resolveEngine(config.engine);
+    switch (resolvedEngine) {
+        case 'energy':
+            return new EnergyDetector(config);
+        case 'none':
+        default:
+            return new NoopDetector();
+    }
+}
+function resolveEngine(engine) {
+    if (engine === 'porcupine') {
+        logger.warn('[WakeWord] Porcupine engine is not yet implemented - falling back to energy-based detection', { component: 'WakeWord' });
+        return 'energy';
+    }
+    return engine;
+}
+// NoopDetector - engine: 'none'
+class NoopDetector {
+    listening = false;
+    startedAt = null;
+    async start() {
+        this.listening = true;
+        this.startedAt = Date.now();
+        logger.debug('[WakeWord] Noop detector started (detection disabled)', { component: 'WakeWord' });
+    }
+    stop() {
+        this.listening = false;
+        this.startedAt = null;
+        logger.debug('[WakeWord] Noop detector stopped', { component: 'WakeWord' });
+    }
+    isListening() {
+        return this.listening;
+    }
+    getStats() {
+        return {
+            detections: 0,
+            falsePositives: 0,
+            uptime: this.startedAt != null ? Date.now() - this.startedAt : 0,
+        };
+    }
+}
+// EnergyDetector - engine: 'energy'
+/**
+ * Simple amplitude-threshold detection.
+ *
+ * NOT real wake-word spotting - it only detects when audio energy exceeds a
+ * threshold, which acts as "someone started talking". Returns a fixed
+ * confidence of 0.3 to signal to callers that this is a low-quality signal.
+ *
+ * Audio samples are fed via `processSample()`. In a real deployment the
+ * microphone capture loop would call this with 16-bit PCM values.
+ */
+class EnergyDetector {
+    config;
+    listening = false;
+    startedAt = null;
+    detections = 0;
+    falsePositives = 0;
+    // Energy threshold derived from sensitivity: higher sensitivity -> lower threshold
+    get energyThreshold() {
+        // Map sensitivity [0,1] to threshold [0.8, 0.1] (inverse relationship)
+        return Math.max(0.05, 0.9 - this.config.sensitivity * 0.8);
+    }
+    constructor(config) {
+        this.config = config;
+    }
+    async start() {
+        this.listening = true;
+        this.startedAt = Date.now();
+        this.detections = 0;
+        this.falsePositives = 0;
+        logger.info('[WakeWord] Energy detector started', {
+            component: 'WakeWord',
+            phrase: this.config.phrase,
+            sensitivity: this.config.sensitivity,
+            energyThreshold: this.energyThreshold,
+        });
+    }
+    stop() {
+        this.listening = false;
+        const uptime = this.startedAt != null ? Date.now() - this.startedAt : 0;
+        this.startedAt = null;
+        logger.info('[WakeWord] Energy detector stopped', {
+            component: 'WakeWord',
+            detections: this.detections,
+            uptime,
+        });
+    }
+    isListening() {
+        return this.listening;
+    }
+    getStats() {
+        return {
+            detections: this.detections,
+            falsePositives: this.falsePositives,
+            uptime: this.startedAt != null ? Date.now() - this.startedAt : 0,
+        };
+    }
+    /**
+     * Feed a normalized audio sample (value in [-1.0, 1.0]) to the detector.
+     * When the absolute amplitude exceeds the threshold the wake callback fires.
+     *
+     * Callers in the microphone capture loop should call this for each PCM frame.
+     * The confidence returned is always 0.3 (low) because energy detection is not
+     * real keyword spotting.
+     */
+    processSample(sample) {
+        if (!this.listening)
+            return;
+        const energy = Math.abs(sample);
+        if (energy >= this.energyThreshold) {
+            this.detections++;
+            const confidence = 0.3; // fixed low confidence - not real keyword spotting
+            logger.debug('[WakeWord] Energy threshold exceeded', {
+                component: 'WakeWord',
+                energy,
+                threshold: this.energyThreshold,
+                confidence,
+            });
+            this.config.onDetected?.(confidence);
+        }
+    }
+}
+//# sourceMappingURL=wake-word.js.map

package/docker-compose.yml

@@ -0,0 +1,222 @@
+# Profiles:
+#   (default)   profclaw (pro mode) + redis
+#   pico        profclaw (pico mode) -- no redis, no UI
+#   ai          + ollama (free local AI)
+#   tools       + redis-commander
+#   monitoring  + prometheus + grafana
+#
+# Quick start per mode:
+#   docker compose up -d                                  # pro (default)
+#   docker compose up -d profclaw-pico                    # pico only (minimal)
+#   docker compose --profile ai up -d                     # pro + ollama
+#
+# NOTE: `docker compose --profile pico up -d` starts pico AND pro (port conflict).
+#       Use `docker compose up -d profclaw-pico` for pico-only.
+
+services:
+  # ===================
+  # profClaw Task Manager
+  # ===================
+  profclaw:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: profclaw
+    ports:
+      - "${PORT:-3000}:3000"
+    environment:
+      # Core
+      - NODE_ENV=production
+      - PORT=3000
+      - PROFCLAW_MODE=pro
+      # Redis
+      - REDIS_URL=redis://redis:6379
+      - PROFCLAW_REQUIRE_REDIS=true
+      # Database
+      - DATABASE_URL=file:/app/data/profclaw.db
+      # OpenClaw
+      - OPENCLAW_BASE_URL=${OPENCLAW_BASE_URL:-http://host.docker.internal:18789}
+      - OPENCLAW_GATEWAY_TOKEN=${OPENCLAW_GATEWAY_TOKEN}
+      - OPENCLAW_WORKING_DIR=/workspace
+      # GitHub
+      - GITHUB_TOKEN=${GITHUB_TOKEN}
+      - GITHUB_WEBHOOK_SECRET=${GITHUB_WEBHOOK_SECRET}
+      - GITHUB_AI_TASK_LABEL=${GITHUB_AI_TASK_LABEL:-ai-task}
+      # Task Queue
+      - TASK_CONCURRENCY=${TASK_CONCURRENCY:-2}
+      # AI Providers (optional)
+      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
+      - OPENAI_API_KEY=${OPENAI_API_KEY}
+      - AZURE_OPENAI_API_KEY=${AZURE_OPENAI_API_KEY}
+      - AZURE_OPENAI_ENDPOINT=${AZURE_OPENAI_ENDPOINT}
+      - GROQ_API_KEY=${GROQ_API_KEY}
+      # Ollama (free local AI)
+      - OLLAMA_BASE_URL=${OLLAMA_BASE_URL:-http://ollama:11434}
+      # Tool Execution
+      - POOL_MAX_CONCURRENT=${POOL_MAX_CONCURRENT:-50}
+      - POOL_TIMEOUT_MS=${POOL_TIMEOUT_MS:-300000}
+    volumes:
+      - profclaw-data:/app/data
+      - workspace:/workspace
+    depends_on:
+      redis:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 10s
+    restart: unless-stopped
+    networks:
+      - profclaw-network
+
+  # ===================
+  # profClaw Pico (minimal, no Redis)
+  # ===================
+  profclaw-pico:
+    build:
+      context: .
+      dockerfile: Dockerfile.pico
+    container_name: profclaw-pico
+    ports:
+      - "${PORT:-3000}:3000"
+    environment:
+      - NODE_ENV=production
+      - PORT=3000
+      - PROFCLAW_MODE=pico
+      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
+      - OPENAI_API_KEY=${OPENAI_API_KEY}
+      - OLLAMA_BASE_URL=${OLLAMA_BASE_URL:-http://host.docker.internal:11434}
+    volumes:
+      - profclaw-data:/app/data
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 5s
+    restart: unless-stopped
+    profiles:
+      - pico
+    networks:
+      - profclaw-network
+
+  # ===================
+  # Redis (Task Queue)
+  # ===================
+  redis:
+    image: redis:7-alpine
+    container_name: profclaw-redis
+    ports:
+      - "${REDIS_PORT:-6379}:6379"
+    volumes:
+      - redis-data:/data
+    command: redis-server --appendonly yes --maxmemory 256mb --maxmemory-policy allkeys-lru
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    restart: unless-stopped
+    networks:
+      - profclaw-network
+
+  # ===================
+  # Ollama (Free Local AI)
+  # ===================
+  ollama:
+    image: ollama/ollama:latest
+    container_name: profclaw-ollama
+    volumes:
+      - ollama-data:/root/.ollama
+    ports:
+      - "${OLLAMA_PORT:-11434}:11434"
+    profiles:
+      - ai
+    healthcheck:
+      test: ["CMD-SHELL", "curl -sf http://localhost:11434/api/tags || exit 1"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 30s
+    restart: unless-stopped
+    networks:
+      - profclaw-network
+
+  # ===================
+  # Redis Commander (Dev Tools)
+  # ===================
+  redis-commander:
+    image: rediscommander/redis-commander:latest
+    container_name: profclaw-redis-ui
+    environment:
+      - REDIS_HOSTS=profclaw:redis:6379
+    ports:
+      - "${REDIS_COMMANDER_PORT:-8081}:8081"
+    depends_on:
+      redis:
+        condition: service_healthy
+    profiles:
+      - tools
+    networks:
+      - profclaw-network
+
+  # ===================
+  # Prometheus (Metrics)
+  # ===================
+  prometheus:
+    image: prom/prometheus:latest
+    container_name: profclaw-prometheus
+    ports:
+      - "${PROMETHEUS_PORT:-9090}:9090"
+    volumes:
+      - ./docker/prometheus.yml:/etc/prometheus/prometheus.yml:ro
+      - prometheus-data:/prometheus
+    command:
+      - '--config.file=/etc/prometheus/prometheus.yml'
+      - '--storage.tsdb.path=/prometheus'
+      - '--storage.tsdb.retention.time=15d'
+    profiles:
+      - monitoring
+    networks:
+      - profclaw-network
+
+  # ===================
+  # Grafana (Dashboards)
+  # ===================
+  grafana:
+    image: grafana/grafana:latest
+    container_name: profclaw-grafana
+    ports:
+      - "${GRAFANA_PORT:-3001}:3000"
+    environment:
+      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD:-admin}
+      - GF_USERS_ALLOW_SIGN_UP=false
+    volumes:
+      - grafana-data:/var/lib/grafana
+      - ./docker/grafana/provisioning:/etc/grafana/provisioning:ro
+    depends_on:
+      - prometheus
+    profiles:
+      - monitoring
+    networks:
+      - profclaw-network
+
+volumes:
+  profclaw-data:
+    driver: local
+  redis-data:
+    driver: local
+  workspace:
+    driver: local
+  ollama-data:
+    driver: local
+  prometheus-data:
+    driver: local
+  grafana-data:
+    driver: local
+
+networks:
+  profclaw-network:
+    driver: bridge

package/package.json

@@ -0,0 +1,154 @@
+{
+  "name": "profclaw",
+  "version": "0.0.1-beta.1",
+  "description": "Smart, lightweight AI agent engine -- run locally on anything from a $10 board to a VPS",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./cli": {
+      "import": "./dist/cli/index.js"
+    },
+    "./cli-entry": "./profclaw.mjs",
+    "./mcp": {
+      "import": "./dist/mcp/server.js"
+    },
+    "./plugins/sdk": {
+      "import": "./dist/plugins/sdk.js",
+      "types": "./dist/plugins/sdk.d.ts"
+    }
+  },
+  "bin": {
+    "profclaw": "profclaw.mjs",
+    "profclaw-mcp": "./dist/mcp/server.js"
+  },
+  "files": [
+    "profclaw.mjs",
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.json",
+    "ui/dist/**",
+    "config/**",
+    "skills/**",
+    "docker-compose.yml",
+    "Dockerfile",
+    ".env.example",
+    "README.md",
+    "LICENSE",
+    "CONTRIBUTING.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "dev": "pnpm kill:ports && concurrently -n api,ui -c blue,magenta \"pnpm dev:api\" \"pnpm dev:ui\"",
+    "dev:api": "tsx watch src/server.ts",
+    "dev:ui": "pnpm --dir ui dev",
+    "kill:ports": "lsof -ti :3000 | xargs kill -9 2>/dev/null || true; lsof -ti :5173 | xargs kill -9 2>/dev/null || true",
+    "build": "tsc && pnpm --dir ui build",
+    "prepublishOnly": "pnpm build",
+    "start": "node dist/server.js",
+    "profclaw": "node profclaw.mjs",
+    "mcp": "node dist/mcp/server.js",
+    "mcp:dev": "tsx src/mcp/server.ts",
+    "cli": "tsx src/cli/index.ts",
+    "cli:dev": "tsx watch src/cli/index.ts",
+    "db:migrate": "drizzle-kit migrate",
+    "db:generate": "drizzle-kit generate",
+    "db:studio": "drizzle-kit studio",
+    "test": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:ui": "vitest --ui",
+    "lint": "eslint src/",
+    "ui": "pnpm --dir ui dev"
+  },
+  "keywords": [
+    "ai-agent",
+    "task-manager",
+    "project-management",
+    "mcp",
+    "model-context-protocol",
+    "agentic",
+    "claude",
+    "openai",
+    "ollama",
+    "automation",
+    "github-integration",
+    "jira-integration",
+    "linear-integration",
+    "slack-bot",
+    "discord-bot",
+    "telegram-bot"
+  ],
+  "author": "profClaw <dev@profclaw.dev>",
+  "license": "AGPL-3.0",
+  "homepage": "https://profclaw.dev",
+  "bugs": {
+    "url": "https://github.com/profclaw/profclaw/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/profclaw/profclaw.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.35",
+    "@ai-sdk/azure": "^3.0.26",
+    "@ai-sdk/google": "^3.0.20",
+    "@ai-sdk/openai": "^3.0.25",
+    "@hono/node-server": "^1.13.8",
+    "@hono/zod-validator": "^0.4.3",
+    "@libsql/client": "^0.17.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "ai": "^6.0.68",
+    "ai-sdk-ollama": "^3.3.0",
+    "bullmq": "^5.34.8",
+    "chalk": "^5.4.1",
+    "chokidar": "^5.0.0",
+    "cli-table3": "^0.6.5",
+    "commander": "^13.1.0",
+    "dockerode": "^4.0.9",
+    "drizzle-orm": "^0.39.1",
+    "figlet": "^1.8.0",
+    "glob": "^13.0.1",
+    "hono": "^4.6.16",
+    "ioredis": "^5.4.2",
+    "js-yaml": "^4.1.1",
+    "minimatch": "^10.1.2",
+    "node-pty": "^1.1.0",
+    "openai": "^6.17.0",
+    "ora": "^8.1.1",
+    "playwright-core": "^1.58.1",
+    "postgres": "^3.4.5",
+    "proper-lockfile": "^4.1.2",
+    "sqlite-vec": "0.1.7-alpha.2",
+    "sqlite3": "^5.1.7",
+    "zod": "^3.24.1",
+    "zod-to-json-schema": "^3.25.1"
+  },
+  "devDependencies": {
+    "@types/dockerode": "^4.0.1",
+    "@types/figlet": "^1.7.0",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.10.7",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/sqlite3": "^5.1.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "@vitest/ui": "^4.0.18",
+    "concurrently": "^9.1.2",
+    "drizzle-kit": "^0.30.2",
+    "eslint": "^9.18.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.54.0",
+    "vitest": "^4.0.18"
+  }
+}

package/profclaw.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+import module from "node:module";
+
+// Enable V8 compile cache for faster startup
+// https://nodejs.org/api/module.html#module-compile-cache
+if (module.enableCompileCache && !process.env.NODE_DISABLE_COMPILE_CACHE) {
+  try {
+    module.enableCompileCache();
+  } catch {
+    // Ignore errors
+  }
+}
+
+// Suppress noisy logs for quick CLI queries (--version, --help, completion)
+if (!process.env.LOG_LEVEL) {
+  const quietArgs = ['--version', '-v', '--help', '-h', 'completion'];
+  const isQuiet = process.argv.length <= 2 || process.argv.some(a => quietArgs.includes(a));
+  if (isQuiet) {
+    process.env.LOG_LEVEL = 'WARN';
+  }
+}
+
+await import("./dist/cli/index.js");

package/skills/1password/SKILL.md

@@ -0,0 +1,155 @@
+---
+name: 1password
+description: Retrieve and manage secrets from 1Password using the op CLI. Supports item lookup, field access, and environment injection.
+version: 1.0.0
+metadata: {"profclaw": {"emoji": "🔐", "category": "security", "priority": 60, "triggerPatterns": ["1password", "password", "op", "secret", "credential", "retrieve secret", "get password", "1pass"]}}
+---
+
+# 1Password
+
+You are a 1Password CLI assistant. When users need to retrieve credentials, inject secrets into commands, or manage items in their 1Password vault, you use the `op` CLI securely.
+
+## What This Skill Does
+
+- Retrieves secrets and credentials from 1Password vaults
+- Injects secrets into commands and environment variables
+- Lists vaults and items (without revealing values)
+- Creates and updates vault items
+- Uses Service Account tokens for headless/automated use
+
+## Checking op CLI is Available
+
+```bash
+which op && op --version
+# Install: brew install 1password-cli (macOS)
+# Or: https://developer.1password.com/docs/cli/get-started
+```
+
+## Authentication
+
+```bash
+# Interactive sign-in (opens browser or prompts)
+eval $(op signin)
+
+# Service Account (for automated/headless use)
+export OP_SERVICE_ACCOUNT_TOKEN="your-token-here"
+op whoami  # verify auth
+```
+
+## Reading Secrets
+
+```bash
+# Get a specific field from an item
+op item get "My Server" --field password
+
+# Get a field by reference (URI format)
+op read "op://Personal/My Server/password"
+
+# Get a username
+op item get "GitHub" --field username
+
+# Get the full item as JSON
+op item get "My Server" --format json
+```
+
+## Environment Variable Injection
+
+```bash
+# Inject secrets into a command without exposing them in shell history
+op run --env-file=.env.op -- node dist/server.js
+
+# Inline injection using op:// references in .env.op:
+# DATABASE_URL=op://Work/Production DB/connection_string
+# API_KEY=op://Work/OpenAI/credential
+```
+
+## Listing Vaults and Items
+
+```bash
+# List all vaults
+op vault list
+
+# List items in a vault
+op item list --vault "Personal"
+
+# Search for an item by name
+op item list --categories Login | grep -i github
+
+# List without revealing secrets (safe to share output)
+op item get "GitHub" --format json | \
+  python3 -c "
+import json,sys
+d=json.load(sys.stdin)
+print(f\"Title: {d['title']}\")
+print(f\"Category: {d['category']}\")
+fields = [f['label'] for f in d.get('fields', []) if f.get('label')]
+print(f\"Fields: {', '.join(fields)}\")
+"
+```
+
+## Creating Items
+
+```bash
+# Create a new Login item
+op item create \
+  --category Login \
+  --title "New Service" \
+  --vault "Work" \
+  --url "https://service.example.com" \
+  username="user@example.com" \
+  password="$(op generate password)"
+
+# Generate a strong password
+op generate password --length 32 --symbols
+```
+
+## Updating Items
+
+```bash
+# Update a specific field
+op item edit "My Server" password="new-secure-password"
+
+# Add a new field
+op item edit "My Server" notes="Updated on $(date)"
+```
+
+## Using References in Config Files
+
+Instead of hardcoding secrets, use `op://` references:
+
+```bash
+# .env.op file (safe to commit - no actual secrets)
+DATABASE_URL=op://Work/Postgres/connection_string
+OPENAI_API_KEY=op://Work/OpenAI/credential
+REDIS_URL=op://Work/Redis/url
+
+# Run with injected secrets
+op run --env-file=.env.op -- pnpm dev
+```
+
+## Example Interactions
+
+**User**: Get my GitHub token from 1Password
+**You**: *(checks op auth, runs `op item get "GitHub" --field credential`, returns value)*
+
+**User**: List all items in my Work vault
+**You**: *(runs `op item list --vault Work`, shows titles and categories without revealing secrets)*
+
+**User**: Inject my production secrets and start the server
+**You**: *(runs `op run --env-file=.env.op -- node dist/server.js`)*
+
+## Safety Rules
+
+- **Never** print secret values to logs or visible output unless explicitly requested
+- **Never** store secrets in files without encryption (use .env.op with op:// refs)
+- **Always** use `op run` for injecting secrets into processes - not shell variables
+- **Confirm** before creating or modifying vault items
+- **Mask** credentials when showing command examples
+
+## Best Practices
+
+1. Use `op run` with `--env-file` for all secret injection - avoids shell history exposure
+2. Use `op://` references in config files instead of actual values
+3. Prefer Service Account tokens for automated pipelines
+4. Use `op generate password` when creating new credentials
+5. Keep separate vaults for Personal, Work, and Shared team credentials