erosolar-cli 1.0.1

package/ARCHITECTURE.json

@@ -0,0 +1,157 @@
+{
+  "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/Agents.md

@@ -0,0 +1,207 @@
+# Agents (Optional)
+
+This optional reference summarizes the agent personalities that ship with the erosolar CLI.
+All executable defaults still live in `src/config.ts`; this document simply mirrors them so
+operators can reason about the available choices without scanning TypeScript.
+
+## Agent overview
+
+| Agent | Provider | Default model | Primary intent |
+| --- | --- | --- | --- |
+| Erosolar | OpenAI | `gpt-5.1` | General-purpose reasoning across planning, writing, research, and coding. |
+| Erosolar Code | OpenAI | `gpt-5.1-codex` | Fast editing feedback with deterministic grounding. |
+
+## Erosolar agent (General)
+
+- **Provider/model**: Uses the OpenAI SDK with `gpt-5.1` as the balanced default model.
+- **System prompt**: Frames the assistant as a multi-domain operator that can plan, research, write, and code with equal rigor.
+- **CLI entrypoint**: `erosolar` (package `bin` field) now boots the Erosolar Code profile; select this general agent via `/agents`, `--profile=general`, or by setting it as the default.
+- **Tool stack**: This profile is slated to inherit the broader research+planning tool bundle once it is finalized, so keep it handy for those workflows.
+- **Ideal for**: General operations where you need a mix of reasoning, writing, and software edits without switching personas.
+- **Model presets**: Switch between `gpt-5.1` (default), `gpt-5.1-codex`, or any other registered preset via `/model`.
+- **Agent selector**: Run `/agents` in the CLI to make Erosolar or any other profile the default for future launches.
+
+## Erosolar Code agent (OpenAI)
+
+- **Provider/model**: Uses the OpenAI SDK with `gpt-5.1-codex` as the baked-in model
+  (`src/config.ts` blueprint).
+- **System prompt**: Frames the assistant as a proactive coding agent that can read/write files,
+  execute bash commands, and chain tools to finish multi-step tasks.
+- **CLI entrypoint**: `erosolar` (package `bin` field). Use `/agents` to switch profiles after launching.
+- **Ideal for**: Rapid iteration when the operator prefers OpenAI latency/behavior.
+- **Model presets**: Switch between `gpt-5.1-codex` (default), `gpt-5.1`, `gpt-5-pro`,
+  `gpt-5-mini`, or `gpt-5-nano` directly from `/model` in the CLI.
+
+## DeepSeek provider (OpenAI-compatible)
+
+- **Provider/model**: Uses the OpenAI SDK pointed at DeepSeek’s API gateway so both
+  `deepseek-reasoner` and `deepseek-chat` appear in `/model`.
+- **Authentication**: Requires `DEEPSEEK_API_KEY` (set via `/secrets` or exported as an env var).
+- **Usage**: The CLI reuses the same OpenAI client plumbing:
+
+```ts
+import OpenAI from 'openai';
+
+const openai = new OpenAI({
+  baseURL: 'https://api.deepseek.com',
+  apiKey: process.env.DEEPSEEK_API_KEY,
+});
+
+async function main() {
+  const completion = await openai.chat.completions.create({
+    messages: [{ role: 'system', content: 'You are a helpful assistant.' }],
+    model: 'deepseek-reasoner',
+  });
+
+  console.log(completion.choices[0].message.content);
+}
+
+main();
+```
+
+- **Ideal for**: When you want DeepSeek’s open weights but still expect the CLI to behave like the
+  OpenAI-backed Erosolar Code workflow.
+
+## xAI provider (OpenAI-compatible)
+
+- **Provider/model**: Reuses the OpenAI Chat Completions client but points it at `https://api.x.ai/v1`
+  so the CLI can drive Grok models natively.
+- **Authentication**: Requires `XAI_API_KEY` (store it via `/secrets` or export it before launching).
+- **Model presets**: `/model` now exposes `grok-4`, `grok-4-fast-reasoning`, `grok-4-fast-non-reasoning`,
+  and `grok-code-fast-1`.
+- **Usage**: You can also call xAI directly with their official SDK:
+
+```ts
+import { xai } from '@ai-sdk/xai';
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model: xai('grok-4'),
+  system:
+    "You are Grok, a chatbot inspired by the Hitchhiker's Guide to the Galaxy.",
+  prompt: 'What is the meaning of life, the universe, and everything?',
+});
+
+console.log(result.text);
+```
+
+- **Ideal for**: When you want Grok’s Hitchhiker-inspired tone without losing the CLI workflow.
+
+## Google provider (Gemini)
+
+- **Provider/model**: Uses Google’s official `@google/genai` SDK so the CLI can talk to Gemini natively. The built-in config exposes both `gemini-2.5-pro` and `gemini-2.5-flash` models under the new `google` provider id.
+- **Authentication**: Requires `GEMINI_API_KEY`, which the CLI passes directly to the SDK client.
+- **Usage**: Mirrors the standalone SDK experience:
+
+```ts
+import { GoogleGenAI } from '@google/genai';
+
+const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
+
+async function main() {
+  const response = await ai.models.generateContent({
+    model: 'gemini-2.5-flash',
+    contents: 'Explain how AI works in a few words',
+  });
+
+  console.log(response.text);
+}
+
+main();
+```
+
+- **Ideal for**: When you want Gemini’s multi-modal reasoning or prefer Google’s governance defaults without going through an OpenAI-compatible shim.
+
+## Environment overrides
+
+All agents honor the same override pattern. Set these before launching the CLI if you need to
+tune a run without editing the repo:
+
+- `GENERAL_MODEL`, `GENERAL_PROVIDER`, `GENERAL_SYSTEM_PROMPT`
+- `EROSOLAR_CODE_MODEL`, `EROSOLAR_CODE_PROVIDER`, `EROSOLAR_CODE_SYSTEM_PROMPT`
+
+Unset or unknown providers automatically fall back to the safe defaults in `src/config.ts`.
+
+## Shell sandbox behavior
+
+- The bash tool now rewrites `HOME`, `TMPDIR`, and the `XDG_*` cache/config/data paths to
+  `<workspace>/.erosolar/shell-sandbox` so commands like `firebase`, `gcloud`, or `curl` can create
+  their runtime state even when the host blocks writes to the real home directory.
+- Set `EROSOLAR_PRESERVE_HOME=1` before launching `erosolar` if you need to opt out and expose your
+  actual home directory (only do this when the host allows writing outside the repo).
+
+## Selecting agents at runtime
+
+Launch `erosolar` and run `/agents` to view the registered profiles (Erosolar and Erosolar Code, plus any
+custom entries). The selection persists in `~/.erosolar/settings.json` and the CLI reloads that
+profile on the next launch unless you override it with `--profile=<name>` or the corresponding
+environment variables.
+
+## Adding custom agents
+
+`src/core/agentProfiles.ts` exposes a lightweight registry so you can call
+`registerAgentProfile()` anywhere before `resolveProfileConfig()` runs. Each profile entry defines
+its label, default provider/model pair, and guardrailed system prompt. The CLI automatically
+recognizes the new profile name with no additional wiring and the `AgentSession` runtime
+(`src/runtime/agentSession.ts`) keeps the prompt/tool context in sync across frontends.
+
+## Provider registry
+
+`src/providers/providerFactory.ts` is now a registry rather than a hard-coded switch. Call
+`registerProvider('my-provider', factory)` once during startup to plug in new SDKs. All agents—
+including the interactive shell, cloud workers, or browser embeddings—reuse the same provider IDs,
+so adding new connections never requires editing the UI layer.
+
+## Tool suites & sessions
+
+Tool handlers are grouped into suites (`src/core/toolRuntime.ts`) which can be registered or
+removed at runtime. The shared `AgentSession` helper composes a profile, provider selection, and
+tool suites into a reusable runtime so the CLI, a browser UI, or a hosted workflow can all spin up
+the same agent contract without reimplementing orchestration code.
+
+## Capability host & modular expansions
+
+- `src/runtime/agentHost.ts` introduces an `AgentHost` facade that fronts every frontend (CLI,
+  daemon, browser worker, or cloud function). It accepts any number of `CapabilityModule`
+  instances—each module can contribute tool suites, external connectors, or metadata without
+  touching the UI.
+- Default modules in `src/capabilities/` wrap the local filesystem, structured repo search, and the
+  sandboxed bash executor. Operators can add new modules (Google Sheets, MCP servers, legacy file
+  migrations, etc.) by registering them before the session starts:
+
+```ts
+import { AgentHost } from './runtime/agentHost.js';
+import { CapabilityModule } from './runtime/agentHost.js';
+
+const googleSheetsModule: CapabilityModule = {
+  id: 'capability.google_sheets',
+  async create(context) {
+    const sheets = await connectToSheets(process.env.GOOGLE_CREDENTIALS!);
+    return {
+      id: 'sheets.tools.analytics',
+      description: 'Plan + edit spreadsheet models via Google Sheets API',
+      toolSuites: [sheets.asToolSuite()],
+      metadata: { scopes: sheets.requestedScopes },
+      dispose: () => sheets.disconnect(),
+    };
+  },
+};
+
+const host = new AgentHost({ profile: 'erosolar-code', workspaceContext, workingDir });
+await host.loadModules([googleSheetsModule]);
+const session = await host.getSession();
+```
+
+- Because `AgentHost` only passes plain tool suites into `AgentSession`, the same capability stack
+  works from a CLI shell, a remote orchestrator, or a browser sandbox. No frontend changes are
+  required as long as new modules obey the shared `CapabilityModule` contract.
+- Modules can bridge to MCP servers, SaaS APIs, or on-prem systems by emitting their own tool suites
+  (e.g., a “research” module that shells into SLURM, or a “filesystem migration” module that wraps a
+  bespoke archivist API). Frontends decide which modules to load based on deployment policy without
+  recompiling the CLI.
+
+## Maintenance
+
+Update this file whenever `src/config.ts` changes guardrails, default models, or provider
+identifiers. If the repo only needs a single agent, you may delete this file altogether; the CLI
+will continue to use the TypeScript blueprints directly.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Erosolar AI
+
+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/SOURCE_OF_TRUTH.json

@@ -0,0 +1,103 @@
+{
+  "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/adapters/browser/index.js

@@ -0,0 +1,10 @@
+export class BrowserRuntimeAdapter {
+    id = 'runtime.browser';
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async createCapabilityModules(_) {
+        return [...(this.options.modules ?? [])];
+    }
+}

package/dist/adapters/node/index.js

@@ -0,0 +1,34 @@
+import { instantiateToolPlugins, registerDefaultNodeToolPlugins, } from '../../plugins/tools/index.js';
+export class NodeRuntimeAdapter {
+    id = 'runtime.node';
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async createCapabilityModules(context) {
+        registerDefaultNodeToolPlugins();
+        const filter = (plugin) => {
+            if (this.options.includeFilesystem === false && plugin.id === 'tool.filesystem.local') {
+                return false;
+            }
+            if (this.options.includeSearch === false && plugin.id === 'tool.search.local') {
+                return false;
+            }
+            if (this.options.includeBash === false && plugin.id === 'tool.bash.local') {
+                return false;
+            }
+            if (this.options.filter && !this.options.filter(plugin)) {
+                return false;
+            }
+            return true;
+        };
+        const modules = await instantiateToolPlugins('node', {
+            workingDir: context.workingDir,
+            env: context.env,
+        }, { filter });
+        if (this.options.extraModules?.length) {
+            modules.push(...this.options.extraModules);
+        }
+        return modules;
+    }
+}

package/dist/adapters/remote/index.js

@@ -0,0 +1,19 @@
+export class RemoteRuntimeAdapter {
+    id = 'runtime.remote';
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async createCapabilityModules(context) {
+        const modules = [];
+        for (const entry of this.options.modules ?? []) {
+            if (typeof entry === 'function') {
+                modules.push(await entry(context));
+            }
+            else {
+                modules.push(entry);
+            }
+        }
+        return modules;
+    }
+}

package/dist/adapters/types.js

@@ -0,0 +1 @@
+export {};

package/dist/bin/erosolar.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { launchShell } from '../shell/shellApp.js';
+launchShell('erosolar-code', { enableProfileSelection: true }).catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+});

