@link-assistant/agent 0.2.1 → 0.3.1

package/EXAMPLES.md

@@ -211,7 +211,7 @@ echo '{"message":"search web","tools":[{"name":"websearch","params":{"query":"Re
 **opencode (requires OPENCODE_EXPERIMENTAL_EXA=true):**
 
 ```bash
-echo '{"message":"search web","tools":[{"name":"websearch","params":{"query":"TypeScript latest features"}}]}' | OPENCODE_EXPERIMENTAL_EXA=true opencode run --format json --model opencode/grok-code
+echo '{"message":"search web","tools":[{"name":"websearch","params":{"query":"TypeScript latest features"}}]}' | opencode run --format json --model opencode/grok-code
 ```
 
 ### codesearch Tool
@@ -229,7 +229,7 @@ echo '{"message":"search code","tools":[{"name":"codesearch","params":{"query":"
 **opencode (requires OPENCODE_EXPERIMENTAL_EXA=true):**
 
 ```bash
-echo '{"message":"search code","tools":[{"name":"codesearch","params":{"query":"React hooks implementation"}}]}' | OPENCODE_EXPERIMENTAL_EXA=true opencode run --format json --model opencode/grok-code
+echo '{"message":"search code","tools":[{"name":"codesearch","params":{"query":"React hooks implementation"}}]}' | opencode run --format json --model opencode/grok-code
 ```
 
 ## Execution Tools
@@ -248,8 +248,8 @@ echo '{"message":"run batch","tools":[{"name":"batch","params":{"tool_calls":[{"
 
 ```bash
 # Create config file first
-mkdir -p .opencode
-echo '{"experimental":{"batch_tool":true}}' > .opencode/config.json
+mkdir -p .link-assistant-agent
+echo '{"experimental":{"batch_tool":true}}' > .link-assistant-agent/opencode.json
 
 # Then run
 echo '{"message":"run batch","tools":[{"name":"batch","params":{"tool_calls":[{"tool":"bash","parameters":{"command":"echo hello"}},{"tool":"bash","parameters":{"command":"echo world"}}]}}]}' | opencode run --format json --model opencode/grok-code

package/README.md

@@ -314,7 +314,7 @@ agent mcp add playwright npx @playwright/mcp@latest
 agent mcp list
 ```
 
