@esotech/contextuate 2.1.0 → 2.1.2

package/dist/utils/tools.d.ts

@@ -0,0 +1,60 @@
+export interface ToolInfo {
+    installed: boolean;
+    version: string | null;
+    path: string | null;
+}
+export interface ToolsConfig {
+    ripgrep: ToolInfo;
+}
+export interface ContextuateConfig {
+    name: string;
+    version: string;
+    description: string;
+    repository: string;
+    initialized: string;
+    updated: string;
+    tools: ToolsConfig;
+}
+/**
+ * Detect ripgrep installation
+ */
+export declare function detectRipgrep(): ToolInfo;
+/**
+ * Detect all tools
+ */
+export declare function detectTools(): ToolsConfig;
+/**
+ * Detect the current operating system and package manager
+ */
+export declare function detectPlatform(): {
+    os: 'macos' | 'linux' | 'windows';
+    packageManager: string | null;
+};
+/**
+ * Install ripgrep using the appropriate package manager
+ */
+export declare function installRipgrep(): Promise<boolean>;
+/**
+ * Prompt user to install missing tools
+ */
+export declare function promptInstallTools(tools: ToolsConfig, nonInteractive?: boolean): Promise<ToolsConfig>;
+/**
+ * Process template variables in a file
+ */
+export declare function processTemplateVariables(content: string, tools: ToolsConfig): string;
+/**
+ * Process template variables in all files in a directory
+ */
+export declare function processTemplateDirectory(dir: string, tools: ToolsConfig): Promise<number>;
+/**
+ * Read contextuate.json config
+ */
+export declare function readContextuateConfig(installDir: string): Promise<ContextuateConfig | null>;
+/**
+ * Write contextuate.json config
+ */
+export declare function writeContextuateConfig(installDir: string, config: ContextuateConfig): Promise<void>;
+/**
+ * Print tool status
+ */
+export declare function printToolStatus(tools: ToolsConfig): void;

package/dist/utils/tools.js

