autohand-cli 0.9.1 → 0.9.2

package/dist/chunk-CMEZ42F2.cjs

@@ -0,0 +1,303 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/onboarding/agentsGenerator.ts
+var AgentsGenerator = class {
+  /**
+   * Generate AGENTS.md content
+   */
+  generateContent(info, options) {
+    const sections = [];
+    sections.push("# AGENTS.md");
+    sections.push("");
+    sections.push("This file helps Autohand understand how to work with this project.");
+    sections.push("");
+    sections.push(this.generateProjectOverview(info));
+    if (info.packageManager) {
+      sections.push(this.generateCommandsSection(info));
+    }
+    if (info.testFramework) {
+      sections.push(this.generateTestingSection(info));
+    }
+    if (info.framework) {
+      const frameworkSection = this.generateFrameworkSection(info);
+      if (frameworkSection) {
+        sections.push(frameworkSection);
+      }
+    }
+    sections.push(this.generateInstructionSourcesSection());
+    sections.push(this.generateCodeStyleSection(info));
+    sections.push(this.generateConstraintsSection());
+    if (_optionalChain([options, 'optionalAccess', _ => _.customSections])) {
+      for (const section of options.customSections) {
+        sections.push(`## ${section.title}`);
+        sections.push("");
+        sections.push(section.content);
+        sections.push("");
+      }
+    }
+    return sections.join("\n");
+  }
+  /**
+   * Generate project overview section
+   */
+  generateProjectOverview(info) {
+    const lines = [];
+    lines.push("## Project Overview");
+    lines.push("");
+    if (info.language) {
+      lines.push(`- **Language**: ${info.language}`);
+    }
+    if (info.framework) {
+      lines.push(`- **Framework**: ${info.framework}`);
+    }
+    if (info.packageManager) {
+      lines.push(`- **Package Manager**: ${info.packageManager}`);
+    }
+    if (info.testFramework) {
+      lines.push(`- **Test Framework**: ${info.testFramework}`);
+    }
+    if (info.buildTool) {
+      lines.push(`- **Build Tool**: ${info.buildTool}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate commands section based on package manager
+   */
+  generateCommandsSection(info) {
+    const lines = [];
+    lines.push("## Commands");
+    lines.push("");
+    const pm = info.packageManager;
+    if (info.language === "Rust") {
+      lines.push("- **Build**: `cargo build`");
+      lines.push("- **Build (release)**: `cargo build --release`");
+      lines.push("- **Run**: `cargo run`");
+      lines.push("- **Test**: `cargo test`");
+      lines.push("- **Check**: `cargo check`");
+      lines.push("- **Format**: `cargo fmt`");
+      lines.push("- **Lint**: `cargo clippy`");
+    } else if (info.language === "Go") {
+      lines.push("- **Build**: `go build`");
+      lines.push("- **Run**: `go run .`");
+      lines.push("- **Test**: `go test ./...`");
+      lines.push("- **Format**: `go fmt ./...`");
+      lines.push("- **Vet**: `go vet ./...`");
+    } else if (info.language === "Python") {
+      if (pm === "poetry") {
+        lines.push("- **Install**: `poetry install`");
+        lines.push("- **Run**: `poetry run python main.py`");
+        lines.push("- **Add dependency**: `poetry add <package>`");
+        if (info.testFramework) {
+          lines.push(`- **Test**: \`poetry run pytest\``);
+        }
+      } else if (pm === "pipenv") {
+        lines.push("- **Install**: `pipenv install`");
+        lines.push("- **Run**: `pipenv run python main.py`");
+        if (info.testFramework) {
+          lines.push(`- **Test**: \`pipenv run pytest\``);
+        }
+      } else {
+        lines.push("- **Install**: `pip install -r requirements.txt`");
+        lines.push("- **Run**: `python main.py`");
+        if (info.testFramework) {
+          lines.push(`- **Test**: \`pytest\``);
+        }
+      }
+    } else {
+      const run = pm === "npm" ? "npm run" : pm;
+      const install = pm === "npm" ? "npm install" : `${pm} install`;
+      lines.push(`- **Install**: \`${install}\``);
+      lines.push(`- **Dev**: \`${run} dev\``);
+      lines.push(`- **Build**: \`${run} build\``);
+      if (info.testFramework) {
+        lines.push(`- **Test**: \`${run} test\``);
+      }
+      if (info.linter) {
+        lines.push(`- **Lint**: \`${run} lint\``);
+      }
+      if (info.formatter) {
+        lines.push(`- **Format**: \`${run} format\``);
+      }
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate testing section
+   */
+  generateTestingSection(info) {
+    const lines = [];
+    lines.push("## Testing");
+    lines.push("");
+    lines.push(`This project uses **${info.testFramework}** for testing.`);
+    lines.push("");
+    lines.push("- Write tests for new features before implementation");
+    lines.push("- Run tests before committing changes");
+    lines.push("- Aim for good test coverage on critical paths");
+    if (info.testFramework === "Vitest" || info.testFramework === "Jest") {
+      lines.push("- Use `describe` and `it` blocks to organize tests");
+      lines.push("- Mock external dependencies when appropriate");
+    } else if (info.testFramework === "pytest") {
+      lines.push("- Use fixtures for shared test setup");
+      lines.push("- Use `pytest.mark` for test categorization");
+    } else if (info.testFramework === "Playwright" || info.testFramework === "Cypress") {
+      lines.push("- Write E2E tests for critical user flows");
+      lines.push("- Keep selectors stable and meaningful");
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate framework-specific section
+   */
+  generateFrameworkSection(info) {
+    const lines = [];
+    switch (info.framework) {
+      case "Next.js":
+        lines.push("## Next.js Guidelines");
+        lines.push("");
+        lines.push("- Use the App Router for new pages (`app/` directory)");
+        lines.push("- Prefer Server Components by default");
+        lines.push('- Use `"use client"` only when needed for interactivity');
+        lines.push("- Keep API routes in `app/api/`");
+        lines.push("- Use `next/image` for optimized images");
+        lines.push("- Use `next/link` for client-side navigation");
+        break;
+      case "React":
+        lines.push("## React Guidelines");
+        lines.push("");
+        lines.push("- Use functional components with hooks");
+        lines.push("- Keep components small and focused");
+        lines.push("- Use custom hooks to share logic");
+        lines.push("- Prefer composition over inheritance");
+        lines.push("- Use TypeScript interfaces for props");
+        break;
+      case "Vue":
+        lines.push("## Vue Guidelines");
+        lines.push("");
+        lines.push("- Use Composition API for new components");
+        lines.push("- Keep components in single-file format (.vue)");
+        lines.push("- Use composables to share logic");
+        break;
+      case "Express":
+        lines.push("## Express Guidelines");
+        lines.push("");
+        lines.push("- Use middleware for cross-cutting concerns");
+        lines.push("- Keep route handlers thin, delegate to services");
+        lines.push("- Use async/await with proper error handling");
+        lines.push("- Validate request input before processing");
+        break;
+      case "FastAPI":
+        lines.push("## FastAPI Guidelines");
+        lines.push("");
+        lines.push("- Use Pydantic models for request/response validation");
+        lines.push("- Use dependency injection for shared resources");
+        lines.push("- Keep endpoints in organized routers");
+        lines.push("- Use async functions for I/O operations");
+        break;
+      case "Django":
+        lines.push("## Django Guidelines");
+        lines.push("");
+        lines.push("- Follow Django project structure conventions");
+        lines.push("- Use class-based views where appropriate");
+        lines.push("- Keep business logic in models or services");
+        lines.push("- Use Django ORM for database operations");
+        break;
+      case "Flask":
+        lines.push("## Flask Guidelines");
+        lines.push("");
+        lines.push("- Use blueprints to organize routes");
+        lines.push("- Keep route handlers focused");
+        lines.push("- Use Flask extensions for common functionality");
+        break;
+      case "NestJS":
+        lines.push("## NestJS Guidelines");
+        lines.push("");
+        lines.push("- Follow module-based architecture");
+        lines.push("- Use dependency injection");
+        lines.push("- Use decorators for metadata");
+        lines.push("- Keep controllers thin, services fat");
+        break;
+      default:
+        return null;
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate instruction sources section
+   */
+  generateInstructionSourcesSection() {
+    const lines = [];
+    lines.push("## Instruction Sources");
+    lines.push("");
+    lines.push("- Check saved memories and preferences before implementation work.");
+    lines.push("- Follow this AGENTS.md file for repository-specific guidance.");
+    lines.push("- AGENTS.md takes precedence over CLAUDE.md when both files provide instructions.");
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate code style section
+   */
+  generateCodeStyleSection(info) {
+    const lines = [];
+    lines.push("## Code Style");
+    lines.push("");
+    if (info.language === "TypeScript") {
+      lines.push("- Use strict TypeScript settings");
+      lines.push("- Define types/interfaces for data structures");
+      lines.push("- Avoid `any` type - use `unknown` if type is truly unknown");
+      lines.push("- Use type inference where obvious");
+    } else if (info.language === "Python") {
+      lines.push("- Follow PEP 8 style guidelines");
+      lines.push("- Use type hints for function signatures");
+      lines.push("- Use docstrings for public functions");
+    } else if (info.language === "Rust") {
+      lines.push("- Follow Rust naming conventions (snake_case for functions)");
+      lines.push("- Use descriptive error types");
+      lines.push("- Prefer `Result` over panicking");
+    } else if (info.language === "Go") {
+      lines.push("- Follow Go idioms and conventions");
+      lines.push("- Use short variable names in small scopes");
+      lines.push("- Handle errors explicitly");
+    }
+    lines.push("- Follow existing patterns in the codebase");
+    lines.push("- Use meaningful variable and function names");
+    lines.push("- Add comments for complex logic");
+    lines.push("- Keep functions focused and small");
+    if (info.linter) {
+      lines.push(`- Run **${info.linter}** before committing`);
+    }
+    if (info.formatter) {
+      lines.push(`- Format code with **${info.formatter}**`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate constraints section
+   */
+  generateConstraintsSection() {
+    const lines = [];
+    lines.push("## Constraints");
+    lines.push("");
+    lines.push("- Do not modify files outside the project directory");
+    lines.push("- Ask before making breaking changes");
+    lines.push("- Prefer editing existing files over creating new ones");
+    lines.push("- Do not delete files without confirmation");
+    lines.push("- Keep dependencies minimal - avoid adding new ones without good reason");
+    lines.push("- Do not commit sensitive data (API keys, secrets, credentials)");
+    lines.push("");
+    return lines.join("\n");
+  }
+};
+
+
+
+exports.AgentsGenerator = AgentsGenerator;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-X5P6QQOB.cjs → chunk-CNQKIWIS.cjs}

@@ -1,9 +1,13 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-var _chunkP6SLT2F4cjs = require('./chunk-P6SLT2F4.cjs');
+var _chunkAZLHUPNCcjs = require('./chunk-AZLHUPNC.cjs');
 
 
-var _chunkHK5A54AVcjs = require('./chunk-HK5A54AV.cjs');
+
+var _chunkEK34UZPBcjs = require('./chunk-EK34UZPB.cjs');
+
+
+var _chunk7TO3PDMVcjs = require('./chunk-7TO3PDMV.cjs');
 
 
 
@@ -11,16 +15,16 @@ var _chunkHK5A54AVcjs = require('./chunk-HK5A54AV.cjs');
 var _chunkYWTIXHU6cjs = require('./chunk-YWTIXHU6.cjs');
 
 
-var _chunkKASXKDF2cjs = require('./chunk-KASXKDF2.cjs');
+var _chunk3JURXAL6cjs = require('./chunk-3JURXAL6.cjs');
 
 // src/config.ts
 var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
 var _path = require('path'); var _path2 = _interopRequireDefault(_path);
 var _yaml = require('yaml'); var _yaml2 = _interopRequireDefault(_yaml);
-var DEFAULT_CONFIG_PATH = _chunkKASXKDF2cjs.AUTOHAND_FILES.configJson;
-var TOML_CONFIG_PATH = _chunkKASXKDF2cjs.AUTOHAND_FILES.configToml;
-var YAML_CONFIG_PATH = _chunkKASXKDF2cjs.AUTOHAND_FILES.configYaml;
-var YML_CONFIG_PATH = _chunkKASXKDF2cjs.AUTOHAND_FILES.configYml;
+var DEFAULT_CONFIG_PATH = _chunk3JURXAL6cjs.AUTOHAND_FILES.configJson;
+var TOML_CONFIG_PATH = _chunk3JURXAL6cjs.AUTOHAND_FILES.configToml;
+var YAML_CONFIG_PATH = _chunk3JURXAL6cjs.AUTOHAND_FILES.configYaml;
+var YML_CONFIG_PATH = _chunk3JURXAL6cjs.AUTOHAND_FILES.configYml;
 var DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
 var DEFAULT_OLLAMA_URL = "http://localhost:11434";
 var DEFAULT_LLAMACPP_URL = "http://localhost:8080";
@@ -28,6 +32,7 @@ var DEFAULT_OPENAI_URL = "https://api.openai.com/v1";
 var DEFAULT_MLX_URL = "http://localhost:8080";
 var DEFAULT_LLMGATEWAY_URL = "https://api.llmgateway.io/v1";
 var DEFAULT_ZAI_URL = "https://api.z.ai/api/paas/v4";
+var DEFAULT_SAKANA_URL = "https://api.sakana.ai/v1";
 var DEFAULT_DEEPSEEK_URL = "https://api.deepseek.com";
 var DEFAULT_BEDROCK_REGION = "us-east-1";
 function normalizeProviderName(provider) {
@@ -37,6 +42,9 @@ function normalizeProviderName(provider) {
   if (provider === "vertex") {
     return "vertexai";
   }
+  if (_chunkEK34UZPBcjs.isCustomProviderName.call(void 0, provider)) {
+    return provider;
+  }
   const validProviders = [
     "openrouter",
     "ollama",
@@ -46,6 +54,7 @@ function normalizeProviderName(provider) {
     "llmgateway",
     "azure",
     "zai",
+    "sakana",
     "vertexai",
     "xai",
     "cerebras",
@@ -343,7 +352,7 @@ async function loadConfig(customPath, workspaceRoot) {
   const normalized = normalizeConfig(parsed);
   let workspaceSettings = null;
   if (workspaceRoot) {
-    workspaceSettings = await _chunkP6SLT2F4cjs.loadLocalProjectSettings.call(void 0, workspaceRoot);
+    workspaceSettings = await _chunkAZLHUPNCcjs.loadLocalProjectSettings.call(void 0, workspaceRoot);
   }
   const withWorkspace = mergeWorkspaceSettings(normalized, workspaceSettings);
   const withEnv = mergeEnvVariables(withWorkspace);
@@ -363,7 +372,18 @@ function mergeWorkspaceSettings(globalConfig, workspaceSettings) {
   }
   if (workspaceSettings.model !== void 0) {
     const provider = workspaceSettings.provider || merged.provider;
-    if (provider && merged[provider]) {
+    if (provider && _chunkEK34UZPBcjs.isCustomProviderName.call(void 0, provider)) {
+      const customProvider = _chunkEK34UZPBcjs.getCustomProviderConfig.call(void 0, merged, provider);
+      if (customProvider) {
+        merged.customProviders = {
+          ...merged.customProviders,
+          [customProvider.id]: {
+            ...customProvider,
+            model: workspaceSettings.model
+          }
+        };
+      }
+    } else if (provider && merged[provider]) {
       merged[provider].model = workspaceSettings.model;
     }
   }
@@ -477,7 +497,7 @@ function normalizeConfig(config) {
   return config;
 }
 function isModernConfig(config) {
-  return typeof config.openrouter === "object" || typeof config.ollama === "object" || typeof config.llamacpp === "object" || typeof config.openai === "object" || typeof config.mlx === "object" || typeof config.azure === "object" || typeof config.zai === "object" || typeof config.vertexai === "object" || typeof config.xai === "object" || typeof config.cerebras === "object" || typeof config.nvidia === "object" || typeof config.deepseek === "object" || typeof config.bedrock === "object";
+  return typeof config.openrouter === "object" || typeof config.ollama === "object" || typeof config.llamacpp === "object" || typeof config.openai === "object" || typeof config.mlx === "object" || typeof config.azure === "object" || typeof config.zai === "object" || typeof config.sakana === "object" || typeof config.vertexai === "object" || typeof config.xai === "object" || typeof config.cerebras === "object" || typeof config.nvidia === "object" || typeof config.deepseek === "object" || typeof config.bedrock === "object" || typeof config.customProviders === "object";
 }
 function isLegacyConfig(config) {
   return typeof config.api_key === "string";
@@ -517,6 +537,9 @@ function validateConfig(config, configPath) {
       throw new Error(`ui.activityVerbsEnabled must be boolean in ${configPath}`);
     }
   }
+  if (_optionalChain([config, 'access', _9 => _9.auth, 'optionalAccess', _10 => _10.apiKeyHelper]) !== void 0 && typeof config.auth.apiKeyHelper !== "string") {
+    throw new Error(`auth.apiKeyHelper must be a string in ${configPath}`);
+  }
   if (config.agent) {
     if (config.agent.toolSelectionCache !== void 0 && typeof config.agent.toolSelectionCache !== "boolean") {
       throw new Error(`agent.toolSelectionCache must be boolean in ${configPath}`);
@@ -575,16 +598,68 @@ function validateConfig(config, configPath) {
       }
     }
   }
+  if (config.customProviders !== void 0) {
+    if (!isPlainObject(config.customProviders)) {
+      throw new Error(`customProviders must be an object in ${configPath}`);
+    }
+    for (const [key, provider] of Object.entries(config.customProviders)) {
+      if (!isPlainObject(provider)) {
+        throw new Error(`customProviders.${key} must be an object in ${configPath}`);
+      }
+      if (provider.id !== key) {
+        throw new Error(`customProviders.${key}.id must match its config key in ${configPath}`);
+      }
+      if (typeof provider.displayName !== "string" || provider.displayName.trim() === "") {
+        throw new Error(`customProviders.${key}.displayName must be a non-empty string in ${configPath}`);
+      }
+      if (provider.apiFormat !== "openai-compatible") {
+        throw new Error(`customProviders.${key}.apiFormat must be "openai-compatible" in ${configPath}`);
+      }
+      if (typeof provider.baseUrl !== "string" || provider.baseUrl.trim() === "") {
+        throw new Error(`customProviders.${key}.baseUrl must be a non-empty string in ${configPath}`);
+      }
+      if (typeof provider.model !== "string" || provider.model.trim() === "") {
+        throw new Error(`customProviders.${key}.model must be a non-empty string in ${configPath}`);
+      }
+      if (provider.apiKeyRequired !== void 0 && typeof provider.apiKeyRequired !== "boolean") {
+        throw new Error(`customProviders.${key}.apiKeyRequired must be boolean in ${configPath}`);
+      }
+      if (provider.contextWindow !== void 0 && (typeof provider.contextWindow !== "number" || provider.contextWindow <= 0)) {
+        throw new Error(`customProviders.${key}.contextWindow must be a positive number in ${configPath}`);
+      }
+    }
+  }
 }
 function resolveWorkspaceRoot(config, requestedPath) {
-  const candidate = _nullishCoalesce(_nullishCoalesce(requestedPath, () => ( process.cwd())), () => ( _optionalChain([config, 'access', _9 => _9.workspace, 'optionalAccess', _10 => _10.defaultRoot])));
+  const candidate = _nullishCoalesce(_nullishCoalesce(requestedPath, () => ( process.cwd())), () => ( _optionalChain([config, 'access', _11 => _11.workspace, 'optionalAccess', _12 => _12.defaultRoot])));
   return _path2.default.resolve(candidate);
 }
 function getProviderConfig(config, provider) {
   const chosen = _nullishCoalesce(_nullishCoalesce(provider, () => ( config.provider)), () => ( "openrouter"));
-  if (chosen === "bedrock" && !_chunkHK5A54AVcjs.isAwsBedrockProviderEnabled.call(void 0, config)) {
+  if (_chunkEK34UZPBcjs.isCustomProviderName.call(void 0, chosen)) {
+    const entry2 = _chunkEK34UZPBcjs.getCustomProviderConfig.call(void 0, config, chosen);
+    if (!entry2 || entry2.apiFormat !== "openai-compatible") {
+      return null;
+    }
+    const model = _optionalChain([entry2, 'access', _13 => _13.model, 'optionalAccess', _14 => _14.trim, 'call', _15 => _15()]);
+    const baseUrl = _optionalChain([entry2, 'access', _16 => _16.baseUrl, 'optionalAccess', _17 => _17.trim, 'call', _18 => _18()]);
+    const requiresApiKey = entry2.apiKeyRequired !== false;
+    if (!model || !baseUrl) {
+      return null;
+    }
+    if (requiresApiKey && (!entry2.apiKey || entry2.apiKey === "replace-me")) {
+      return null;
+    }
+    return {
+      ...entry2,
+      model,
+      baseUrl
+    };
+  }
+  if (chosen === "bedrock" && !_chunk7TO3PDMVcjs.isAwsBedrockProviderEnabled.call(void 0, config)) {
     return null;
   }
+  const builtInProvider = chosen;
   const configByProvider = {
     openrouter: config.openrouter,
     ollama: config.ollama,
@@ -594,6 +669,7 @@ function getProviderConfig(config, provider) {
     llmgateway: config.llmgateway,
     azure: config.azure,
     zai: config.zai,
+    sakana: config.sakana,
     vertexai: config.vertexai,
     xai: config.xai,
     cerebras: config.cerebras,
@@ -601,7 +677,7 @@ function getProviderConfig(config, provider) {
     deepseek: config.deepseek,
     bedrock: config.bedrock
   };
-  const entry = configByProvider[chosen];
+  const entry = configByProvider[builtInProvider];
   if (!entry) {
     return null;
   }
@@ -611,7 +687,7 @@ function getProviderConfig(config, provider) {
       return null;
     }
     if (openAIEntry.authMode === "chatgpt") {
-      if (!_optionalChain([openAIEntry, 'access', _11 => _11.chatgptAuth, 'optionalAccess', _12 => _12.accessToken]) || !_optionalChain([openAIEntry, 'access', _13 => _13.chatgptAuth, 'optionalAccess', _14 => _14.accountId])) {
+      if (!_optionalChain([openAIEntry, 'access', _19 => _19.chatgptAuth, 'optionalAccess', _20 => _20.accessToken]) || !_optionalChain([openAIEntry, 'access', _21 => _21.chatgptAuth, 'optionalAccess', _22 => _22.accountId])) {
         return null;
       }
     } else {
@@ -619,24 +695,24 @@ function getProviderConfig(config, provider) {
         return null;
       }
     }
-  } else if (chosen === "openrouter" || chosen === "llmgateway" || chosen === "zai" || chosen === "nvidia" || chosen === "deepseek") {
+  } else if (builtInProvider === "openrouter" || builtInProvider === "llmgateway" || builtInProvider === "zai" || builtInProvider === "sakana" || builtInProvider === "nvidia" || builtInProvider === "deepseek") {
     const { apiKey, model } = entry;
     if (!apiKey || apiKey === "replace-me" || !model) {
       return null;
     }
-  } else if (chosen === "vertexai") {
+  } else if (builtInProvider === "vertexai") {
     const { authToken, projectId, model } = entry;
     if (!authToken || !projectId || !model) {
       return null;
     }
-  } else if (chosen === "bedrock") {
+  } else if (builtInProvider === "bedrock") {
     return normalizeBedrockProviderConfig(entry);
   } else {
-    if (chosen === "llamacpp") {
+    if (builtInProvider === "llamacpp") {
       return {
         ...entry,
         model: _nullishCoalesce(entry.model, () => ( "local")),
-        baseUrl: _nullishCoalesce(entry.baseUrl, () => ( defaultBaseUrlFor(chosen, entry.port)))
+        baseUrl: _nullishCoalesce(entry.baseUrl, () => ( defaultBaseUrlFor(builtInProvider, entry.port)))
       };
     }
     if (!entry.model) {
@@ -645,13 +721,14 @@ function getProviderConfig(config, provider) {
   }
   return {
     ...entry,
-    baseUrl: _nullishCoalesce(entry.baseUrl, () => ( defaultBaseUrlFor(chosen, entry.port)))
+    baseUrl: _nullishCoalesce(entry.baseUrl, () => ( defaultBaseUrlFor(builtInProvider, entry.port)))
   };
 }
 function defaultBaseUrlFor(provider, port) {
   if (provider === "openrouter") return DEFAULT_BASE_URL;
   if (provider === "llmgateway") return DEFAULT_LLMGATEWAY_URL;
   if (provider === "zai") return DEFAULT_ZAI_URL;
+  if (provider === "sakana") return DEFAULT_SAKANA_URL;
   if (provider === "deepseek") return DEFAULT_DEEPSEEK_URL;
   const p = port ? port.toString() : void 0;
   switch (provider) {
@@ -672,11 +749,11 @@ function defaultBaseUrlFor(provider, port) {
   }
 }
 function normalizeBedrockProviderConfig(entry) {
-  const model = _optionalChain([entry, 'access', _15 => _15.model, 'optionalAccess', _16 => _16.trim, 'call', _17 => _17()]);
-  const region = _optionalChain([entry, 'access', _18 => _18.region, 'optionalAccess', _19 => _19.trim, 'call', _20 => _20()]) || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || DEFAULT_BEDROCK_REGION;
+  const model = _optionalChain([entry, 'access', _23 => _23.model, 'optionalAccess', _24 => _24.trim, 'call', _25 => _25()]);
+  const region = _optionalChain([entry, 'access', _26 => _26.region, 'optionalAccess', _27 => _27.trim, 'call', _28 => _28()]) || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || DEFAULT_BEDROCK_REGION;
   const apiMode = _nullishCoalesce(entry.apiMode, () => ( "converse"));
   const authMode = _nullishCoalesce(entry.authMode, () => ( (apiMode === "converse" ? "aws-credentials" : "bedrock-api-key")));
-  const endpoint = _nullishCoalesce(_optionalChain([entry, 'access', _21 => _21.endpoint, 'optionalAccess', _22 => _22.replace, 'call', _23 => _23(/\/+$/, "")]), () => ( (apiMode === "converse" ? `https://bedrock-runtime.${region}.amazonaws.com` : `https://bedrock-runtime.${region}.amazonaws.com/openai/v1`)));
+  const endpoint = _nullishCoalesce(_optionalChain([entry, 'access', _29 => _29.endpoint, 'optionalAccess', _30 => _30.replace, 'call', _31 => _31(/\/+$/, "")]), () => ( (apiMode === "converse" ? `https://bedrock-runtime.${region}.amazonaws.com` : `https://bedrock-runtime.${region}.amazonaws.com/openai/v1`)));
   if (!model || !region) {
     return null;
   }

package/dist/{chunk-AQ5PVHOC.cjs → chunk-CSUGNNJY.cjs}

@@ -1,7 +1,7 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});// package.json
 var package_default = {
   name: "autohand-cli",
-  version: "0.9.1",
+  version: "0.9.2",
   license: "Apache-2.0",
   description: "Autohand Code CLI is a fast, terminal-native AI coding agent for planning, editing, testing, and automating software work.",
   repository: {
@@ -64,7 +64,7 @@ var package_default = {
     dotenv: "^17.4.2",
     "fs-extra": "^11.3.4",
     ignore: "^7.0.5",
-    ink: "^7.0.1",
+    ink: "^7.0.5",
     "ink-spinner": "^5.0.0",
     minimatch: "^10.2.5",
     "node-notifier": "^10.0.1",
@@ -104,7 +104,8 @@ var package_default = {
     vitest: "^4.1.5"
   },
   overrides: {
-    "ansi-styles": "^6.2.3"
+    "ansi-styles": "^6.2.3",
+    uuid: "^11.1.0"
   }
 };
 

package/dist/{chunk-QRQF3556.js → chunk-D6HB3H3L.js}

@@ -1,22 +1,23 @@
 import {
   DEFAULT_SYNC_CONFIG,
-  createSyncService
-} from "./chunk-V5ELP2XE.js";
+  createSyncService,
+  isMemorySyncPath
+} from "./chunk-H65446XW.js";
 import {
   safePrompt
-} from "./chunk-MMKZSJUN.js";
+} from "./chunk-NKW6CHXQ.js";
 import {
   getAuthClient
-} from "./chunk-6AYJCDTA.js";
+} from "./chunk-MA3AVDCC.js";
 import {
   saveConfig
-} from "./chunk-IEPLQ47J.js";
+} from "./chunk-CM24K6ZT.js";
 import {
   AUTH_CONFIG
-} from "./chunk-SHRLFX6F.js";
+} from "./chunk-PG2JIU5M.js";
 import {
   t
-} from "./chunk-LEZEWKPA.js";
+} from "./chunk-SJQU2ZFR.js";
 
 // src/commands/login.ts
 import chalk from "chalk";
@@ -167,11 +168,19 @@ async function checkAndRestoreSyncData(token, userId, config) {
     if (!remoteManifest || remoteManifest.files.length === 0) {
       return;
     }
-    const fileCount = remoteManifest.files.length;
-    const totalSize = remoteManifest.files.reduce((sum, f) => sum + f.size, 0);
+    const memoryFiles = remoteManifest.files.filter((file) => isMemorySyncPath(file.path));
+    if (memoryFiles.length > 0) {
+      await restoreMemorySyncData(syncService, memoryFiles);
+    }
+    const consentRequiredFiles = remoteManifest.files.filter((file) => !isMemorySyncPath(file.path));
+    if (consentRequiredFiles.length === 0) {
+      return;
+    }
+    const fileCount = consentRequiredFiles.length;
+    const totalSize = consentRequiredFiles.reduce((sum, f) => sum + f.size, 0);
     const sizeStr = formatSize(totalSize);
     console.log(chalk.cyan(`Found cloud sync data (${fileCount} files, ${sizeStr})`));
-    console.log(chalk.gray("This includes your settings, agents, skills, and memory."));
+    console.log(chalk.gray("This includes your settings, agents, skills, sessions, and hooks."));
     console.log();
     const result = await safePrompt({
       type: "confirm",
@@ -201,6 +210,12 @@ async function checkAndRestoreSyncData(token, userId, config) {
     console.log(chalk.gray("Could not check cloud sync data."));
   }
 }
+async function restoreMemorySyncData(syncService, memoryFiles) {
+  try {
+    await syncService.forceDownloadPaths(memoryFiles.map((file) => file.path));
+  } catch {
+  }
+}
 async function cancellableOperation(fn) {
   const stdin = process.stdin;
   const wasRaw = stdin.isRaw;