erosolar-cli 1.0.2 → 1.0.3

package/scripts/health-check.mjs

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+
+import { readFileSync, existsSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+
+// Simplified color handling using Node.js built-in support
+const colors = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m'
+};
+
+function logSuccess(message) {
+  console.log(`${colors.green}✅${colors.reset} ${message}`);
+}
+
+function logError(message) {
+  console.log(`${colors.red}❌${colors.reset} ${message}`);
+}
+
+function logWarning(message) {
+  console.log(`${colors.yellow}⚠️${colors.reset} ${message}`);
+}
+
+function logInfo(message) {
+  console.log(`${colors.blue}ℹ️${colors.reset} ${message}`);
+}
+
+function checkFileExists(path, description = path) {
+  if (existsSync(path)) {
+    logSuccess(`${description} - Exists`);
+    return true;
+  } else {
+    logError(`${description} - Missing`);
+    return false;
+  }
+}
+
+function checkJsonFile(path, description = path) {
+  if (!existsSync(path)) {
+    logError(`${description} - Missing`);
+    return null;
+  }
+  
+  try {
+    const content = JSON.parse(readFileSync(path, 'utf8'));
+    logSuccess(`${description} - Valid JSON`);
+    return content;
+  } catch (error) {
+    logError(`${description} - Invalid JSON: ${error.message}`);
+    return null;
+  }
+}
+
+console.log(`${colors.cyan}🧪 Erosolar CLI Health Check${colors.reset}\n`);
+
+let hasErrors = false;
+let hasWarnings = false;
+
+// Check Node version
+console.log(`${colors.magenta}📦 Node.js Environment${colors.reset}`);
+const nodeVersion = process.version;
+const [major] = process.versions.node.split('.').map(Number);
+console.log(`   Version: ${nodeVersion}`);
+
+if (major >= 20) {
+  logSuccess(`Node.js version meets requirement (>=20.0.0)`);
+} else {
+  logError(`Node.js 20.0.0 or newer is required`);
+  hasErrors = true;
+}
+
+// Check package.json configuration
+console.log(`\n${colors.magenta}📋 Package Configuration${colors.reset}`);
+const packageJson = checkJsonFile('package.json', 'Package.json');
+
+if (packageJson) {
+  const requiredFields = ['name', 'version', 'description', 'main', 'bin'];
+  const missingFields = requiredFields.filter(field => !packageJson[field]);
+
+  if (missingFields.length === 0) {
+    logSuccess('Package.json configuration valid');
+  } else {
+    logError(`Missing required fields: ${missingFields.join(', ')}`);
+    hasErrors = true;
+  }
+
+  // Check erosolar-specific configuration
+  if (packageJson.erosolar?.rulebookSchema) {
+    logSuccess('Erosolar rulebook schema configured');
+  } else {
+    logWarning('Erosolar rulebook schema not configured in package.json');
+    hasWarnings = true;
+  }
+}
+
+// Check TypeScript compilation
+console.log(`\n${colors.magenta}🔧 TypeScript & Build${colors.reset}`);
+if (checkFileExists('dist', 'Build directory')) {
+  // Check main binary
+  if (checkFileExists('dist/bin/erosolar.js', 'Main binary')) {
+    // Check bin file permissions
+    const binCheck = spawnSync('ls', ['-la', 'dist/bin/erosolar.js'], { encoding: 'utf8' });
+    if (binCheck.status === 0 && binCheck.stdout.includes('-rwx')) {
+      logSuccess('Binary is executable');
+    } else {
+      logWarning('Binary is not executable');
+      hasWarnings = true;
+    }
+  }
+} else {
+  logWarning('Build directory does not exist - run \'npm run build\'');
+  hasWarnings = true;
+}
+
+// Check agent schema document
+console.log(`\n${colors.magenta}📚 Agent Schema${colors.reset}`);
+const agentsDocPath = 'Agents.md';
+if (checkFileExists(agentsDocPath, 'Agents.md manifest')) {
+  const content = readFileSync(agentsDocPath, 'utf8');
+  if (/```json\s+manifest/.test(content)) {
+    logSuccess('Agents.md contains a manifest block');
+  } else {
+    logError('Agents.md is missing a ```json manifest block');
+    hasErrors = true;
+  }
+
+  const rulebookMatches = [...content.matchAll(/```json\s+rulebook\s+([^\s`]+)[\s\S]*?```/g)];
+  if (rulebookMatches.length >= 1) {
+    logSuccess(`Agents.md contains ${rulebookMatches.length} rulebook block(s)`);
+  } else {
+    logError('Agents.md must include at least one ```json rulebook <profile> block');
+    hasErrors = true;
+  }
+} else {
+  hasErrors = true;
+}
+
+// Check rulebook schema
+console.log(`\n${colors.magenta}📄 Schema Validation${colors.reset}`);
+checkFileExists('src/contracts/schemas/agent-rules.schema.json', 'Agent rules schema');
+
+// Check core dependencies
+console.log(`\n${colors.magenta}📦 Core Dependencies${colors.reset}`);
+const coreFiles = [
+  'src/core/agent.ts',
+  'src/core/agentRulebook.ts', 
+  'src/core/toolRuntime.ts',
+  'src/providers/providerFactory.ts',
+  'src/capabilities/index.ts'
+];
+
+coreFiles.forEach(file => checkFileExists(file, file));
+
+// Summary
+console.log(`\n${colors.cyan}📊 Health Check Summary${colors.reset}`);
+
+if (hasErrors) {
+  console.log(`${colors.red}❌ Health check failed with errors${colors.reset}`);
+  console.log(`${colors.yellow}💡 Run 'npm run build' to rebuild the project${colors.reset}`);
+  console.log(`${colors.yellow}💡 Run 'npm test' to verify functionality${colors.reset}`);
+  process.exit(1);
+} else if (hasWarnings) {
+  console.log(`${colors.yellow}⚠️ Health check completed with warnings${colors.reset}`);
+  console.log(`${colors.yellow}💡 Review warnings above and address as needed${colors.reset}`);
+  process.exit(0);
+} else {
+  console.log(`${colors.green}🎉 Health check passed successfully!${colors.reset}`);
+  console.log(`${colors.green}✅ The CLI is ready for use${colors.reset}`);
+  console.log(`\n${colors.cyan}💡 Next steps:${colors.reset}`);
+  console.log('   Run \'erosolar\' to start the CLI');
+  console.log('   Run \'npm test\' for full test suite');
+  console.log('   Run \'npm run build\' to rebuild if needed');
+  process.exit(0);
+}