-This will create a configuration file at `~/.config/opencode/opencode.json` (or your system's config directory) with:
+This will create a configuration file at `~/.config/link-assistant-agent/opencode.json` (or your system's config directory) with:
 
 ```json
 {
@@ -477,7 +477,7 @@ The package publishes source files directly (no build step required). Bun handle
 
 ### No Configuration Required
 
-- **WebSearch/CodeSearch**: Work without `OPENCODE_EXPERIMENTAL_EXA` environment variable
+- **WebSearch/CodeSearch**: Work without `LINK_ASSISTANT_AGENT_EXPERIMENTAL_EXA` environment variable (legacy `OPENCODE_EXPERIMENTAL_EXA` still supported)
 - **Batch Tool**: Always enabled, no experimental flag needed
 - **All Tools**: No config files, API keys handled automatically
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "A minimal, public domain AI CLI agent compatible with OpenCode's JSON interface. Bun-only runtime.",
   "main": "src/index.js",
   "type": "module",

package/src/bun/index.ts

@@ -5,10 +5,14 @@ import path from 'path';
 import { NamedError } from '../util/error';
 import { readableStreamToText } from 'bun';
 import { Flag } from '../flag/flag';
+import { Lock } from '../util/lock';
 
 export namespace BunProc {
   const log = Log.create({ service: 'bun' });
 
+  // Lock key for serializing package installations to prevent race conditions
+  const INSTALL_LOCK_KEY = 'bun-install';
+
   export async function run(
     cmd: string[],
     options?: Bun.SpawnOptions.OptionsObject<any, any, any>
@@ -65,8 +69,38 @@ export namespace BunProc {
     })
   );
 
+  // Maximum number of retry attempts for cache-related errors
+  const MAX_RETRIES = 3;
+  // Delay between retries in milliseconds
+  const RETRY_DELAY_MS = 500;
+
+  /**
+   * Check if an error is related to Bun cache issues
+   */
+  function isCacheRelatedError(errorMsg: string): boolean {
+    return (
+      errorMsg.includes('failed copying files from cache') ||
+      errorMsg.includes('FileNotFound') ||
+      errorMsg.includes('ENOENT') ||
+      errorMsg.includes('EACCES') ||
+      errorMsg.includes('EBUSY')
+    );
+  }
+
+  /**
+   * Wait for a specified duration
+   */
+  function delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
   export async function install(pkg: string, version = 'latest') {
     const mod = path.join(Global.Path.cache, 'node_modules', pkg);
+
+    // Use a write lock to serialize all package installations
+    // This prevents race conditions when multiple packages are installed concurrently
+    using _ = await Lock.write(INSTALL_LOCK_KEY);
+
     const pkgjson = Bun.file(path.join(Global.Path.cache, 'package.json'));
     const parsed = await pkgjson.json().catch(async () => {
       const result = { dependencies: {} };
@@ -108,25 +142,78 @@ export namespace BunProc {
       version,
     });
 
-    await BunProc.run(args, {
-      cwd: Global.Path.cache,
-    }).catch((e) => {
-      log.error('package installation failed', {
+    // Retry logic for cache-related errors
+    let lastError: Error | undefined;
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        await BunProc.run(args, {
+          cwd: Global.Path.cache,
+        });
+
+        log.info('package installed successfully', { pkg, version, attempt });
+        parsed.dependencies[pkg] = version;
+        await Bun.write(pkgjson.name!, JSON.stringify(parsed, null, 2));
+        return mod;
+      } catch (e) {
+        const errorMsg = e instanceof Error ? e.message : String(e);
+        const isCacheError = isCacheRelatedError(errorMsg);
+
+        log.warn('package installation attempt failed', {
+          pkg,
+          version,
+          attempt,
+          maxRetries: MAX_RETRIES,
+          error: errorMsg,
+          isCacheError,
+        });
+
+        if (isCacheError && attempt < MAX_RETRIES) {
+          log.info('retrying installation after cache-related error', {
+            pkg,
+            version,
+            attempt,
+            nextAttempt: attempt + 1,
+            delayMs: RETRY_DELAY_MS,
+          });
+          await delay(RETRY_DELAY_MS);
+          lastError = e instanceof Error ? e : new Error(errorMsg);
+          continue;
+        }
+
+        // Non-cache error or final attempt - log and throw
+        log.error('package installation failed', {
+          pkg,
+          version,
+          error: errorMsg,
+          stack: e instanceof Error ? e.stack : undefined,
+          possibleCacheCorruption: isCacheError,
+          attempts: attempt,
+        });
+
+        // Provide helpful recovery instructions for cache-related errors
+        if (isCacheError) {
+          log.error(
+            'Bun package cache may be corrupted. Try clearing the cache with: bun pm cache rm'
+          );
+        }
+
+        throw new InstallFailedError(
+          { pkg, version, details: errorMsg },
+          {
+            cause: e,
+          }
+        );
+      }
+    }
+
+    // This should not be reached, but handle it just in case
+    throw new InstallFailedError(
+      {
         pkg,
         version,
-        error: e instanceof Error ? e.message : String(e),
-        stack: e instanceof Error ? e.stack : undefined,
-      });
-      throw new InstallFailedError(
-        { pkg, version, details: e instanceof Error ? e.message : String(e) },
-        {
-          cause: e,
-        }
-      );
-    });
-    log.info('package installed successfully', { pkg, version });
-    parsed.dependencies[pkg] = version;
-    await Bun.write(pkgjson.name!, JSON.stringify(parsed, null, 2));
-    return mod;
+        details: lastError?.message ?? 'Installation failed after all retries',
+      },
+      { cause: lastError }
+    );
   }
 }

package/src/config/config.ts

@@ -22,6 +22,103 @@ import { ConfigMarkdown } from './markdown';
 export namespace Config {
   const log = Log.create({ service: 'config' });
 
+  /**
+   * Automatically migrate .opencode directories to .link-assistant-agent
+   * This ensures a smooth transition for both file system configs and environment variables.
+   * Once .link-assistant-agent exists, we stop reading from .opencode.
+   */
+  async function migrateConfigDirectories() {
+    // Find all .opencode and .link-assistant-agent directories in the project hierarchy
+    const allDirs = await Array.fromAsync(
+      Filesystem.up({
+        targets: ['.link-assistant-agent', '.opencode'],
+        start: Instance.directory,
+        stop: Instance.worktree,
+      })
+    );
+
+    const newConfigDirs = allDirs.filter((d) =>
+      d.endsWith('.link-assistant-agent')
+    );
+    const oldConfigDirs = allDirs.filter((d) => d.endsWith('.opencode'));
+
+    // For each old config directory, check if there's a corresponding new one
+    for (const oldDir of oldConfigDirs) {
+      const parentDir = path.dirname(oldDir);
+      const newDir = path.join(parentDir, '.link-assistant-agent');
+
+      // Check if the new directory already exists at the same level
+      const newDirExists = newConfigDirs.includes(newDir);
+
+      if (!newDirExists) {
+        try {
+          // Perform migration by copying the entire directory
+          log.info(
+            `Migrating config from ${oldDir} to ${newDir} for smooth transition`
+          );
+
+          // Use fs-extra style recursive copy
+          await copyDirectory(oldDir, newDir);
+
+          log.info(`Successfully migrated config to ${newDir}`);
+        } catch (error) {
+          log.error(`Failed to migrate config from ${oldDir}:`, error);
+          // Don't throw - allow the app to continue with the old config
+        }
+      }
+    }
+
+    // Also migrate global config if needed
+    const oldGlobalPath = path.join(os.homedir(), '.config', 'opencode');
+    const newGlobalPath = Global.Path.config;
+
+    try {
+      const oldGlobalExists = await fs
+        .stat(oldGlobalPath)
+        .then(() => true)
+        .catch(() => false);
+      const newGlobalExists = await fs
+        .stat(newGlobalPath)
+        .then(() => true)
+        .catch(() => false);
+
+      if (oldGlobalExists && !newGlobalExists) {
+        log.info(
+          `Migrating global config from ${oldGlobalPath} to ${newGlobalPath}`
+        );
+        await copyDirectory(oldGlobalPath, newGlobalPath);
+        log.info(`Successfully migrated global config to ${newGlobalPath}`);
+      }
+    } catch (error) {
+      log.error('Failed to migrate global config:', error);
+      // Don't throw - allow the app to continue
+    }
+  }
+
+  /**
+   * Recursively copy a directory and all its contents
+   */
+  async function copyDirectory(src: string, dest: string) {
+    // Create destination directory
+    await fs.mkdir(dest, { recursive: true });
+
+    // Read all entries in source directory
+    const entries = await fs.readdir(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        // Recursively copy subdirectories
+        await copyDirectory(srcPath, destPath);
+      } else if (entry.isFile() || entry.isSymbolicLink()) {
+        // Copy files
+        await fs.copyFile(srcPath, destPath);
+      }
+    }
+  }
+
   export const state = Instance.state(async () => {
     const auth = await Auth.all();
     let result = await global();
@@ -64,20 +161,43 @@ export namespace Config {
     result.agent = result.agent || {};
     result.mode = result.mode || {};
 
-    const directories = [
-      Global.Path.config,
-      ...(await Array.fromAsync(
-        Filesystem.up({
-          targets: ['.opencode'],
-          start: Instance.directory,
-          stop: Instance.worktree,
-        })
-      )),
-    ];
+    // Perform automatic migration from .opencode to .link-assistant-agent if needed
+    await migrateConfigDirectories();
+
+    // Find all config directories
+    const foundDirs = await Array.fromAsync(
+      Filesystem.up({
+        targets: ['.link-assistant-agent', '.opencode'],
+        start: Instance.directory,
+        stop: Instance.worktree,
+      })
+    );
+
+    // Check if any .link-assistant-agent directory exists
+    const hasNewConfig = foundDirs.some((d) =>
+      d.endsWith('.link-assistant-agent')
+    );
+
+    // Filter out .opencode directories if .link-assistant-agent exists
+    const filteredDirs = foundDirs.filter((dir) => {
+      // If .link-assistant-agent exists, exclude .opencode directories
+      if (hasNewConfig && dir.endsWith('.opencode')) {
+        log.debug(
+          'Skipping .opencode directory (using .link-assistant-agent):',
+          {
+            path: dir,
+          }
+        );
+        return false;
+      }
+      return true;
+    });
+
+    const directories = [Global.Path.config, ...filteredDirs];
 
     if (Flag.OPENCODE_CONFIG_DIR) {
       directories.push(Flag.OPENCODE_CONFIG_DIR);
-      log.debug('loading config from OPENCODE_CONFIG_DIR', {
+      log.debug('loading config from LINK_ASSISTANT_AGENT_CONFIG_DIR', {
         path: Flag.OPENCODE_CONFIG_DIR,
       });
     }
@@ -86,7 +206,11 @@ export namespace Config {
     for (const dir of directories) {
       await assertValid(dir);
 
-      if (dir.endsWith('.opencode') || dir === Flag.OPENCODE_CONFIG_DIR) {
+      if (
+        dir.endsWith('.link-assistant-agent') ||
+        dir.endsWith('.opencode') ||
+        dir === Flag.OPENCODE_CONFIG_DIR
+      ) {
         for (const file of ['opencode.jsonc', 'opencode.json']) {
           log.debug(`loading config from ${path.join(dir, file)}`);
           result = mergeDeep(result, await loadFile(path.join(dir, file)));
@@ -162,7 +286,11 @@ export namespace Config {
       if (!md.data) continue;
 
       const name = (() => {
-        const patterns = ['/.opencode/command/', '/command/'];
+        const patterns = [
+          '/.link-assistant-agent/command/',
+          '/.opencode/command/',
+          '/command/',
+        ];
         const pattern = patterns.find((p) => item.includes(p));
 
         if (pattern) {
@@ -202,11 +330,13 @@ export namespace Config {
 
       // Extract relative path from agent folder for nested agents
       let agentName = path.basename(item, '.md');
-      const agentFolderPath = item.includes('/.opencode/agent/')
-        ? item.split('/.opencode/agent/')[1]
-        : item.includes('/agent/')
-          ? item.split('/agent/')[1]
-          : agentName + '.md';
+      const agentFolderPath = item.includes('/.link-assistant-agent/agent/')
+        ? item.split('/.link-assistant-agent/agent/')[1]
+        : item.includes('/.opencode/agent/')
+          ? item.split('/.opencode/agent/')[1]
+          : item.includes('/agent/')
+            ? item.split('/agent/')[1]
+            : agentName + '.md';
 
       // If agent is in a subfolder, include folder path in name
       if (agentFolderPath.includes('/')) {

package/src/flag/flag.ts

@@ -1,29 +1,67 @@
 export namespace Flag {
-  // OPENCODE_AUTO_SHARE removed - no sharing support
-  export const OPENCODE_CONFIG = process.env['OPENCODE_CONFIG'];
-  export const OPENCODE_CONFIG_DIR = process.env['OPENCODE_CONFIG_DIR'];
-  export const OPENCODE_CONFIG_CONTENT = process.env['OPENCODE_CONFIG_CONTENT'];
-  export const OPENCODE_DISABLE_AUTOUPDATE = truthy(
+  // Helper to check env vars with new prefix first, then fall back to old prefix for backwards compatibility
+  function getEnv(newKey: string, oldKey: string): string | undefined {
+    return process.env[newKey] ?? process.env[oldKey];
+  }
+
+  function truthyCompat(newKey: string, oldKey: string): boolean {
+    const value = (getEnv(newKey, oldKey) ?? '').toLowerCase();
+    return value === 'true' || value === '1';
+  }
+
+  // LINK_ASSISTANT_AGENT_AUTO_SHARE removed - no sharing support
+  export const OPENCODE_CONFIG = getEnv(
+    'LINK_ASSISTANT_AGENT_CONFIG',
+    'OPENCODE_CONFIG'
+  );
+  export const OPENCODE_CONFIG_DIR = getEnv(
+    'LINK_ASSISTANT_AGENT_CONFIG_DIR',
+    'OPENCODE_CONFIG_DIR'
+  );
+  export const OPENCODE_CONFIG_CONTENT = getEnv(
+    'LINK_ASSISTANT_AGENT_CONFIG_CONTENT',
+    'OPENCODE_CONFIG_CONTENT'
+  );
+  export const OPENCODE_DISABLE_AUTOUPDATE = truthyCompat(
+    'LINK_ASSISTANT_AGENT_DISABLE_AUTOUPDATE',
     'OPENCODE_DISABLE_AUTOUPDATE'
   );
-  export const OPENCODE_DISABLE_PRUNE = truthy('OPENCODE_DISABLE_PRUNE');
-  export const OPENCODE_ENABLE_EXPERIMENTAL_MODELS = truthy(
+  export const OPENCODE_DISABLE_PRUNE = truthyCompat(
+    'LINK_ASSISTANT_AGENT_DISABLE_PRUNE',
+    'OPENCODE_DISABLE_PRUNE'
+  );
+  export const OPENCODE_ENABLE_EXPERIMENTAL_MODELS = truthyCompat(
+    'LINK_ASSISTANT_AGENT_ENABLE_EXPERIMENTAL_MODELS',
     'OPENCODE_ENABLE_EXPERIMENTAL_MODELS'
   );
-  export const OPENCODE_DISABLE_AUTOCOMPACT = truthy(
+  export const OPENCODE_DISABLE_AUTOCOMPACT = truthyCompat(
+    'LINK_ASSISTANT_AGENT_DISABLE_AUTOCOMPACT',
     'OPENCODE_DISABLE_AUTOCOMPACT'
   );
 
   // Experimental
-  export const OPENCODE_EXPERIMENTAL = truthy('OPENCODE_EXPERIMENTAL');
+  export const OPENCODE_EXPERIMENTAL = truthyCompat(
+    'LINK_ASSISTANT_AGENT_EXPERIMENTAL',
+    'OPENCODE_EXPERIMENTAL'
+  );
   export const OPENCODE_EXPERIMENTAL_WATCHER =
-    OPENCODE_EXPERIMENTAL || truthy('OPENCODE_EXPERIMENTAL_WATCHER');
+    OPENCODE_EXPERIMENTAL ||
+    truthyCompat(
+      'LINK_ASSISTANT_AGENT_EXPERIMENTAL_WATCHER',
+      'OPENCODE_EXPERIMENTAL_WATCHER'
+    );
 
   // Verbose mode - enables detailed logging of API requests
-  export let OPENCODE_VERBOSE = truthy('OPENCODE_VERBOSE');
+  export let OPENCODE_VERBOSE = truthyCompat(
+    'LINK_ASSISTANT_AGENT_VERBOSE',
+    'OPENCODE_VERBOSE'
+  );
 
   // Dry run mode - simulate operations without making actual API calls or changes
-  export let OPENCODE_DRY_RUN = truthy('OPENCODE_DRY_RUN');
+  export let OPENCODE_DRY_RUN = truthyCompat(
+    'LINK_ASSISTANT_AGENT_DRY_RUN',
+    'OPENCODE_DRY_RUN'
+  );
 
   // Allow setting verbose mode programmatically (e.g., from CLI --verbose flag)
   export function setVerbose(value: boolean) {

package/src/global/index.ts

@@ -3,7 +3,7 @@ import { xdgData, xdgCache, xdgConfig, xdgState } from 'xdg-basedir';
 import path from 'path';
 import os from 'os';
 
-const app = 'opencode';
+const app = 'link-assistant-agent';
 
 const data = path.join(xdgData!, app);
 const cache = path.join(xdgCache!, app);

package/src/provider/provider.ts

@@ -876,7 +876,13 @@ export namespace Provider {
     }
   }
 
-  const priority = ['gpt-5', 'claude-sonnet-4', 'big-pickle', 'gemini-3-pro'];
+  const priority = [
+    'grok-code',
+    'gpt-5',
+    'claude-sonnet-4',
+    'big-pickle',
+    'gemini-3-pro',
+  ];
   export function sort(models: ModelsDev.Model[]) {
     return sortBy(
       models,
@@ -893,13 +899,27 @@ export namespace Provider {
     const cfg = await Config.get();
     if (cfg.model) return parseModel(cfg.model);
 
-    const provider = await list()
-      .then((val) => Object.values(val))
-      .then((x) =>
-        x.find(
-          (p) => !cfg.provider || Object.keys(cfg.provider).includes(p.info.id)
-        )
-      );
+    // Prefer opencode provider if available
+    const providers = await list().then((val) => Object.values(val));
+    const opencodeProvider = providers.find((p) => p.info.id === 'opencode');
+    if (opencodeProvider) {
+      const [model] = sort(Object.values(opencodeProvider.info.models));
+      if (model) {
+        log.info('using opencode provider as default', {
+          provider: opencodeProvider.info.id,
+          model: model.id,
+        });
+        return {
+          providerID: opencodeProvider.info.id,
+          modelID: model.id,
+        };
+      }
+    }
+
+    // Fall back to any available provider if opencode is not available
+    const provider = providers.find(
+      (p) => !cfg.provider || Object.keys(cfg.provider).includes(p.info.id)
+    );
     if (!provider) throw new Error('no providers found');
     const [model] = sort(Object.values(provider.info.models));
     if (!model) throw new Error('no models found');

package/src/session/prompt.ts

@@ -290,10 +290,27 @@ export namespace SessionPrompt {
           history: msgs,
         });
 
-      const model = await Provider.getModel(
-        lastUser.model.providerID,
-        lastUser.model.modelID
-      );
+      let model;
+      try {
+        model = await Provider.getModel(
+          lastUser.model.providerID,
+          lastUser.model.modelID
+        );
+      } catch (error) {
+        log.warn(
+          'Failed to initialize specified model, falling back to default model',
+          {
+            providerID: lastUser.model.providerID,
+            modelID: lastUser.model.modelID,
+            error: error instanceof Error ? error.message : String(error),
+          }
+        );
+        const defaultModel = await Provider.defaultModel();
+        model = await Provider.getModel(
+          defaultModel.providerID,
+          defaultModel.modelID
+        );
+      }
       const task = tasks.pop();
 
       // pending subtask