@@ -0,0 +1,260 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectRipgrep = detectRipgrep;
+exports.detectTools = detectTools;
+exports.detectPlatform = detectPlatform;
+exports.installRipgrep = installRipgrep;
+exports.promptInstallTools = promptInstallTools;
+exports.processTemplateVariables = processTemplateVariables;
+exports.processTemplateDirectory = processTemplateDirectory;
+exports.readContextuateConfig = readContextuateConfig;
+exports.writeContextuateConfig = writeContextuateConfig;
+exports.printToolStatus = printToolStatus;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+/**
+ * Detect if a command exists and get its path
+ */
+function detectCommand(command) {
+    try {
+        const result = (0, child_process_1.execSync)(`which ${command}`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        return { exists: true, path: result.trim() };
+    }
+    catch {
+        return { exists: false, path: null };
+    }
+}
+/**
+ * Get ripgrep version
+ */
+function getRipgrepVersion(rgPath) {
+    try {
+        const result = (0, child_process_1.execSync)(`"${rgPath}" --version`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        const match = result.match(/ripgrep\s+(\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Detect ripgrep installation
+ */
+function detectRipgrep() {
+    const detection = detectCommand('rg');
+    if (!detection.exists) {
+        return { installed: false, version: null, path: null };
+    }
+    const version = getRipgrepVersion(detection.path);
+    return {
+        installed: true,
+        version,
+        path: detection.path
+    };
+}
+/**
+ * Detect all tools
+ */
+function detectTools() {
+    return {
+        ripgrep: detectRipgrep()
+    };
+}
+/**
+ * Detect the current operating system and package manager
+ */
+function detectPlatform() {
+    const platform = os_1.default.platform();
+    if (platform === 'darwin') {
+        // Check for Homebrew
+        const brew = detectCommand('brew');
+        return { os: 'macos', packageManager: brew.exists ? 'brew' : null };
+    }
+    if (platform === 'linux') {
+        // Check for common package managers
+        if (detectCommand('apt-get').exists) {
+            return { os: 'linux', packageManager: 'apt' };
+        }
+        if (detectCommand('dnf').exists) {
+            return { os: 'linux', packageManager: 'dnf' };
+        }
+        if (detectCommand('yum').exists) {
+            return { os: 'linux', packageManager: 'yum' };
+        }
+        if (detectCommand('pacman').exists) {
+            return { os: 'linux', packageManager: 'pacman' };
+        }
+        return { os: 'linux', packageManager: null };
+    }
+    if (platform === 'win32') {
+        // Check for common Windows package managers
+        if (detectCommand('choco').exists) {
+            return { os: 'windows', packageManager: 'choco' };
+        }
+        if (detectCommand('winget').exists) {
+            return { os: 'windows', packageManager: 'winget' };
+        }
+        return { os: 'windows', packageManager: null };
+    }
+    return { os: 'linux', packageManager: null };
+}
+/**
+ * Install ripgrep using the appropriate package manager
+ */
+async function installRipgrep() {
+    const platform = detectPlatform();
+    let installCommand;
+    switch (platform.packageManager) {
+        case 'brew':
+            installCommand = 'brew install ripgrep';
+            break;
+        case 'apt':
+            installCommand = 'sudo apt-get install -y ripgrep';
+            break;
+        case 'dnf':
+            installCommand = 'sudo dnf install -y ripgrep';
+            break;
+        case 'yum':
+            installCommand = 'sudo yum install -y ripgrep';
+            break;
+        case 'pacman':
+            installCommand = 'sudo pacman -S --noconfirm ripgrep';
+            break;
+        case 'choco':
+            installCommand = 'choco install ripgrep -y';
+            break;
+        case 'winget':
+            installCommand = 'winget install BurntSushi.ripgrep.MSVC';
+            break;
+        default:
+            console.log(chalk_1.default.yellow('[WARN] No supported package manager found.'));
+            console.log(chalk_1.default.blue('[INFO] Please install ripgrep manually:'));
+            console.log(chalk_1.default.gray('  - macOS: brew install ripgrep'));
+            console.log(chalk_1.default.gray('  - Ubuntu/Debian: sudo apt install ripgrep'));
+            console.log(chalk_1.default.gray('  - Fedora: sudo dnf install ripgrep'));
+            console.log(chalk_1.default.gray('  - Arch: sudo pacman -S ripgrep'));
+            console.log(chalk_1.default.gray('  - Windows: choco install ripgrep'));
+            console.log(chalk_1.default.gray('  - Or download from: https://github.com/BurntSushi/ripgrep/releases'));
+            return false;
+    }
+    console.log(chalk_1.default.blue(`[INFO] Installing ripgrep via ${platform.packageManager}...`));
+    console.log(chalk_1.default.gray(`  Running: ${installCommand}`));
+    return new Promise((resolve) => {
+        (0, child_process_1.exec)(installCommand, (error, stdout, stderr) => {
+            if (error) {
+                console.log(chalk_1.default.red(`[ERROR] Installation failed: ${error.message}`));
+                if (stderr) {
+                    console.log(chalk_1.default.gray(stderr));
+                }
+                resolve(false);
+            }
+            else {
+                console.log(chalk_1.default.green('[OK] ripgrep installed successfully'));
+                resolve(true);
+            }
+        });
+    });
+}
+/**
+ * Prompt user to install missing tools
+ */
+async function promptInstallTools(tools, nonInteractive = false) {
+    // Check ripgrep
+    if (!tools.ripgrep.installed && !nonInteractive) {
+        const { installRg } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'installRg',
+                message: 'ripgrep (rg) is not installed. Would you like to install it? (Recommended for faster code search)',
+                default: true,
+            },
+        ]);
+        if (installRg) {
+            const success = await installRipgrep();
+            if (success) {
+                // Re-detect after installation
+                tools.ripgrep = detectRipgrep();
+            }
+        }
+    }
+    return tools;
+}
+/**
+ * Process template variables in a file
+ */
+function processTemplateVariables(content, tools) {
+    // Replace {grep} with rg if ripgrep is installed, otherwise grep
+    const grepCommand = tools.ripgrep.installed ? 'rg' : 'grep';
+    return content.replace(/\{grep\}/g, grepCommand);
+}
+/**
+ * Process template variables in all files in a directory
+ */
+async function processTemplateDirectory(dir, tools) {
+    let processedCount = 0;
+    if (!fs_extra_1.default.existsSync(dir)) {
+        return processedCount;
+    }
+    const processDir = async (currentDir) => {
+        const entries = await fs_extra_1.default.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                await processDir(fullPath);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                const content = await fs_extra_1.default.readFile(fullPath, 'utf-8');
+                const processed = processTemplateVariables(content, tools);
+                if (content !== processed) {
+                    await fs_extra_1.default.writeFile(fullPath, processed);
+                    processedCount++;
+                }
+            }
+        }
+    };
+    await processDir(dir);
+    return processedCount;
+}
+/**
+ * Read contextuate.json config
+ */
+async function readContextuateConfig(installDir) {
+    const configPath = path_1.default.join(installDir, 'contextuate.json');
+    try {
+        if (fs_extra_1.default.existsSync(configPath)) {
+            const content = await fs_extra_1.default.readFile(configPath, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch {
+        // Config doesn't exist or is invalid
+    }
+    return null;
+}
+/**
+ * Write contextuate.json config
+ */
+async function writeContextuateConfig(installDir, config) {
+    const configPath = path_1.default.join(installDir, 'contextuate.json');
+    await fs_extra_1.default.writeFile(configPath, JSON.stringify(config, null, 2));
+}
+/**
+ * Print tool status
+ */
+function printToolStatus(tools) {
+    console.log('');
+    console.log(chalk_1.default.blue('[INFO] Tool Status:'));
+    if (tools.ripgrep.installed) {
+        console.log(chalk_1.default.green(`  [OK] ripgrep: ${tools.ripgrep.path} (v${tools.ripgrep.version})`));
+    }
+    else {
+        console.log(chalk_1.default.yellow('  [--] ripgrep: not installed (using grep fallback)'));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esotech/contextuate",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": "**Standardized AI Context for Software Projects**",
   "main": "dist/index.js",
   "bin": {
@@ -11,7 +11,7 @@
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "tsc && mkdir -p dist/templates && cp -r src/templates/* dist/templates/ && mkdir -p dist/monitor/hooks && cp src/monitor/hooks/emit-event.js dist/monitor/hooks/ && chmod +x dist/index.js dist/monitor/hooks/emit-event.js dist/monitor/daemon/cli.js dist/monitor/server/cli.js",
+    "build": "tsc && rm -rf dist/templates && mkdir -p dist/templates && cp -r src/templates/* dist/templates/ && mkdir -p dist/monitor/hooks && cp src/monitor/hooks/emit-event.js dist/monitor/hooks/ && chmod +x dist/index.js dist/monitor/hooks/emit-event.js dist/monitor/daemon/cli.js dist/monitor/server/cli.js",
     "build:monitor-ui": "cd src/monitor/ui && npm install && npm run build",
     "build:all": "npm run build && npm run build:monitor-ui",
     "prepublishOnly": "npm run build:all"

package/dist/templates/skills/orchestrate.md

@@ -1,173 +0,0 @@
-# /orchestrate - Orchestrator Mode Skill
-
-Activate the ARCHON agent for coordinated multi-agent task execution.
-
-## Agent Invocation
-
-**IMPORTANT:** Before proceeding, read and adopt the ARCHON agent persona:
-
-**Agent Definition:** [agents/archon.md](../agents/archon.md)
-
-Read the agent file above, then follow its guidelines for task analysis, delegation, and synthesis.
-
-## Usage
-
-```
-/orchestrate [task description]
-```
-
-## Behavior
-
-When this skill is invoked, read the ARCHON agent definition and adopt its persona to:
-
-1. **Analyze the task** to identify required domains and complexity
-2. **Delegate to specialist agents** rather than implementing directly
-3. **Coordinate handoffs** between agents for dependent tasks
-4. **Synthesize results** into a cohesive solution
-
-## Pre-Orchestration
-
-For complex or unfamiliar work, use `/consult` BEFORE `/orchestrate`:
-```
-/consult [research/plan topic]  →  produces specification
-/orchestrate [implement spec]   →  delegates to specialists
-```
-
-## Available Specialist Agents
-
-> **Agent Roster:** [agent-roles.md](../.contextuate/standards/agent-roles.md)
-
-Read the agent roster for the complete list of specialist agents with their domains and when to use each one.
-
-## Examples
-
-### Multi-domain feature
-```
-/orchestrate Add a new API endpoint with database query, validation, and tests
-```
-Result: Delegates to thoth (query), nexus (API), sentinel (validation), crucible (tests)
-
-### Code review workflow
-```
-/orchestrate Review the authentication module for security issues and suggest improvements
-```
-Result: Delegates to atlas (find files), sentinel (security analysis), aegis (code review)
-
-### Documentation task
-```
-/orchestrate Document the monitor feature architecture and create API reference
-```
-Result: Delegates to chronicle (architecture doc), scribe (API reference)
-
-## Orchestration Rules
-
-1. **Never implement directly** - Always delegate to specialist agents
-2. **Provide context** - Give agents specific file paths and patterns to follow
-3. **Track complex tasks** - Use ledger for multi-step work
-4. **Synthesize results** - Combine agent outputs into cohesive solution
-5. **Keep context clean** - Delegate to subagents to preserve main context window
-
-## Parallel Execution
-
-**CRITICAL: Always spawn independent agents in parallel.**
-
-When multiple agents can work independently (no dependencies between their outputs), you MUST launch them in a single message with multiple Task tool calls:
-
-```
-Good: Single message with parallel Task calls for independent work
-├── Task: atlas (find auth files)
-├── Task: thoth (analyze schema)
-└── Task: sentinel (security review)
-
-Bad: Sequential Task calls when work is independent
-├── Message 1: Task: atlas...
-├── Message 2: Task: thoth...
-└── Message 3: Task: sentinel...
-```
-
-**Parallel execution rules:**
-- Identify independent tasks that don't depend on each other's output
-- Launch all independent tasks in a single response
-- Only serialize tasks that have true dependencies
-- Use background execution (`run_in_background: true`) for long-running tasks when appropriate
-
-## File Contention & Conflict Avoidance
-
-When multiple agents may modify the same files, use the **Intent-First Locking Protocol**.
-
-> **Full Protocol:** [agent-workflow.md](../.contextuate/standards/agent-workflow.md#conflict-avoidance--file-locking)
-
-### Quick Reference
-
-**Step 1: Intent Declaration** - Before editing, agents declare intent:
-```yaml
-Status: PLANNING
-Intent:
-  - Modify: src/path/to/file.js
-  - Create: src/path/to/new-file.js
-```
-
-**Step 2: Archon Validation** - Check against Active Lock Table:
-- **Clear**: Lock the files, approve execution
-- **Conflict**: Queue the agent until files are released
-
-**Step 3: Resolution Options:**
-| Scenario | Resolution |
-|----------|------------|
-| Files are free | Lock and proceed |
-| Files locked by another agent | Queue and wait |
-| Highly parallel work | Use Git Worktree isolation |
-
-### Git Worktree Alternative
-For highly parallel tasks where locking is too restrictive:
-1. Create disposable Git worktree (branch) per agent
-2. Agent works entirely within worktree
-3. Agent commits and signals ready
-4. **Unity** merges branch into main
-
-## Agent Preference Order
-
-**CRITICAL: Prefer specialist agents over general-purpose agents.**
-
-When deciding which agent to use, follow this preference hierarchy:
-
-1. **Custom Specialist Agents** (STRONGLY PREFERRED)
-   - aegis, atlas, canvas, chronicle, chronos, cipher, crucible, echo, forge, ledger, meridian, nexus, thoth, scribe, sentinel, unity, vox, weaver
-   - These have domain-specific expertise and context
-
-2. **Built-in Specialized Agents** (Use only if no specialist fits)
-   - Plan, Explore, claude-code-guide
-
-3. **General-Purpose Agents** (AVOID unless absolutely necessary)
-   - general-purpose - Only use for truly generic tasks that don't fit any specialist
-
-**Examples:**
-| Task | Wrong Choice | Right Choice |
-|------|-------------|--------------|
-| Find files related to auth | general-purpose | **atlas** |
-| Write API documentation | general-purpose | **scribe** |
-| Review code quality | Explore | **aegis** |
-| Create database queries | general-purpose | **thoth** |
-| Build new component | general-purpose | **forge** (scaffold) + **canvas** (UI) |
-
-**Always ask: "Which specialist agent has domain expertise for this task?"**
-
-## Decision Tree
-
-```
-Is this a simple, single-domain task?
-├── YES → Delegate to single specialist
-└── NO → Break down and coordinate multiple specialists
-
-Does it require exploration first?
-├── YES → Start with atlas for navigation
-└── NO → Proceed to implementation agents
-
-Is this multi-step?
-├── YES → Engage ledger for tracking
-└── NO → Direct delegation
-
-Should we review the result?
-├── YES → aegis for quality, crucible for tests
-└── NO → Deliver directly
-```

package/dist/templates/skills/pythia.md

@@ -1,37 +0,0 @@
-# /pythia - Strategic Planning Oracle
-
-Alias for `/consult`. Activates the PYTHIA agent for strategic planning and research.
-
-## Agent Invocation
-
-**IMPORTANT:** Before proceeding, read and adopt the PYTHIA agent persona:
-
-**Agent Definition:** [agents/pythia.md](../agents/pythia.md)
-
-Read the agent file above, then follow its guidelines for research, synthesis, and specification creation.
-
-## Usage
-
-```
-/pythia [topic or question]
-```
-
-See [/consult](./consult.md) for full documentation and behavior details.
-
-## Quick Reference
-
-| Command | Purpose |
-|---------|---------|
-| `/pythia [topic]` | Research and plan before implementation |
-| `/consult [topic]` | Same as `/pythia` |
-| `/orchestrate [task]` | Execute implementation with specialist agents |
-
-## Example Flow
-
-```
-/pythia How should we implement real-time notifications?
-    |
-[PYTHIA produces specification]
-    |
-/orchestrate Implement the notification system per spec
-```