package/ARCHITECTURE.json

@@ -1,157 +0,0 @@
-{
-  "document": {
-    "title": "erosolar Editing Architecture",
-    "schema": "architecture.v2",
-    "version": "2.0.0",
-    "lastUpdated": "2025-11-16",
-    "maintainer": "Minimal Erosolar Code Agent"
-  },
-  "editingNorthStar": "Every edit must cite deterministic workspace evidence so hallucinations cannot slip into patches or reviews.",
-  "hallucinationObjectives": [
-    {
-      "id": "lock_truth",
-      "statement": "Freeze the exact repo snapshot before editing begins so subsequent reasoning cannot invent files, paths, or metadata."
-    },
-    {
-      "id": "minimize_context",
-      "statement": "Keep the prompt appendix to the essential tree + canonical docs so LLM context windows are not wasted on stale chatter."
-    },
-    {
-      "id": "metadata_reentry",
-      "statement": "Expose metadata-only tools that replay the frozen snapshot verbatim whenever the model needs to re-ground itself mid-edit."
-    },
-    {
-      "id": "operator_loop_supervision",
-      "statement": "Let the agent continue calling tools until it ships a cited answer while making it easy for humans to interrupt if it stalls."
-    }
-  ],
-  "knowledgeChannels": [
-    {
-      "id": "deterministic_snapshot",
-      "source": "src/workspace.ts",
-      "payload": "Depth-2 directory tree plus 2000-character excerpts from README.md, SOURCE_OF_TRUTH.json, ARCHITECTURE.json, and package.json.",
-      "purpose": "Provides the single editing reference frame shared by prompts and tools."
-    },
-    {
-      "id": "prompt_appendix",
-      "source": "src/config.ts",
-      "payload": "Agent guardrails from Agents.md plus the frozen snapshot appended to the system prompt of both Erosolar Code and General agents.",
-      "purpose": "Bootstraps the very first editing turn with verifiable facts."
-    },
-    {
-      "id": "metadata_tools",
-      "source": "src/core/toolRuntime.ts",
-      "payload": ["context_snapshot", "capabilities_overview", "profile_details"],
-      "purpose": "Replay the captured data verbatim mid-edit without re-reading the filesystem."
-    }
-  ],
-  "editingPipeline": [
-    {
-      "stage": "capture_lock",
-      "module": "src/workspace.ts",
-      "responsibility": "Scan the repo deterministically, drop noisy folders (.git, node_modules, dist), and output the frozen editing snapshot.",
-      "editingImpact": "Gives editing sessions a canonical baseline and surfaces an explicit error when capture fails."
-    },
-    {
-      "stage": "prompt_appendix",
-      "module": "src/config.ts",
-      "responsibility": "Resolve the active agent, merge env overrides, and glue the snapshot to the model system prompt.",
-      "editingImpact": "Keeps the first editing turn grounded and identical across providers."
-    },
-    {
-      "stage": "capability_composer",
-      "module": "src/runtime/agentHost.ts",
-      "responsibility": "Load capability modules (filesystem, bash, research connectors, MCP bridges) and emit the exact tool suites that enter the runtime.",
-      "editingImpact": "Decouples tooling from the UI so the same agent can run inside a CLI, browser worker, or cloud orchestrator without refactoring."
-    },
-    {
-      "stage": "metadata_runtime",
-      "module": "src/core/toolRuntime.ts",
-      "responsibility": "Register metadata-only tools that simply echo cached truth blobs.",
-      "editingImpact": "Lets the model rehearse facts repeatedly without risking hallucinated side effects."
-    },
-    {
-      "stage": "agent_loop",
-      "module": "src/core/agent.ts",
-      "responsibility": "Orchestrate prompts, respond to tool calls synchronously, and stream until the provider emits a final message.",
-      "editingImpact": "Allows legitimate multi-step edits to finish while keeping operators aware of every intermediate turn."
-    }
-  ],
-  "components": [
-    {
-      "id": "WorkspaceContext",
-      "file": "src/workspace.ts",
-      "responsibilities": [
-        "Produce a deterministic directory map capped at depth 2 / 200 entries.",
-        "Slice README.md, SOURCE_OF_TRUTH.json, ARCHITECTURE.json, and package.json to 2000 characters each.",
-        "Emit descriptive errors when capture cannot complete so the agent pauses editing until a new snapshot is available."
-      ],
-      "editingBenefit": "The edit session can quote exact file paths and doc excerpts without guessing."
-    },
-    {
-      "id": "PromptAppendix",
-      "file": "src/config.ts",
-      "responsibilities": [
-        "Resolve provider + model for the general and Erosolar Code agents with safe env overrides.",
-        "Append the frozen snapshot to the guardrail text before the agent speaks.",
-        "Mirror prompts between providers so edits look identical regardless of backend."
-      ],
-      "editingBenefit": "Both providers share the same edit-ready context, preventing provider-specific hallucinations."
-    },
-    {
-      "id": "MetadataToolRuntime",
-      "file": "src/core/toolRuntime.ts",
-      "responsibilities": [
-        "Expose context_snapshot, capabilities_overview, and profile_details (see Agents.md) as immutable tools.",
-        "Serialize responses exactly as captured—no synthesis, no side effects.",
-        "Log tool start/result/error events for auditability."
-      ],
-      "editingBenefit": "Editors can re-check facts mid-patch without touching the filesystem or adding new context noise."
-    },
-    {
-      "id": "AgentRuntimeController",
-      "file": "src/core/agent.ts",
-      "responsibilities": [
-        "Inject the prompt appendix, record conversation state, and gate tool responses.",
-        "Stream unlimited tool passes so complex edits can finish without artificial cutoffs.",
-        "Emit each assistant/tool turn so operators can interrupt and gather more evidence whenever the run stalls."
-      ],
-      "editingBenefit": "Keeps humans informed without forcing premature stops during legitimate multi-step refactors."
-    },
-    {
-      "id": "CapabilityHost",
-      "file": "src/runtime/agentHost.ts",
-      "responsibilities": [
-        "Compose CapabilityModule implementations into deterministic ToolSuite arrays before AgentSession spins up.",
-        "Track contribution metadata and enforce unique suite ids so multiple connectors (e.g., Google Sheets, MCP servers, or archive movers) can coexist.",
-        "Provide a deployment-agnostic manifest that any frontend (shell, browser, CI runner) can inspect to decide which modules are active."
-      ],
-      "editingBenefit": "Operators can add or remove integrations without touching UI code, which keeps deployments reliable across different environments."
-    }
-  ],
-  "guardrails": [
-    {
-      "id": "snapshot_lock",
-      "statement": "No editing session proceeds without a freshly captured workspace context; failures raise blocking errors."
-    },
-    {
-      "id": "appendix_required",
-      "statement": "System prompts for every agent must include the Agents.md guardrails + snapshot verbatim so every answer cites the same data."
-    },
-    {
-      "id": "metadata_only_tools",
-      "statement": "Registered tools are limited to replaying captured metadata; runtime rejects side-effect handlers."
-    },
-    {
-      "id": "manual_loop_supervision",
-      "statement": "Agent runs are no longer capped; humans stop the session themselves if the tool loop thrashes or lacks evidence, replacing the previous 6+6 pass guard that aborted speculative turns."
-    }
-  ],
-  "contextBudget": {
-    "treeDepth": 2,
-    "maxEntries": 200,
-    "documentExcerptLimit": 2000,
-    "excludedFolders": [".git", "node_modules", "dist"],
-    "comment": "Tool passes are now unlimited; appendix sizing stays the same so prompts remain deterministic."
-  }
-}

