@ectplsm/relic 0.1.0

package/LICENCE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2026 ectplsm
+
+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/README.md

@@ -0,0 +1,324 @@
+| English | [日本語](README-ja.md) |
+|:---:|:---:|
+
+# PROJECT RELIC
+
+```
+    ____  ________    ____________
+   / __ \/ ____/ /   /  _/ ____/
+  / /_/ / __/ / /    / // /
+ / _, _/ /___/ /____/ // /___
+/_/ |_/_____/_____/___/\____/
+```
+
+**Inject AI personas into any coding CLI.**
+
+Relic manages AI personalities (called **Engrams**) and injects them into coding assistants like Claude Code, Gemini CLI, Codex CLI, and GitHub Copilot CLI. One persona, any shell.
+
+```bash
+# Initialize Relic (creates ~/.relic/ with sample Engrams)
+relic init
+
+# Launch Claude Code as Johnny Silverhand
+relic claude --engram johnny
+
+# Launch Gemini CLI as Motoko Kusanagi
+relic gemini --engram motoko
+```
+
+## How It Works
+
+```
++--------------+     +--------------+     +--------------+
+|   Mikoshi    |     |    Relic     |     |    Shell     |
+|  (backend)   |     |  (injector)  |     |   (AI CLI)   |
++--------------+     +--------------+     +--------------+
+       |                   |                    |
+   +---------+        compose &            +---------+
+   | Engram  |------> inject ------------->|Construct|
+   |(persona)|                             | (live)  |
+   +---------+                             +---------+
+   SOUL.md                                  claude
+   IDENTITY.md                              gemini
+   MEMORY.md                                codex
+   ...                                      copilot
+```
+
+1. **Engram** — A persona defined as a set of Markdown files (OpenClaw-compatible)
+2. **Relic** — Reads the Engram, composes it into a prompt, and injects it into...
+3. **Shell** — Any AI coding CLI. The persona takes over the session.
+4. **Construct** — A live process where an Engram is loaded into a Shell. The running instance of a persona.
+5. **Mikoshi** — Cloud backend where Engrams are stored and synced (planned).
+
+## Installation
+
+```bash
+git clone https://github.com/ectplsm/relic.git
+cd relic
+npm install
+npm link
+```
+
+## Quick Start
+
+```bash
+# Initialize — creates config and sample Engrams
+relic init
+
+# List available Engrams
+relic list
+
+# Preview an Engram's composed prompt
+relic show motoko
+
+# Launch a Shell with an Engram injected
+relic claude --engram motoko
+relic gemini --engram johnny
+relic codex --engram motoko
+relic copilot --engram johnny
+```
+
+## Supported Shells
+
+| Shell | Command | Injection Method |
+|-------|---------|-----------------|
+| [Claude Code](https://github.com/anthropics/claude-code) | `relic claude` | `--system-prompt` (direct override) |
+| [Gemini CLI](https://github.com/google-gemini/gemini-cli) | `relic gemini` | `--prompt-interactive` (first message) |
+| [Codex CLI](https://github.com/openai/codex) | `relic codex` | `PROMPT` argument (first message) |
+| [Copilot CLI](https://github.com/github/copilot-cli) | `relic copilot` | `--interactive` (first message) |
+
+All shell commands support:
+- `--engram <id>` (required) — Engram to inject
+- `--path <dir>` — Override Engrams directory
+- `--cwd <dir>` — Working directory for the Shell (default: current directory)
+
+Extra arguments are passed through to the underlying CLI.
+
+## MCP Server
+
+Relic also runs as an [MCP](https://modelcontextprotocol.io/) server, allowing any MCP-compatible client (like Claude Desktop) to access Engrams directly.
+
+### Setup (Claude Desktop)
+
+1. Build the project:
+   ```bash
+   npm run build
+   ```
+
+2. Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
+   ```json
+   {
+     "mcpServers": {
+       "relic": {
+         "command": "node",
+         "args": ["/path/to/relic/dist/interfaces/mcp/index.js"]
+       }
+     }
+   }
+   ```
+
+3. Restart Claude Desktop.
+
+### Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `relic_init` | Initialize `~/.relic/` with config and sample Engrams |
+| `relic_list` | List all available Engrams |
+| `relic_show` | Preview an Engram's composed prompt |
+| `relic_summon` | Summon an Engram and return the persona prompt for injection |
+| `relic_inject` | Inject an Engram into an OpenClaw workspace |
+| `relic_extract` | Extract an Engram from an OpenClaw workspace |
+| `relic_memory_search` | Search an Engram's memory entries by keyword |
+| `relic_memory_get` | Get a specific memory entry by date |
+| `relic_memory_list` | List all memory entry dates for an Engram |
+
+## OpenClaw Integration
+
+Relic is fully compatible with [OpenClaw](https://github.com/openclaw/openclaw) workspaces. **Agent name = Engram ID** — this simple convention eliminates the need for mapping configuration.
+
+### Inject — Push an Engram into OpenClaw
+
+Injects persona files (SOUL.md, IDENTITY.md, etc.) into `agents/<engramId>/agent/`. Memory entries are **not** injected — they are managed by OpenClaw independently.
+
+> **Note:** The OpenClaw agent must already exist. Inject writes persona files into an existing agent directory — it does not create new agents. Create the agent in OpenClaw first, then inject.
+
+```bash
+# Inject Engram "motoko" → agents/motoko/agent/
+relic inject --engram motoko
+
+# Inject into a differently-named agent (one-way copy)
+relic inject --engram motoko --to main
+# → agents/main/agent/ receives motoko's persona
+# → extract will create Engram "main", not "motoko"
+
+# Specify a custom OpenClaw directory
+relic inject --engram motoko --openclaw /path/to/.openclaw
+```
+
+### Extract — Sync memory from OpenClaw
+
+Reads from `agents/<engramId>/agent/` and merges memory entries back to the Relic Engram.
+
+```bash
+# Extract memory from agent "motoko" → merge into Engram "motoko"
+relic extract --engram motoko
+
+# New agent with no existing Engram (--name required)
+relic extract --engram analyst --name "Data Analyst"
+
+# Overwrite persona files (memory is always merged)
+relic extract --engram motoko --force
+
+# Extract from a custom OpenClaw directory
+relic extract --engram motoko --openclaw /path/to/.openclaw
+```
+
+### Sync — Watch and auto-sync
+
+Watches all agents under `~/.openclaw/agents/` and automatically syncs:
+
+```bash
+# Start watching (Ctrl+C to stop)
+relic sync
+
+# Specify a custom OpenClaw directory
+relic sync --openclaw /path/to/.openclaw
+```
+
+On startup:
+1. Injects persona files for all agents that have a matching Engram
+2. Extracts memory entries from all agents
+
+While running:
+- Watches each agent's `memory/` directory for changes
+- Automatically merges new memory entries into the corresponding Engram
+
+### Memory Sync Behavior
+
+| Scenario | Persona (SOUL, IDENTITY...) | Memory entries |
+|----------|---------------------------|----------------|
+| **inject** | Relic → OpenClaw (overwrite) | Not copied (OpenClaw manages its own) |
+| **extract** (existing Engram) | Not touched | OpenClaw → Relic (append) |
+| **extract** + `--force` | OpenClaw → Relic (overwrite) | OpenClaw → Relic (append) |
+| **extract** (new Engram) | Created from OpenClaw | Created from OpenClaw |
+| **sync** (startup) | inject for matching Engrams | extract all |
+| **sync** (watching) | — | Auto-extract on change |
+
+## Memory Management
+
+Relic uses a **2-day sliding window** for memory entries, matching OpenClaw's approach:
+
+- `MEMORY.md` — Always included in the prompt (curated long-term memory)
+- `memory/today.md` + `memory/yesterday.md` — Always included
+- Older entries — **Not included in the prompt**, but accessible via MCP tools
+
+This keeps prompts compact while preserving full history. AI clients (like Claude Desktop) can use the memory tools to search or retrieve older entries on demand:
+
+```
+relic_memory_search  → keyword search across all entries
+relic_memory_get     → fetch a specific date's entry
+relic_memory_list    → list all available dates
+```
+
+## Creating Your Own Engram
+
+Create a directory under `~/.relic/engrams/` with the following structure:
+
+```
+~/.relic/engrams/your-persona/
+├── engram.json        # Metadata (id, name, description, tags)
+├── SOUL.md            # Core directive — how the persona thinks and acts
+├── IDENTITY.md        # Name, tone, background, personality
+├── AGENTS.md          # (optional) Tool usage policies
+├── USER.md            # (optional) User context
+├── MEMORY.md          # (optional) Memory index
+├── HEARTBEAT.md       # (optional) Periodic reflection
+└── memory/            # (optional) Dated memory entries
+    └── 2026-03-21.md
+```
+
+**engram.json:**
+```json
+{
+  "id": "your-persona",
+  "name": "Display Name",
+  "description": "A short description",
+  "createdAt": "2026-03-21T00:00:00Z",
+  "updatedAt": "2026-03-21T00:00:00Z",
+  "tags": ["custom"]
+}
+```
+
+**SOUL.md** — The most important file. Defines how the persona behaves:
+```markdown
+You are a pragmatic systems architect who values simplicity above all.
+Never over-engineer. Always ask "what's the simplest thing that works?"
+```
+
+**IDENTITY.md** — Defines who the persona is:
+```markdown
+# Identity
+
+- Name: Alex
+- Tone: Calm, thoughtful, occasionally playful
+- Background: 20 years of distributed systems experience
+- Creed: "Boring technology wins."
+```
+
+## Configuration
+
+Config lives at `~/.relic/config.json`:
+
+```json
+{
+  "engramsPath": "/home/user/.relic/engrams"
+}
+```
+
+Priority: CLI `--path` flag > config file > default (`~/.relic/engrams`)
+
+## Architecture
+
+Clean Architecture with dependency inversion:
+
+```
+src/
+├── core/            # Business logic (no external deps except Zod)
+│   ├── entities/    # Engram, Construct domain models
+│   ├── usecases/    # Summon, ListEngrams, Init
+│   └── ports/       # Abstract interfaces (EngramRepository, ShellLauncher)
+├── adapters/        # Concrete implementations
+│   ├── local/       # Local filesystem EngramRepository
+│   └── shells/      # Claude, Gemini, Codex, Copilot launchers
+├── interfaces/      # Entry points
+│   ├── cli/         # Commander-based CLI
+│   └── mcp/         # MCP Server (stdio transport)
+└── shared/          # Engram composer, config management
+```
+
+## Domain Glossary
+
+| Term | Role | Description |
+|------|------|-------------|
+| **Relic** | Injector | The core system. Adapts personas to any AI interface. |
+| **Mikoshi** | Backend | Cloud fortress where all Engrams are stored (planned). |
+| **Engram** | Data | A persona dataset — a set of Markdown files. |
+| **Shell** | LLM | An AI CLI (Claude, Gemini, etc). A vessel with pure compute. |
+| **Construct** | Process | A live process where an Engram is loaded into a Shell. |
+
+## Roadmap
+
+- [x] CLI with init, list, show commands
+- [x] Shell injection: Claude Code, Gemini CLI, Codex CLI, Copilot CLI
+- [x] MCP Server interface
+- [x] OpenClaw integration (inject / extract)
+- [x] `relic sync` — watch OpenClaw agents and auto-sync (`--cloud` for Mikoshi: planned)
+- [ ] `relic login` — authenticate with Mikoshi (OAuth Device Flow)
+- [ ] `relic push` / `relic pull` — sync Engrams with Mikoshi
+- [ ] Mikoshi cloud backend (`mikoshi.ectplsm.com`)
+- [ ] `relic create` — interactive Engram creation wizard
+
+## License
+
+[MIT](./LICENCE.md)

package/dist/adapters/local/index.d.ts

@@ -0,0 +1 @@
+export { LocalEngramRepository } from "./local-engram-repository.js";

package/dist/adapters/local/index.js

@@ -0,0 +1 @@
+export { LocalEngramRepository } from "./local-engram-repository.js";

package/dist/adapters/local/local-engram-repository.d.ts

@@ -0,0 +1,28 @@
+import type { Engram, EngramMeta } from "../../core/entities/engram.js";
+import type { EngramRepository } from "../../core/ports/engram-repository.js";
+/**
+ * LocalEngramRepository — ローカルファイルシステム上の
+ * OpenClaw互換ディレクトリからEngramを読み書きする。
+ *
+ * ディレクトリ構造:
+ *   {basePath}/{engramId}/
+ *     ├── engram.json     (メタデータ)
+ *     ├── SOUL.md
+ *     ├── IDENTITY.md
+ *     ├── AGENTS.md       (optional)
+ *     ├── USER.md         (optional)
+ *     ├── MEMORY.md       (optional)
+ *     ├── HEARTBEAT.md    (optional)
+ *     └── memory/         (optional)
+ *         └── YYYY-MM-DD.md
+ */
+export declare class LocalEngramRepository implements EngramRepository {
+    private readonly basePath;
+    constructor(basePath: string);
+    list(): Promise<EngramMeta[]>;
+    get(id: string): Promise<Engram | null>;
+    save(engram: Engram): Promise<void>;
+    delete(id: string): Promise<void>;
+    private readMeta;
+    private readFiles;
+}

package/dist/adapters/local/local-engram-repository.js

@@ -0,0 +1,130 @@
+import { readdir, readFile, writeFile, mkdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { EngramMetaSchema } from "../../core/entities/engram.js";
+/**
+ * OpenClaw互換のファイル名マッピング
+ * EngramFiles のキー → 実ファイル名
+ */
+const FILE_MAP = {
+    soul: "SOUL.md",
+    identity: "IDENTITY.md",
+    agents: "AGENTS.md",
+    user: "USER.md",
+    memory: "MEMORY.md",
+    heartbeat: "HEARTBEAT.md",
+};
+const META_FILE = "engram.json";
+const MEMORY_DIR = "memory";
+/**
+ * LocalEngramRepository — ローカルファイルシステム上の
+ * OpenClaw互換ディレクトリからEngramを読み書きする。
+ *
+ * ディレクトリ構造:
+ *   {basePath}/{engramId}/
+ *     ├── engram.json     (メタデータ)
+ *     ├── SOUL.md
+ *     ├── IDENTITY.md
+ *     ├── AGENTS.md       (optional)
+ *     ├── USER.md         (optional)
+ *     ├── MEMORY.md       (optional)
+ *     ├── HEARTBEAT.md    (optional)
+ *     └── memory/         (optional)
+ *         └── YYYY-MM-DD.md
+ */
+export class LocalEngramRepository {
+    basePath;
+    constructor(basePath) {
+        this.basePath = basePath;
+    }
+    async list() {
+        if (!existsSync(this.basePath)) {
+            return [];
+        }
+        const entries = await readdir(this.basePath, { withFileTypes: true });
+        const dirs = entries.filter((e) => e.isDirectory());
+        const metas = [];
+        for (const dir of dirs) {
+            const metaPath = join(this.basePath, dir.name, META_FILE);
+            if (!existsSync(metaPath))
+                continue;
+            const raw = await readFile(metaPath, "utf-8");
+            const parsed = EngramMetaSchema.safeParse(JSON.parse(raw));
+            if (parsed.success) {
+                metas.push(parsed.data);
+            }
+        }
+        return metas;
+    }
+    async get(id) {
+        const engramDir = join(this.basePath, id);
+        if (!existsSync(engramDir)) {
+            return null;
+        }
+        const meta = await this.readMeta(engramDir);
+        if (!meta)
+            return null;
+        const files = await this.readFiles(engramDir);
+        return { meta, files };
+    }
+    async save(engram) {
+        const engramDir = join(this.basePath, engram.meta.id);
+        await mkdir(engramDir, { recursive: true });
+        // メタデータ書き込み
+        await writeFile(join(engramDir, META_FILE), JSON.stringify(engram.meta, null, 2), "utf-8");
+        // 必須ファイル書き込み
+        for (const [key, filename] of Object.entries(FILE_MAP)) {
+            const content = engram.files[key];
+            if (content !== undefined) {
+                await writeFile(join(engramDir, filename), content, "utf-8");
+            }
+        }
+        // memory/ エントリ書き込み
+        if (engram.files.memoryEntries) {
+            const memoryDir = join(engramDir, MEMORY_DIR);
+            await mkdir(memoryDir, { recursive: true });
+            for (const [date, content] of Object.entries(engram.files.memoryEntries)) {
+                await writeFile(join(memoryDir, `${date}.md`), content, "utf-8");
+            }
+        }
+    }
+    async delete(id) {
+        const engramDir = join(this.basePath, id);
+        if (existsSync(engramDir)) {
+            await rm(engramDir, { recursive: true });
+        }
+    }
+    // --- private ---
+    async readMeta(engramDir) {
+        const metaPath = join(engramDir, META_FILE);
+        if (!existsSync(metaPath))
+            return null;
+        const raw = await readFile(metaPath, "utf-8");
+        const parsed = EngramMetaSchema.safeParse(JSON.parse(raw));
+        return parsed.success ? parsed.data : null;
+    }
+    async readFiles(engramDir) {
+        const files = {};
+        // 各Markdownファイルを読み込み
+        for (const [key, filename] of Object.entries(FILE_MAP)) {
+            const filePath = join(engramDir, filename);
+            if (existsSync(filePath)) {
+                files[key] = await readFile(filePath, "utf-8");
+            }
+        }
+        // memory/ ディレクトリの読み込み
+        const memoryDir = join(engramDir, MEMORY_DIR);
+        if (existsSync(memoryDir)) {
+            const memEntries = await readdir(memoryDir);
+            const mdFiles = memEntries.filter((f) => f.endsWith(".md")).sort();
+            if (mdFiles.length > 0) {
+                files.memoryEntries = {};
+                for (const mdFile of mdFiles) {
+                    const date = mdFile.replace(/\.md$/, "");
+                    files.memoryEntries[date] = await readFile(join(memoryDir, mdFile), "utf-8");
+                }
+            }
+        }
+        return files;
+    }
+}

package/dist/adapters/shells/claude-shell.d.ts

@@ -0,0 +1,13 @@
+import type { ShellLauncher, InjectionMode } from "../../core/ports/shell-launcher.js";
+/**
+ * Claude Code CLI アダプター
+ * --system-prompt フラグでEngramを直接注入する。
+ */
+export declare class ClaudeShell implements ShellLauncher {
+    private readonly command;
+    readonly name = "Claude Code";
+    readonly injectionMode: InjectionMode;
+    constructor(command?: string);
+    isAvailable(): Promise<boolean>;
+    launch(prompt: string, extraArgs?: string[], cwd?: string): Promise<void>;
+}

package/dist/adapters/shells/claude-shell.js

@@ -0,0 +1,33 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { spawnShell } from "./spawn-shell.js";
+const execAsync = promisify(exec);
+/**
+ * Claude Code CLI アダプター
+ * --system-prompt フラグでEngramを直接注入する。
+ */
+export class ClaudeShell {
+    command;
+    name = "Claude Code";
+    injectionMode = "system-prompt";
+    constructor(command = "claude") {
+        this.command = command;
+    }
+    async isAvailable() {
+        try {
+            await execAsync(`which ${this.command}`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async launch(prompt, extraArgs = [], cwd) {
+        const args = [
+            "--system-prompt",
+            prompt,
+            ...extraArgs,
+        ];
+        await spawnShell(this.command, args, cwd);
+    }
+}

package/dist/adapters/shells/codex-shell.d.ts

@@ -0,0 +1,14 @@
+import type { ShellLauncher, InjectionMode } from "../../core/ports/shell-launcher.js";
+/**
+ * Codex CLI アダプター
+ * [PROMPT] 引数でEngramを初回メッセージとして注入し、
+ * インタラクティブモードを継続する。
+ */
+export declare class CodexShell implements ShellLauncher {
+    private readonly command;
+    readonly name = "Codex CLI";
+    readonly injectionMode: InjectionMode;
+    constructor(command?: string);
+    isAvailable(): Promise<boolean>;
+    launch(prompt: string, extraArgs?: string[], cwd?: string): Promise<void>;
+}

package/dist/adapters/shells/codex-shell.js

@@ -0,0 +1,34 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { spawnShell } from "./spawn-shell.js";
+import { wrapWithOverride } from "./override-preamble.js";
+const execAsync = promisify(exec);
+/**
+ * Codex CLI アダプター
+ * [PROMPT] 引数でEngramを初回メッセージとして注入し、
+ * インタラクティブモードを継続する。
+ */
+export class CodexShell {
+    command;
+    name = "Codex CLI";
+    injectionMode = "user-message";
+    constructor(command = "codex") {
+        this.command = command;
+    }
+    async isAvailable() {
+        try {
+            await execAsync(`which ${this.command}`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async launch(prompt, extraArgs = [], cwd) {
+        const args = [
+            ...extraArgs,
+            wrapWithOverride(prompt),
+        ];
+        await spawnShell(this.command, args, cwd);
+    }
+}

package/dist/adapters/shells/copilot-shell.d.ts

@@ -0,0 +1,14 @@
+import type { ShellLauncher, InjectionMode } from "../../core/ports/shell-launcher.js";
+/**
+ * GitHub Copilot CLI アダプター (copilot コマンド)
+ * --interactive フラグでEngramを初回プロンプトとして注入し、
+ * インタラクティブモードを継続する。
+ */
+export declare class CopilotShell implements ShellLauncher {
+    private readonly command;
+    readonly name = "GitHub Copilot CLI";
+    readonly injectionMode: InjectionMode;
+    constructor(command?: string);
+    isAvailable(): Promise<boolean>;
+    launch(prompt: string, extraArgs?: string[], cwd?: string): Promise<void>;
+}

package/dist/adapters/shells/copilot-shell.js

@@ -0,0 +1,43 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { readFileSync } from "node:fs";
+import { spawnShell, writeTempPrompt } from "./spawn-shell.js";
+import { wrapWithOverride } from "./override-preamble.js";
+const execAsync = promisify(exec);
+/**
+ * GitHub Copilot CLI アダプター (copilot コマンド)
+ * --interactive フラグでEngramを初回プロンプトとして注入し、
+ * インタラクティブモードを継続する。
+ */
+export class CopilotShell {
+    command;
+    name = "GitHub Copilot CLI";
+    injectionMode = "user-message";
+    constructor(command = "copilot") {
+        this.command = command;
+    }
+    async isAvailable() {
+        try {
+            await execAsync(`which ${this.command}`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async launch(prompt, extraArgs = [], cwd) {
+        const tmp = writeTempPrompt(wrapWithOverride(prompt));
+        try {
+            const fileContent = readFileSync(tmp.path, "utf-8");
+            const args = [
+                "--interactive",
+                fileContent,
+                ...extraArgs,
+            ];
+            await spawnShell(this.command, args, cwd);
+        }
+        finally {
+            tmp.cleanup();
+        }
+    }
+}

package/dist/adapters/shells/gemini-shell.d.ts

@@ -0,0 +1,14 @@
+import type { ShellLauncher, InjectionMode } from "../../core/ports/shell-launcher.js";
+/**
+ * Gemini CLI アダプター
+ * プロンプトをtempファイルに書き出し、
+ * --prompt-interactive で読み込んで注入する。
+ */
+export declare class GeminiShell implements ShellLauncher {
+    private readonly command;
+    readonly name = "Gemini CLI";
+    readonly injectionMode: InjectionMode;
+    constructor(command?: string);
+    isAvailable(): Promise<boolean>;
+    launch(prompt: string, extraArgs?: string[], cwd?: string): Promise<void>;
+}