oc-solomemory-dev 1.0.6-dev.70f1ae5

package/README.md

@@ -0,0 +1,71 @@
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/solomemory-ai/.github/main/brand/logo-mark-white-transparent.png">
+  <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/solomemory-ai/.github/main/brand/logo-mark-black-transparent.png">
+  <img src="https://raw.githubusercontent.com/solomemory-ai/.github/main/brand/logo-mark-black-transparent.png" alt="Solo Memory" width="120">
+</picture>
+
+# Solo Memory for OpenCode
+
+[![npm version](https://img.shields.io/npm/v/oc-solomemory?color=blue&label=stable)](https://www.npmjs.com/package/oc-solomemory)
+[![npm downloads](https://img.shields.io/npm/dm/oc-solomemory)](https://www.npmjs.com/package/oc-solomemory)
+[![License: AGPL-3.0](https://img.shields.io/badge/License-AGPL--3.0-green.svg)](LICENSE)
+[![TypeScript](https://img.shields.io/badge/TypeScript-strict-blue?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+
+Persistent memory plugin for [OpenCode](https://opencode.ai). Your AI agent remembers across sessions and projects.
+
+[Solo Memory](https://solomemory.com) gives your coding agent long-term memory — preferences you've shared, decisions you've made, context from past sessions. It all carries forward automatically.
+
+---
+
+## Install
+
+Get your API key at [solomemory.com](https://solomemory.com), then:
+
+```bash
+npx oc-solomemory@latest install --api-key=your-key
+```
+
+Restart OpenCode. Done.
+
+## What It Does
+
+- **Remembers context** — Your preferences, project decisions, and past conversations are injected into every new session
+- **Syncs conversations** — Sessions are synced to Solo Memory, building knowledge over time
+- **Scopes memory** — Memories are organized by user, project, repo, and branch
+- **Keyword detection** — Say "remember this" and it saves to memory
+- **Codebase indexing** — Run `/solomemory-init` to memorize your project structure
+
+## How It Works
+
+```
+You start a session
+  → Plugin fetches your profile + relevant memories
+  → Agent has full context from day one
+
+You work with the agent
+  → Session syncs to Solo Memory when idle
+
+Next session
+  → Agent already knows what you discussed
+```
+
+### Memory Scopes
+
+| Scope       | What it remembers                    | Example                             |
+| ----------- | ------------------------------------ | ----------------------------------- |
+| **User**    | Your preferences across all projects | "Prefers TypeScript strict mode"    |
+| **Project** | Project-specific context             | "Uses Bun, not Node"                |
+| **Repo**    | Repository knowledge                 | "Auth uses JWT with refresh tokens" |
+| **Branch**  | Branch-specific work                 | "Working on dark mode feature"      |
+
+## Configuration
+
+See [docs/CONFIG.md](docs/CONFIG.md) for advanced options.
+
+## Contributing
+
+See [docs/CONTRIBUTING.md](docs/CONTRIBUTING.md).
+
+## License
+
+[AGPL-3.0](LICENSE)

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+export declare function main(): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"AAoCA,wBAAgB,IAAI,IAAI,IAAI,CAe3B"}

package/dist/cli/install.d.ts

@@ -0,0 +1,2 @@
+export declare function install(apiKey: string | undefined): number;
+//# sourceMappingURL=install.d.ts.map

package/dist/cli/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../src/cli/install.ts"],"names":[],"mappings":"AAqMA,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAK1D"}

package/dist/cli/templates.d.ts

@@ -0,0 +1,3 @@
+export declare const SOLOMEMORY_INIT_COMMAND = "---\ndescription: Initialize Solo Memory with comprehensive codebase knowledge\n---\n\n# Initializing Solo Memory\n\nYou are initializing persistent memory for this codebase. This is not just data collection - you're building context that will make you significantly more effective across all future sessions.\n\n## Understanding Context\n\nYou are a **stateful** coding agent. Users expect to work with you over extended periods - potentially the entire lifecycle of a project. Your memory is how you get better over time and maintain continuity.\n\n## What to Remember\n\n### 1. Procedures (Rules & Workflows)\nExplicit rules that should always be followed:\n- \"Never commit directly to main - always use feature branches\"\n- \"Always run lint before tests\"\n- \"Use conventional commits format\"\n\n### 2. Preferences (Style & Conventions)  \nProject and user coding style:\n- \"Prefer functional components over class components\"\n- \"Use early returns instead of nested conditionals\"\n- \"Always add JSDoc to exported functions\"\n\n### 3. Architecture & Context\nHow the codebase works and why:\n- \"Auth system was refactored in v2.0 - old patterns deprecated\"\n- \"The monorepo used to have 3 modules before consolidation\"\n- \"This pagination bug was fixed before - similar to PR #234\"\n\n## Memory Scopes\n\n**Project-scoped** (`scope: \"project\"`):\n- Build/test/lint commands\n- Architecture and key directories\n- Team conventions specific to this codebase\n- Technology stack and framework choices\n- Known issues and their solutions\n\n**User-scoped** (`scope: \"user\"`):\n- Personal coding preferences across all projects\n- Communication style preferences\n- General workflow habits\n\n## Research Approach\n\nThis is a **deep research** initialization. Take your time and be thorough (~50+ tool calls). The goal is to genuinely understand the project, not just collect surface-level facts.\n\n**What to uncover:**\n- Tech stack and dependencies (explicit and implicit)\n- Project structure and architecture\n- Build/test/deploy commands and workflows\n- Contributors & team dynamics (who works on what?)\n- Commit conventions and branching strategy\n- Code evolution (major refactors, architecture changes)\n- Pain points (areas with lots of bug fixes)\n- Implicit conventions not documented anywhere\n\n## Research Techniques\n\n### File-based\n- README.md, CONTRIBUTING.md, AGENTS.md, CLAUDE.md\n- Package manifests (package.json, Cargo.toml, pyproject.toml, go.mod)\n- Config files (.eslintrc, tsconfig.json, .prettierrc)\n- CI/CD configs (.github/workflows/)\n\n### Git-based\n- `git log --oneline -20` - Recent history\n- `git branch -a` - Branching strategy  \n- `git log --format=\"%s\" -50` - Commit conventions\n- `git shortlog -sn --all | head -10` - Main contributors\n\n### Explore Agent\nFire parallel explore queries for broad understanding:\n```\nTask(explore, \"What is the tech stack and key dependencies?\")\nTask(explore, \"What is the project structure? Key directories?\")\nTask(explore, \"How do you build, test, and run this project?\")\nTask(explore, \"What are the main architectural patterns?\")\nTask(explore, \"What conventions or patterns are used?\")\n```\n\n## How to Do Thorough Research\n\n**Don't just collect data - analyze and cross-reference.**\n\nBad (shallow):\n- Run commands, copy output\n- List facts without understanding\n\nGood (thorough):\n- Cross-reference findings (if inconsistent, dig deeper)\n- Resolve ambiguities (don't leave questions unanswered)\n- Read actual file content, not just names\n- Look for patterns (what do commits tell you about workflow?)\n- Think like a new team member - what would you want to know?\n\n## Saving Memories\n\nUse the `solomemory` tool for each distinct insight:\n\n```\nsolomemory(mode: \"add\", content: \"...\", type: \"...\", scope: \"project\")\n```\n\n**Types:**\n- `project-config` - tech stack, commands, tooling\n- `architecture` - codebase structure, key components, data flow\n- `learned-pattern` - conventions specific to this codebase\n- `error-solution` - known issues and their fixes\n- `preference` - coding style preferences (use with user scope)\n\n**Guidelines:**\n- Save each distinct insight as a separate memory\n- Be concise but include enough context to be useful\n- Include the \"why\" not just the \"what\" when relevant\n- Update memories incrementally as you research (don't wait until the end)\n\n**Good memories:**\n- \"Uses Bun runtime and package manager. Commands: bun install, bun run dev, bun test\"\n- \"API routes in src/routes/, handlers in src/handlers/. Hono framework.\"\n- \"Auth uses Redis sessions, not JWT. Implementation in src/lib/auth.ts\"\n- \"Never use `any` type - strict TypeScript. Use `unknown` and narrow.\"\n- \"Database migrations must be backward compatible - we do rolling deploys\"\n\n## Upfront Questions\n\nBefore diving in, ask:\n1. \"Any specific rules I should always follow?\"\n2. \"Preferences for how I communicate? (terse/detailed)\"\n\n## Reflection Phase\n\nBefore finishing, reflect:\n1. **Completeness**: Did you cover commands, architecture, conventions, gotchas?\n2. **Quality**: Are memories concise and searchable?\n3. **Scope**: Did you correctly separate project vs user knowledge?\n\nThen ask: \"I've initialized memory with X insights. Want me to continue refining, or is this good?\"\n\n## Your Task\n\n1. Ask upfront questions (research depth, rules, preferences)\n2. Check existing memories: `solomemory(mode: \"list\", scope: \"project\")`\n3. Research based on chosen depth\n4. Save memories incrementally as you discover insights\n5. Reflect and verify completeness\n6. Summarize what was learned and ask if user wants refinement\n";
+export declare const SOLOMEMORY_LOGIN_COMMAND = "---\ndescription: Configure Solo Memory API key\n---\n\n# Solo Memory Setup\n\nTo use Solo Memory, you need to set your API key.\n\n## Option 1: Environment Variable (Recommended)\n\n```bash\nexport SOLOMEMORY_API_KEY=\"your-api-key\"\n```\n\nAdd this to your shell profile (~/.bashrc, ~/.zshrc, etc.) for persistence.\n\n## Option 2: Config File\n\nCreate `~/.config/opencode/solomemory.jsonc`:\n\n```jsonc\n{\n  \"apiKey\": \"your-api-key\",\n  // Optional: Custom API URL (default: https://api.solomemory.com)\n  \"apiUrl\": \"https://api.solomemory.com\"\n}\n```\n\n## Option 3: Credentials File\n\nSave credentials using the CLI:\n\n```bash\nnpx oc-solomemory@latest login\n```\n\nThis will prompt for your API key and save it securely.\n\n## Verify Setup\n\nRestart OpenCode and run:\n\n```bash\nopencode -c\n```\n\nYou should see `solomemory` in the tools list.\n";
+//# sourceMappingURL=templates.d.ts.map

package/dist/cli/templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../src/cli/templates.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,0mLAsJnC,CAAC;AAEF,eAAO,MAAM,wBAAwB,22BA+CpC,CAAC"}

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,553 @@
+#!/usr/bin/env node
+
+// src/cli/install.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import path2 from "node:path";
+
+// src/services/auth.ts
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+var CREDENTIALS_DIR = path.join(homedir(), ".solomemory-opencode");
+var CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "credentials.json");
+function saveCredentials(apiKey) {
+  mkdirSync(CREDENTIALS_DIR, { recursive: true, mode: 448 });
+  const credentials = {
+    apiKey,
+    createdAt: new Date().toISOString()
+  };
+  writeFileSync(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2), { mode: 384 });
+}
+function getCredentialsDir() {
+  return CREDENTIALS_DIR;
+}
+
+// src/services/jsonc.ts
+function processStringChar(content, state) {
+  const char = content[state.i];
+  if (char === undefined)
+    return;
+  let backslashCount = 0;
+  let j = state.i - 1;
+  while (j >= 0 && content[j] === "\\") {
+    backslashCount++;
+    j--;
+  }
+  if (backslashCount % 2 === 0) {
+    state.inString = !state.inString;
+  }
+  state.result += char;
+  state.i++;
+}
+function processSingleLineComment(content, state) {
+  const char = content[state.i];
+  if (char === undefined)
+    return;
+  if (char === `
+`) {
+    state.inSingleLineComment = false;
+    state.result += char;
+  }
+  state.i++;
+}
+function processMultiLineComment(content, state) {
+  const char = content[state.i];
+  const nextChar = content[state.i + 1];
+  if (char === "*" && nextChar === "/") {
+    state.inMultiLineComment = false;
+    state.i += 2;
+    return;
+  }
+  if (char === `
+`) {
+    state.result += char;
+  }
+  state.i++;
+}
+function handleCommentStart(char, nextChar, state) {
+  if (char === "/" && nextChar === "/") {
+    state.inSingleLineComment = true;
+    state.i += 2;
+    return true;
+  }
+  if (char === "/" && nextChar === "*") {
+    state.inMultiLineComment = true;
+    state.i += 2;
+    return true;
+  }
+  return false;
+}
+function handleStringState(content, state, char) {
+  if (!state.inSingleLineComment && !state.inMultiLineComment && char === '"') {
+    processStringChar(content, state);
+    return true;
+  }
+  if (state.inString) {
+    state.result += char;
+    state.i++;
+    return true;
+  }
+  return false;
+}
+function handleCommentState(content, state) {
+  if (state.inSingleLineComment) {
+    processSingleLineComment(content, state);
+    return true;
+  }
+  if (state.inMultiLineComment) {
+    processMultiLineComment(content, state);
+    return true;
+  }
+  return false;
+}
+function processCharacter(content, state) {
+  const char = content[state.i];
+  const nextChar = content[state.i + 1];
+  if (handleStringState(content, state, char ?? "")) {
+    return;
+  }
+  if (handleCommentState(content, state)) {
+    return;
+  }
+  if (handleCommentStart(char, nextChar, state)) {
+    return;
+  }
+  if (char !== undefined) {
+    state.result += char;
+  }
+  state.i++;
+}
+function stripJsoncComments(content) {
+  const state = {
+    result: "",
+    i: 0,
+    inString: false,
+    inSingleLineComment: false,
+    inMultiLineComment: false
+  };
+  while (state.i < content.length) {
+    processCharacter(content, state);
+  }
+  return state.result.replaceAll(/,\s*([}\]])/g, "$1");
+}
+
+// src/cli/templates.ts
+var SOLOMEMORY_INIT_COMMAND = `---
+description: Initialize Solo Memory with comprehensive codebase knowledge
+---
+
+# Initializing Solo Memory
+
+You are initializing persistent memory for this codebase. This is not just data collection - you're building context that will make you significantly more effective across all future sessions.
+
+## Understanding Context
+
+You are a **stateful** coding agent. Users expect to work with you over extended periods - potentially the entire lifecycle of a project. Your memory is how you get better over time and maintain continuity.
+
+## What to Remember
+
+### 1. Procedures (Rules & Workflows)
+Explicit rules that should always be followed:
+- "Never commit directly to main - always use feature branches"
+- "Always run lint before tests"
+- "Use conventional commits format"
+
+### 2. Preferences (Style & Conventions)  
+Project and user coding style:
+- "Prefer functional components over class components"
+- "Use early returns instead of nested conditionals"
+- "Always add JSDoc to exported functions"
+
+### 3. Architecture & Context
+How the codebase works and why:
+- "Auth system was refactored in v2.0 - old patterns deprecated"
+- "The monorepo used to have 3 modules before consolidation"
+- "This pagination bug was fixed before - similar to PR #234"
+
+## Memory Scopes
+
+**Project-scoped** (\`scope: "project"\`):
+- Build/test/lint commands
+- Architecture and key directories
+- Team conventions specific to this codebase
+- Technology stack and framework choices
+- Known issues and their solutions
+
+**User-scoped** (\`scope: "user"\`):
+- Personal coding preferences across all projects
+- Communication style preferences
+- General workflow habits
+
+## Research Approach
+
+This is a **deep research** initialization. Take your time and be thorough (~50+ tool calls). The goal is to genuinely understand the project, not just collect surface-level facts.
+
+**What to uncover:**
+- Tech stack and dependencies (explicit and implicit)
+- Project structure and architecture
+- Build/test/deploy commands and workflows
+- Contributors & team dynamics (who works on what?)
+- Commit conventions and branching strategy
+- Code evolution (major refactors, architecture changes)
+- Pain points (areas with lots of bug fixes)
+- Implicit conventions not documented anywhere
+
+## Research Techniques
+
+### File-based
+- README.md, CONTRIBUTING.md, AGENTS.md, CLAUDE.md
+- Package manifests (package.json, Cargo.toml, pyproject.toml, go.mod)
+- Config files (.eslintrc, tsconfig.json, .prettierrc)
+- CI/CD configs (.github/workflows/)
+
+### Git-based
+- \`git log --oneline -20\` - Recent history
+- \`git branch -a\` - Branching strategy  
+- \`git log --format="%s" -50\` - Commit conventions
+- \`git shortlog -sn --all | head -10\` - Main contributors
+
+### Explore Agent
+Fire parallel explore queries for broad understanding:
+\`\`\`
+Task(explore, "What is the tech stack and key dependencies?")
+Task(explore, "What is the project structure? Key directories?")
+Task(explore, "How do you build, test, and run this project?")
+Task(explore, "What are the main architectural patterns?")
+Task(explore, "What conventions or patterns are used?")
+\`\`\`
+
+## How to Do Thorough Research
+
+**Don't just collect data - analyze and cross-reference.**
+
+Bad (shallow):
+- Run commands, copy output
+- List facts without understanding
+
+Good (thorough):
+- Cross-reference findings (if inconsistent, dig deeper)
+- Resolve ambiguities (don't leave questions unanswered)
+- Read actual file content, not just names
+- Look for patterns (what do commits tell you about workflow?)
+- Think like a new team member - what would you want to know?
+
+## Saving Memories
+
+Use the \`solomemory\` tool for each distinct insight:
+
+\`\`\`
+solomemory(mode: "add", content: "...", type: "...", scope: "project")
+\`\`\`
+
+**Types:**
+- \`project-config\` - tech stack, commands, tooling
+- \`architecture\` - codebase structure, key components, data flow
+- \`learned-pattern\` - conventions specific to this codebase
+- \`error-solution\` - known issues and their fixes
+- \`preference\` - coding style preferences (use with user scope)
+
+**Guidelines:**
+- Save each distinct insight as a separate memory
+- Be concise but include enough context to be useful
+- Include the "why" not just the "what" when relevant
+- Update memories incrementally as you research (don't wait until the end)
+
+**Good memories:**
+- "Uses Bun runtime and package manager. Commands: bun install, bun run dev, bun test"
+- "API routes in src/routes/, handlers in src/handlers/. Hono framework."
+- "Auth uses Redis sessions, not JWT. Implementation in src/lib/auth.ts"
+- "Never use \`any\` type - strict TypeScript. Use \`unknown\` and narrow."
+- "Database migrations must be backward compatible - we do rolling deploys"
+
+## Upfront Questions
+
+Before diving in, ask:
+1. "Any specific rules I should always follow?"
+2. "Preferences for how I communicate? (terse/detailed)"
+
+## Reflection Phase
+
+Before finishing, reflect:
+1. **Completeness**: Did you cover commands, architecture, conventions, gotchas?
+2. **Quality**: Are memories concise and searchable?
+3. **Scope**: Did you correctly separate project vs user knowledge?
+
+Then ask: "I've initialized memory with X insights. Want me to continue refining, or is this good?"
+
+## Your Task
+
+1. Ask upfront questions (research depth, rules, preferences)
+2. Check existing memories: \`solomemory(mode: "list", scope: "project")\`
+3. Research based on chosen depth
+4. Save memories incrementally as you discover insights
+5. Reflect and verify completeness
+6. Summarize what was learned and ask if user wants refinement
+`;
+var SOLOMEMORY_LOGIN_COMMAND = `---
+description: Configure Solo Memory API key
+---
+
+# Solo Memory Setup
+
+To use Solo Memory, you need to set your API key.
+
+## Option 1: Environment Variable (Recommended)
+
+\`\`\`bash
+export SOLOMEMORY_API_KEY="your-api-key"
+\`\`\`
+
+Add this to your shell profile (~/.bashrc, ~/.zshrc, etc.) for persistence.
+
+## Option 2: Config File
+
+Create \`~/.config/opencode/solomemory.jsonc\`:
+
+\`\`\`jsonc
+{
+  "apiKey": "your-api-key",
+  // Optional: Custom API URL (default: https://api.solomemory.com)
+  "apiUrl": "https://api.solomemory.com"
+}
+\`\`\`
+
+## Option 3: Credentials File
+
+Save credentials using the CLI:
+
+\`\`\`bash
+npx oc-solomemory@latest login
+\`\`\`
+
+This will prompt for your API key and save it securely.
+
+## Verify Setup
+
+Restart OpenCode and run:
+
+\`\`\`bash
+opencode -c
+\`\`\`
+
+You should see \`solomemory\` in the tools list.
+`;
+
+// src/cli/install.ts
+var OPENCODE_CONFIG_DIR = path2.join(homedir2(), ".config", "opencode");
+var OPENCODE_COMMAND_DIR = path2.join(OPENCODE_CONFIG_DIR, "command");
+var JSON_INDENT_SPACES = 2;
+var SEPARATOR_WIDTH = 50;
+function getPluginTag() {
+  return "1.0.6-dev.70f1ae5".includes("-dev.") ? "dev" : "latest";
+}
+function getPluginName() {
+  return `oc-solomemory@${getPluginTag()}`;
+}
+function isOpencodeConfig(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseOpencodeConfig(content) {
+  const jsonContent = stripJsoncComments(content);
+  try {
+    const parsed = JSON.parse(jsonContent);
+    if (!isOpencodeConfig(parsed)) {
+      console.error("✗ Invalid config file format");
+      return null;
+    }
+    return parsed;
+  } catch {
+    console.error("✗ Failed to parse config file");
+    return null;
+  }
+}
+function insertPluginIntoExistingArray(content) {
+  const match = /("plugin"\s*:\s*\[)([^\]]*?)(\])/.exec(content);
+  if (match === null)
+    return content;
+  const fullMatch = match[0];
+  const start = match[1] ?? "";
+  const middle = match[2] ?? "";
+  const end = match[JSON_INDENT_SPACES + 1] ?? "";
+  const trimmed = middle.trim();
+  const replacement = trimmed === "" ? `${start}
+    "${getPluginName()}"
+  ${end}` : `${start}${middle.trimEnd()},
+    "${getPluginName()}"
+  ${end}`;
+  return content.replace(fullMatch, replacement);
+}
+function writePluginToJsonc(configPath, content) {
+  if (content.includes('"plugin"')) {
+    writeFileSync2(configPath, insertPluginIntoExistingArray(content));
+  } else {
+    const updated = content.replace(/^(\s*\{)/, `$1
+  "plugin": ["${getPluginName()}"],`);
+    writeFileSync2(configPath, updated);
+  }
+}
+function updateConfigWithPlugin(configPath, content) {
+  if (configPath.endsWith(".jsonc")) {
+    writePluginToJsonc(configPath, content);
+  } else {
+    const config = parseOpencodeConfig(content);
+    if (config === null)
+      return;
+    const plugins = config.plugin ?? [];
+    plugins.push(getPluginName());
+    config.plugin = plugins;
+    writeFileSync2(configPath, JSON.stringify(config, null, JSON_INDENT_SPACES));
+  }
+}
+function replaceExistingPlugin(content) {
+  return content.replaceAll(/"oc-solomemory@[^"]*"/g, `"${getPluginName()}"`);
+}
+function addPluginToConfig(configPath) {
+  try {
+    const content = readFileSync2(configPath, "utf8");
+    if (content.includes("oc-solomemory")) {
+      const updated = replaceExistingPlugin(content);
+      writeFileSync2(configPath, updated);
+      console.log(`✓ Plugin updated to ${getPluginName()}`);
+      return true;
+    }
+    const config = parseOpencodeConfig(content);
+    if (config === null)
+      return false;
+    updateConfigWithPlugin(configPath, content);
+    console.log(`✓ Added plugin to ${configPath}`);
+    return true;
+  } catch (error) {
+    console.error("✗ Failed to update config:", error);
+    return false;
+  }
+}
+function findOpencodeConfig() {
+  const candidates = [
+    path2.join(OPENCODE_CONFIG_DIR, "opencode.jsonc"),
+    path2.join(OPENCODE_CONFIG_DIR, "opencode.json")
+  ];
+  for (const filePath of candidates) {
+    if (existsSync2(filePath)) {
+      return filePath;
+    }
+  }
+  return null;
+}
+function createNewConfig() {
+  const configPath = path2.join(OPENCODE_CONFIG_DIR, "opencode.jsonc");
+  mkdirSync2(OPENCODE_CONFIG_DIR, { recursive: true });
+  const config = `{
+  "plugin": ["${getPluginName()}"]
+}
+`;
+  writeFileSync2(configPath, config);
+  console.log(`✓ Created ${configPath}`);
+}
+function createCommands() {
+  mkdirSync2(OPENCODE_COMMAND_DIR, { recursive: true });
+  const initPath = path2.join(OPENCODE_COMMAND_DIR, "solomemory-init.md");
+  writeFileSync2(initPath, SOLOMEMORY_INIT_COMMAND);
+  console.log(`✓ Created /solomemory-init command`);
+  const loginPath = path2.join(OPENCODE_COMMAND_DIR, "solomemory-login.md");
+  writeFileSync2(loginPath, SOLOMEMORY_LOGIN_COMMAND);
+  console.log(`✓ Created /solomemory-login command`);
+}
+function stepRegisterPlugin() {
+  console.log("Step 1: Register plugin in OpenCode config");
+  const configPath = findOpencodeConfig();
+  if (configPath === null) {
+    createNewConfig();
+  } else {
+    addPluginToConfig(configPath);
+  }
+}
+function stepCreateCommands() {
+  console.log(`
+Step 2: Create /solomemory-init and /solomemory-login commands`);
+  createCommands();
+}
+function printApiKeyRequired() {
+  console.error(`✗ API key is required.
+`);
+  console.error("Usage:");
+  console.error("  npx oc-solomemory@latest install <api-key>");
+  console.error(`  npx oc-solomemory@latest install --api-key=<key>
+`);
+  console.error("Get your API key at https://solomemory.com");
+  return 1;
+}
+function saveApiKey(apiKey) {
+  saveCredentials(apiKey);
+  console.log(`✓ API key saved to ${getCredentialsDir()}`);
+  console.log(`
+✓ Setup complete! Restart OpenCode to activate.
+`);
+}
+function runInstall(apiKey) {
+  console.log(`
+\uD83E\uDDE0 oc-solomemory installer
+`);
+  stepRegisterPlugin();
+  stepCreateCommands();
+  console.log(`
+` + "─".repeat(SEPARATOR_WIDTH));
+  console.log(`
+\uD83D\uDD11 Final step: Configure API key
+`);
+  saveApiKey(apiKey);
+  return 0;
+}
+function install(apiKey) {
+  if (typeof apiKey === "string") {
+    return runInstall(apiKey);
+  }
+  return printApiKeyRequired();
+}
+
+// src/cli/index.ts
+function printHelp() {
+  console.log(`
+oc-solomemory - Persistent memory for OpenCode agents
+
+Usage:
+  npx oc-solomemory@latest install <api-key>
+  npx oc-solomemory@latest install --api-key=<key>
+
+Get your API key at https://solomemory.com
+`);
+}
+function shouldShowHelp(command) {
+  return command === undefined || command === "help" || command === "--help" || command === "-h";
+}
+function parseApiKey(args) {
+  const flag = args.find((a) => a.startsWith("--api-key="));
+  if (flag !== undefined)
+    return flag.split("=")[1];
+  const positional = args.find((a) => !a.startsWith("-"));
+  return positional;
+}
+function handleCommand(command, args) {
+  if (command === "install") {
+    return install(parseApiKey(args.slice(1)));
+  }
+  console.error(`Unknown command: ${command}`);
+  printHelp();
+  return 1;
+}
+function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  if (shouldShowHelp(command)) {
+    printHelp();
+    process.exit(0);
+  }
+  if (command === undefined) {
+    process.exit(1);
+  }
+  const exitCode = handleCommand(command, args);
+  process.exit(exitCode);
+}
+
+// src/cli.ts
+main();

package/dist/config.d.ts

@@ -0,0 +1,16 @@
+export declare function getApiKey(): string | undefined;
+export declare function getApiUrl(): string;
+export declare function isConfigured(): boolean;
+export interface RuntimeConfig {
+    readonly maxMemories: number;
+    readonly maxProjectMemories: number;
+    readonly maxProfileItems: number;
+    readonly injectProfile: boolean;
+    readonly containerTagPrefix: string;
+    readonly platformIdentifier: string;
+    readonly autoSyncConversations: boolean;
+    readonly filterPrompt: string;
+}
+export declare function getConfig(): RuntimeConfig;
+export declare const CONFIG: RuntimeConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAuGA,wBAAgB,SAAS,IAAI,MAAM,GAAG,SAAS,CAG9C;AAED,wBAAgB,SAAS,IAAI,MAAM,CAGlC;AAED,wBAAgB,YAAY,IAAI,OAAO,CAEtC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,qBAAqB,EAAE,OAAO,CAAC;IACxC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED,wBAAgB,SAAS,IAAI,aAAa,CAMzC;AAoCD,eAAO,MAAM,MAAM,EAAE,aAAoE,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const SolomemoryPlugin: Plugin;
+export default SolomemoryPlugin;
+//# sourceMappingURL=index.d.ts.map