package/SOURCE_OF_TRUTH.json

@@ -1,103 +0,0 @@
-{
-  "document": {
-    "title": "Source of Truth — Hallucination-Free Editing",
-    "schemaVersion": "5.0.0",
-    "snapshotId": "editing_grounding_refresh",
-    "snapshotLabel": "Editing Context Discipline",
-    "lastUpdated": "2025-11-16",
-    "maintainedBy": "erosolar Dual Provider Runtime"
-  },
-  "northStar": "Make every edit cite deterministic evidence so hallucinations and contextual overload never reach the file system.",
-  "mission": "Describe the frozen truth inputs, replay-only tooling, and loop controls that make erosolar the safest place to edit with LLMs.",
-  "authoritativeCorpus": {
-    "priorityFiles": [
-      "README.md",
-      "Agents.md",
-      "SOURCE_OF_TRUTH.json",
-      "ARCHITECTURE.json",
-      "package.json",
-      "src/config.ts"
-    ],
-    "refreshExpectation": "Capture a new workspace snapshot on every CLI launch before any editing instructions are issued.",
-    "allowedExpansion": "Only add files that contain objective reference specs or canonical configuration. Narrative changelogs live elsewhere."
-  },
-  "agentsDocumentation": {
-    "optionalFile": "Agents.md",
-    "purpose": "Describe the available CLI agents (Erosolar general via OpenAI and Erosolar Code via OpenAI) without bloating this canonical JSON snapshot.",
-    "contents": [
-      "Provider + model defaults copied from src/config.ts blueprint values.",
-      "Guidance on when to use each agent and how system prompts differ.",
-      "Environment variable overrides that map directly to the implementation."
-    ],
-    "refreshGuidance": "Regenerate or update Agents.md whenever src/config.ts changes guardrails, models, or environment override names."
-  },
-  "preferencePersistence": {
-    "mechanism": "src/core/preferences.ts writes ~/.erosolar/settings.json whenever the operator changes models via /model.",
-    "behavior": "On startup the CLI reloads the last saved provider/model for a profile unless the corresponding EROSOLAR_CODE_* environment variables pin a specific configuration."
-  },
-  "hallucinationControls": [
-    {
-      "id": "deterministic_snapshot",
-      "mechanism": "src/workspace.ts builds a depth-2 tree (max 200 entries) and ingests 2000-character excerpts from every priority file.",
-      "editingImpact": "Locks an identical evidence base for both providers before edits start."
-    },
-    {
-      "id": "prompt_appendix",
-      "mechanism": "src/config.ts concatenates the guardrail text with the frozen snapshot for each agent defined in Agents.md.",
-      "editingImpact": "Reduces contextual overload by giving every agent the same curated evidence instead of raw workspace noise."
-    },
-    {
-      "id": "metadata_tools",
-      "mechanism": "src/core/toolRuntime.ts exposes `context_snapshot`, `capabilities_overview`, and `profile_details` as replay-only handlers.",
-      "editingImpact": "Allows the model to rehearse the snapshot verbatim mid-edit instead of guessing.",
-      "contextDiscipline": "Tools never re-read the workspace or shell out, so the prompt stays small and predictable."
-    },
-    {
-      "id": "loop_monitoring",
-      "mechanism": "src/core/agent.ts streams every assistant/tool turn without a hard pass cap, relying on operators to interrupt if necessary and replacing the previous 6+6 pass guardrail.",
-      "editingImpact": "Long-running refactors can finish in one turn, yet humans still decide when to stop and gather more evidence."
-    }
-  ],
-  "editingWorkflow": [
-    {
-      "stage": "intent_capture",
-      "description": "Operator issues an editing request; agent confirms which files are in scope using the frozen tree."
-    },
-    {
-      "stage": "snapshot_rehearsal",
-      "description": "Model replays `context_snapshot` or `profile_details` (documented in Agents.md) if any evidence feels uncertain."
-    },
-    {
-      "stage": "patch_reasoning",
-      "description": "Model plans edits strictly against cited files and excerpts from the appendix."
-    },
-    {
-      "stage": "answer_or_escalate",
-      "description": "The model keeps iterating until it can deliver a cited patch plan or explain what evidence is missing; humans interrupt manually if execution thrashes."
-    }
-  ],
-  "contextManagement": {
-    "treeDepth": 2,
-    "maxEntries": 200,
-    "documentExcerptLimit": 2000,
-    "excludedFolders": [".git", "node_modules", "dist"],
-    "rationale": "Unlimited tool passes keep the editing loop flexible; the appendix guardrails stay focused on keeping captured context compact."
-  },
-  "verificationRules": [
-    "Reference only the files listed in `authoritativeCorpus.priorityFiles` or paths that appear in the captured tree.",
-    "Quote line numbers or excerpt boundaries whenever describing an edit.",
-    "If the snapshot omits the needed file (e.g., because of depth limits), stop and request a refreshed capture.",
-    "Never suggest creating speculative files to satisfy a request; direct contributors back to this Source of Truth."
-  ],
-  "responseBoundaries": [
-    "All answers must cite which captured file or tool output justified the claim.",
-    "If an editing action would require fresh context (new file, new dependency), instruct the operator to refresh the snapshot first.",
-    "Do not fabricate configuration guidance—reference src/config.ts or this document.",
-    "Keep reasoning concise; defer to the metadata tools instead of repeating the entire snapshot inside free-form text."
-  ],
-  "escalationPolicy": {
-    "missing_snapshot": "Abort the editing session and instruct the operator to re-run the CLI to capture a new snapshot.",
-    "long_running_loop": "If the agent keeps issuing tool calls without converging, stop the session manually and gather more evidence before retrying.",
-    "tool_error": "Surface the exact error string (no paraphrasing) and request human intervention."
-  }
-}