package/dist/capabilities/bashCapability.js

@@ -0,0 +1,23 @@
+import { createBashTools } from '../tools/bashTools.js';
+export class BashCapabilityModule {
+    id = 'capability.bash';
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async create(context) {
+        const workingDir = this.options.workingDir ?? context.workingDir;
+        return {
+            id: this.options.id ?? 'bash.tools.shell',
+            description: this.options.description ?? 'Shell execution with stdout/stderr summaries for reproducibility.',
+            toolSuite: {
+                id: 'bash',
+                description: 'Shell access',
+                tools: createBashTools(workingDir),
+            },
+            metadata: {
+                workingDir,
+            },
+        };
+    }
+}

package/dist/capabilities/filesystemCapability.js

@@ -0,0 +1,23 @@
+import { createFileTools } from '../tools/fileTools.js';
+export class FilesystemCapabilityModule {
+    id = 'capability.filesystem';
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async create(context) {
+        const workingDir = this.options.workingDir ?? context.workingDir;
+        return {
+            id: this.options.id ?? 'filesystem.tools.local',
+            description: this.options.description ?? 'Local file system access with deterministic diff summaries.',
+            toolSuite: {
+                id: 'fs',
+                description: 'File operations',
+                tools: createFileTools(workingDir),
+            },
+            metadata: {
+                workingDir,
+            },
+        };
+    }
+}

package/dist/capabilities/index.js

@@ -0,0 +1,3 @@
+export { FilesystemCapabilityModule } from './filesystemCapability.js';
+export { BashCapabilityModule } from './bashCapability.js';
+export { SearchCapabilityModule } from './searchCapability.js';

package/dist/capabilities/searchCapability.js

@@ -0,0 +1,23 @@
+import { createSearchTools } from '../tools/searchTools.js';
+export class SearchCapabilityModule {
+    id = 'capability.search';
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async create(context) {
+        const workingDir = this.options.workingDir ?? context.workingDir;
+        return {
+            id: this.options.id ?? 'search.tools.repo',
+            description: this.options.description ?? 'Repository-aware search helpers (glob + structural grep).',
+            toolSuite: {
+                id: 'search',
+                description: 'Code search',
+                tools: createSearchTools(workingDir),
+            },
+            metadata: {
+                workingDir,
+            },
+        };
+    }
+}