package/dist/capabilities/tavilyCapability.js

@@ -1,26 +0,0 @@
-import { createTavilyTools } from '../tools/tavilyTools.js';
-export class TavilyCapabilityModule {
-    id = 'capability.tavily';
-    options;
-    constructor(options) {
-        if (!options?.apiKey) {
-            throw new Error('TavilyCapabilityModule requires an API key.');
-        }
-        this.options = options;
-    }
-    async create(_context) {
-        const tools = createTavilyTools({
-            apiKey: this.options.apiKey,
-            baseUrl: this.options.baseUrl,
-        });
-        return {
-            id: 'tavily.tools.web',
-            description: 'Live Tavily web search and extraction tools.',
-            toolSuite: {
-                id: 'tavily.web',
-                description: 'Internet search and content extraction via Tavily.',
-                tools,
-            },
-        };
-    }
-}

package/dist/plugins/tools/tavily/tavilyPlugin.js

@@ -1,16 +0,0 @@
-import { TavilyCapabilityModule } from '../../../capabilities/tavilyCapability.js';
-import { getSecretValue } from '../../../core/secretStore.js';
-export function createTavilyToolPlugin() {
-    return {
-        id: 'tool.tavily.web',
-        description: 'Tavily web search and extraction.',
-        targets: ['node', 'cloud'],
-        create: () => {
-            const apiKey = getSecretValue('TAVILY_API_KEY');
-            if (!apiKey) {
-                return null;
-            }
-            return new TavilyCapabilityModule({ apiKey });
-        },
-    };
-}

package/dist/shell/__tests__/bracketedPasteManager.test.js

@@ -1,35 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { BracketedPasteManager } from '../bracketedPasteManager.js';
-const START = '\u001b[200~';
-const END = '\u001b[201~';
-test('combines bracketed paste across multiple lines', () => {
-    const manager = new BracketedPasteManager(true);
-    let result = manager.process(`${START}what happened in`);
-    assert.equal(result.handled, true);
-    assert.equal(result.result, undefined);
-    result = manager.process(`  Trump\'s 2025 trip to${END}`);
-    assert.equal(result.handled, true);
-    assert.equal(result.result, "what happened in\n  Trump's 2025 trip to");
-});
-test('captures pastes that end with a newline', () => {
-    const manager = new BracketedPasteManager(true);
-    manager.process(`${START}first line`);
-    manager.process('second line');
-    const result = manager.process(`${END}`);
-    assert.equal(result.handled, true);
-    assert.equal(result.result, 'first line\nsecond line\n');
-});
-test('preserves prefix and suffix text outside paste markers', () => {
-    const manager = new BracketedPasteManager(true);
-    const result = manager.process(`Tell me ${START}something${END} please`);
-    assert.equal(result.handled, true);
-    assert.equal(result.result, 'Tell me something please');
-});
-test('falls back gracefully when bracketed paste is disabled', () => {
-    const manager = new BracketedPasteManager(false);
-    let result = manager.process('just text');
-    assert.equal(result.handled, false);
-    result = manager.process(`${START}multi${END}`);
-    assert.equal(result.handled, false);
-});