autohand-cli 0.9.0 → 0.9.2

package/dist/chunk-2WUNHTXL.js

@@ -0,0 +1,303 @@
+// 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 (options?.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");
+  }
+};
+
+export {
+  AgentsGenerator
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-HQWQZML5.cjs → chunk-34B6ZO6W.cjs}

@@ -1,6 +1,6 @@
 "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 _class; var _class2;
 
-var _chunkE26KKI46cjs = require('./chunk-E26KKI46.cjs');
+var _chunk3JURXAL6cjs = require('./chunk-3JURXAL6.cjs');
 
 // src/session/SessionManager.ts
 var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
@@ -11,7 +11,7 @@ var SessionManager = (_class = class {
   __init() {this.currentSession = null}
   __init2() {this.index = null}
   constructor(baseDir) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
-    this.sessionsDir = _nullishCoalesce(baseDir, () => ( _chunkE26KKI46cjs.AUTOHAND_PATHS.sessions));
+    this.sessionsDir = _nullishCoalesce(baseDir, () => ( _chunk3JURXAL6cjs.AUTOHAND_PATHS.sessions));
   }
   async initialize() {
     await _fsextra2.default.ensureDir(this.sessionsDir);
@@ -42,7 +42,8 @@ var SessionManager = (_class = class {
     return session;
   }
   async loadSession(sessionId) {
-    const sessionDir = _path2.default.join(this.sessionsDir, sessionId);
+    const resolvedSessionId = await this.resolveSessionReference(sessionId);
+    const sessionDir = _path2.default.join(this.sessionsDir, resolvedSessionId);
     if (!await _fsextra2.default.pathExists(sessionDir)) {
       throw new Error(`Session not found: ${sessionId}`);
     }
@@ -53,16 +54,82 @@ var SessionManager = (_class = class {
     this.currentSession = session;
     return session;
   }
+  async resolveSessionReference(reference) {
+    const trimmed = reference.trim();
+    if (!trimmed) {
+      throw new Error("Session reference is required");
+    }
+    const asPath = _path2.default.resolve(trimmed);
+    if (await _fsextra2.default.pathExists(asPath)) {
+      const stat = await _fsextra2.default.stat(asPath);
+      const sessionDir = stat.isDirectory() ? asPath : _path2.default.dirname(asPath);
+      const metadataPath = _path2.default.join(sessionDir, "metadata.json");
+      if (await _fsextra2.default.pathExists(metadataPath)) {
+        const metadata = await _fsextra2.default.readJson(metadataPath);
+        return metadata.sessionId;
+      }
+    }
+    const directDir = _path2.default.join(this.sessionsDir, trimmed);
+    if (await _fsextra2.default.pathExists(_path2.default.join(directDir, "metadata.json"))) {
+      return trimmed;
+    }
+    await this.loadIndex();
+    const candidates = _nullishCoalesce(_optionalChain([this, 'access', _ => _.index, 'optionalAccess', _2 => _2.sessions, 'access', _3 => _3.filter, 'call', _4 => _4((session) => session.id.startsWith(trimmed))]), () => ( []));
+    if (candidates.length === 1) {
+      return candidates[0].id;
+    }
+    if (candidates.length > 1) {
+      throw new Error(`Ambiguous session reference: ${reference}`);
+    }
+    throw new Error(`Session not found: ${reference}`);
+  }
+  async branchSession(sourceReference, options) {
+    const sourceSessionId = await this.resolveSessionReference(sourceReference);
+    const sourceSession = await this.loadSession(sourceSessionId);
+    const sourceMessages = sourceSession.getMessages();
+    const copiedMessages = selectBranchMessages(sourceMessages, options);
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    const sessionId = this.generateSessionId();
+    const sessionDir = _path2.default.join(this.sessionsDir, sessionId);
+    await _fsextra2.default.ensureDir(sessionDir);
+    const metadata = {
+      ...sourceSession.metadata,
+      sessionId,
+      createdAt,
+      lastActiveAt: createdAt,
+      closedAt: void 0,
+      messageCount: copiedMessages.length,
+      status: "active",
+      exitCode: void 0,
+      branch: {
+        type: options.type,
+        sourceSessionId,
+        sourceMessageIndex: options.type === "fork" && copiedMessages.length > 0 ? copiedMessages.length - 1 : void 0,
+        sourceUserMessageOrdinal: options.type === "fork" ? options.userMessageOrdinal : void 0,
+        createdAt
+      }
+    };
+    const session = new Session(sessionDir, metadata);
+    await session.replaceMessages(copiedMessages);
+    const sourceState = sourceSession.getState();
+    if (sourceState) {
+      await session.updateState(sourceState);
+    }
+    await session.save();
+    this.currentSession = session;
+    await this.addToIndex(session.metadata);
+    return session;
+  }
   async listSessions(filter) {
     await this.loadIndex();
     if (!this.index) return [];
     let sessions = this.index.sessions;
-    if (_optionalChain([filter, 'optionalAccess', _ => _.project])) {
+    if (_optionalChain([filter, 'optionalAccess', _5 => _5.project])) {
       const projectPath = _path2.default.resolve(filter.project);
       const sessionIds = this.index.byProject[projectPath] || [];
       sessions = sessions.filter((s) => sessionIds.includes(s.id));
     }
-    if (_optionalChain([filter, 'optionalAccess', _2 => _2.since])) {
+    if (_optionalChain([filter, 'optionalAccess', _6 => _6.since])) {
       sessions = sessions.filter((s) => new Date(s.createdAt) >= filter.since);
     }
     const fullMetadata = [];
@@ -105,7 +172,16 @@ var SessionManager = (_class = class {
   async loadIndex() {
     const indexPath = _path2.default.join(this.sessionsDir, "index.json");
     if (await _fsextra2.default.pathExists(indexPath)) {
-      this.index = await _fsextra2.default.readJson(indexPath);
+      try {
+        this.index = await _fsextra2.default.readJson(indexPath);
+      } catch (error) {
+        const backupPath = `${indexPath}.corrupt-${Date.now()}`;
+        await _fsextra2.default.move(indexPath, backupPath, { overwrite: true });
+        const reason = error instanceof Error ? error.message : String(error);
+        console.warn(`Session index was corrupt and has been reset: ${reason}. Backup saved to ${backupPath}`);
+        this.index = { sessions: [], byProject: {} };
+        await this.saveIndex();
+      }
     } else {
       this.index = { sessions: [], byProject: {} };
     }
@@ -121,7 +197,12 @@ var SessionManager = (_class = class {
       id: metadata.sessionId,
       projectPath: metadata.projectPath,
       createdAt: metadata.createdAt,
-      summary: metadata.summary
+      summary: metadata.summary,
+      importedFrom: metadata.importedFrom ? {
+        source: metadata.importedFrom.source,
+        originalId: metadata.importedFrom.originalId
+      } : void 0,
+      branch: metadata.branch
     });
     if (!this.index.byProject[metadata.projectPath]) {
       this.index.byProject[metadata.projectPath] = [];
@@ -134,10 +215,31 @@ var SessionManager = (_class = class {
     const session = this.index.sessions.find((s) => s.id === metadata.sessionId);
     if (session) {
       session.summary = metadata.summary;
+      session.branch = metadata.branch;
     }
     await this.saveIndex();
   }
 }, _class);
+function selectBranchMessages(messages, options) {
+  if (options.type === "clone" || options.userMessageOrdinal === void 0) {
+    return [...messages];
+  }
+  if (!Number.isInteger(options.userMessageOrdinal) || options.userMessageOrdinal < 1) {
+    throw new Error("Fork message must be a positive user-message number");
+  }
+  let seenUserMessages = 0;
+  const selected = [];
+  for (const message of messages) {
+    selected.push(message);
+    if (message.role === "user") {
+      seenUserMessages += 1;
+      if (seenUserMessages === options.userMessageOrdinal) {
+        return selected;
+      }
+    }
+  }
+  throw new Error(`User message ${options.userMessageOrdinal} not found`);
+}
 var Session = (_class2 = class {
   
   
@@ -147,24 +249,39 @@ var Session = (_class2 = class {
     this.sessionDir = sessionDir;
     this.metadata = metadata;
   }
+  async ensureSessionDir() {
+    await _fsextra2.default.ensureDir(this.sessionDir);
+  }
   async append(message) {
     this.messages.push(message);
     this.metadata.messageCount = this.messages.length;
     this.metadata.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.ensureSessionDir();
     const conversationPath = _path2.default.join(this.sessionDir, "conversation.jsonl");
     await _fsextra2.default.appendFile(conversationPath, JSON.stringify(message) + "\n");
     await this.save();
   }
   async appendTransient(message) {
+    await this.ensureSessionDir();
     const conversationPath = _path2.default.join(this.sessionDir, "conversation.jsonl");
     await _fsextra2.default.appendFile(conversationPath, JSON.stringify(message) + "\n");
   }
+  async replaceMessages(messages) {
+    this.messages = [...messages];
+    this.metadata.messageCount = this.messages.length;
+    const conversationPath = _path2.default.join(this.sessionDir, "conversation.jsonl");
+    const content = this.messages.map((message) => JSON.stringify(message)).join("\n");
+    await _fsextra2.default.writeFile(conversationPath, content ? `${content}
+` : "");
+  }
   async updateState(state) {
     this.state = state;
+    await this.ensureSessionDir();
     const statePath = _path2.default.join(this.sessionDir, "state.json");
     await _fsextra2.default.writeJson(statePath, state, { spaces: 2 });
   }
   async save() {
+    await this.ensureSessionDir();
     const metadataPath = _path2.default.join(this.sessionDir, "metadata.json");
     await _fsextra2.default.writeJson(metadataPath, this.metadata, { spaces: 2 });
   }

package/dist/{chunk-5JTTM5SC.js → chunk-3BJN7GAH.js}

@@ -4,7 +4,7 @@ import path from "path";
 import fse from "fs-extra";
 var metadata = {
   command: "/review",
-  description: "staff-level code review with 10 actionable findings",
+  description: "review your current changes and find issues",
   implemented: true
 };
 async function review(ctx, args = []) {

package/dist/{chunk-4256YRCO.cjs → chunk-3CAXECWJ.cjs}

@@ -1,15 +1,19 @@
 "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 _chunkNVATU4V6cjs = require('./chunk-NVATU4V6.cjs');
+
+
 var _chunkLJD7KR3Lcjs = require('./chunk-LJD7KR3L.cjs');
 
 
-var _chunkIKUMVBCWcjs = require('./chunk-IKUMVBCW.cjs');
 
+var _chunkSD3NTC7Dcjs = require('./chunk-SD3NTC7D.cjs');
 
-var _chunkREMGR23Vcjs = require('./chunk-REMGR23V.cjs');
 
+var _chunkCSUGNNJYcjs = require('./chunk-CSUGNNJY.cjs');
 
-var _chunkCHI52KFRcjs = require('./chunk-CHI52KFR.cjs');
+
+var _chunkRJCZLFHEcjs = require('./chunk-RJCZLFHE.cjs');
 
 // src/commands/about.ts
 var _child_process = require('child_process');
@@ -20,9 +24,9 @@ function getCommitFromAlphaVersion(version) {
 }
 function getGitCommit() {
   if (true) {
-    return "8cc71ec";
+    return "1d7b7b1";
   }
-  const alphaCommit = getCommitFromAlphaVersion(_chunkREMGR23Vcjs.package_default.version);
+  const alphaCommit = getCommitFromAlphaVersion(_chunkCSUGNNJYcjs.package_default.version);
   if (alphaCommit) {
     return alphaCommit;
   }
@@ -34,33 +38,42 @@ function getGitCommit() {
 }
 function getVersionString() {
   const commit = getGitCommit();
-  return commit !== "unknown" ? `${_chunkREMGR23Vcjs.package_default.version} (${commit})` : _chunkREMGR23Vcjs.package_default.version;
+  return commit !== "unknown" ? `${_chunkCSUGNNJYcjs.package_default.version} (${commit})` : _chunkCSUGNNJYcjs.package_default.version;
 }
-async function about() {
+async function about(ctx = {}) {
   const theme = _chunkLJD7KR3Lcjs.createCommandTheme.call(void 0, );
+  const greetingName = _chunkNVATU4V6cjs.getUserGreetingName.call(void 0, ctx.config);
+  const terminalColumns = _nullishCoalesce(ctx.terminalColumns, () => ( _chunkSD3NTC7Dcjs.getTerminalColumns.call(void 0, process.stdout)));
   const lines = [
-    theme.muted(_chunkIKUMVBCWcjs.ASCII_FRIEND),
+    theme.muted(_chunkSD3NTC7Dcjs.renderAutohandLogo.call(void 0, { columns: terminalColumns })),
     "",
-    theme.accent(`${_chunkCHI52KFRcjs.t.call(void 0, "commands.about.title")} v${getVersionString()}`),
-    theme.muted(_chunkCHI52KFRcjs.t.call(void 0, "commands.about.subtitle")),
+    theme.accent(`${_chunkRJCZLFHEcjs.t.call(void 0, "commands.about.title")} v${getVersionString()}`),
+    theme.muted(_chunkRJCZLFHEcjs.t.call(void 0, "commands.about.subtitle")),
     ""
   ];
+  if (greetingName) {
+    lines.push(theme.text(`Hey ${greetingName}, here are a few suggestions for what you could do next:`));
+    lines.push(theme.text(`   \u2022 Review model, context, and account usage: ${theme.accent("/usage")}`));
+    lines.push(theme.text(`   \u2022 Check current session and runtime status: ${theme.accent("/status")}`));
+    lines.push(theme.text(`   \u2022 Discover experiments available to you: ${theme.accent("/experiments")}`));
+    lines.push("");
+  }
   const websiteUrl = "https://autohand.ai";
   const githubUrl = "https://github.com/autohandai/";
   const docsUrl = "https://docs.autohand.ai";
   const websiteLink = _terminallink2.default.call(void 0, theme.link("autohand.ai"), websiteUrl);
   const githubLink = _terminallink2.default.call(void 0, theme.link("github.com/autohandai/"), githubUrl);
   const docsLink = _terminallink2.default.call(void 0, theme.link("docs.autohand.ai"), docsUrl);
-  lines.push(`${theme.text("\u{1F310}")} ${theme.text(_chunkCHI52KFRcjs.t.call(void 0, "commands.about.website") + ":")}    ${websiteLink}`);
-  lines.push(`${theme.text("\u{1F4E6}")} ${theme.text(_chunkCHI52KFRcjs.t.call(void 0, "commands.about.github") + ":")}     ${githubLink}`);
-  lines.push(`${theme.text("\u{1F4DA}")} ${theme.text(_chunkCHI52KFRcjs.t.call(void 0, "commands.about.docs") + ":")}       ${docsLink}`);
+  lines.push(`${theme.text("\u{1F310}")} ${theme.text(_chunkRJCZLFHEcjs.t.call(void 0, "commands.about.website") + ":")}    ${websiteLink}`);
+  lines.push(`${theme.text("\u{1F4E6}")} ${theme.text(_chunkRJCZLFHEcjs.t.call(void 0, "commands.about.github") + ":")}     ${githubLink}`);
+  lines.push(`${theme.text("\u{1F4DA}")} ${theme.text(_chunkRJCZLFHEcjs.t.call(void 0, "commands.about.docs") + ":")}       ${docsLink}`);
   lines.push("");
-  lines.push(theme.text(`\u{1F4A1} ${_chunkCHI52KFRcjs.t.call(void 0, "commands.about.contribute")}`));
-  lines.push(theme.text(`   \u2022 ${_chunkCHI52KFRcjs.t.call(void 0, "commands.about.feedback")}:     ${theme.accent("/feedback")}`));
-  lines.push(theme.text(`   \u2022 ${_chunkCHI52KFRcjs.t.call(void 0, "commands.about.submitPR")}:         ${theme.accent("gh pr create")}`));
+  lines.push(theme.text(`\u{1F4A1} ${_chunkRJCZLFHEcjs.t.call(void 0, "commands.about.contribute")}`));
+  lines.push(theme.text(`   \u2022 ${_chunkRJCZLFHEcjs.t.call(void 0, "commands.about.feedback")}:     ${theme.accent("/feedback")}`));
+  lines.push(theme.text(`   \u2022 ${_chunkRJCZLFHEcjs.t.call(void 0, "commands.about.submitPR")}:         ${theme.accent("gh pr create")}`));
   const issuesUrl = "https://github.com/autohandai/code-cli/issues";
   const issuesLink = _terminallink2.default.call(void 0, theme.link("github.com/autohandai/code-cli/issues"), issuesUrl);
-  lines.push(theme.text(`   \u2022 ${_chunkCHI52KFRcjs.t.call(void 0, "commands.about.reportIssues")}:     ${issuesLink}`));
+  lines.push(theme.text(`   \u2022 ${_chunkRJCZLFHEcjs.t.call(void 0, "commands.about.reportIssues")}:     ${issuesLink}`));
   return lines.join("\n");
 }
 var metadata = {

package/dist/{chunk-KNTUI4TZ.cjs → chunk-3CBYUBZC.cjs}

@@ -2,27 +2,27 @@
 
 
 
-var _chunkCHI52KFRcjs = require('./chunk-CHI52KFR.cjs');
+var _chunkRJCZLFHEcjs = require('./chunk-RJCZLFHE.cjs');
 
 // src/ui/i18n/I18nContext.tsx
 var _react = require('react');
 var _jsxruntime = require('react/jsx-runtime');
 var defaultContextValue = {
-  t: _chunkCHI52KFRcjs.t,
+  t: _chunkRJCZLFHEcjs.t,
   locale: "en"
 };
 var I18nContext = _react.createContext.call(void 0, defaultContextValue);
 var I18nProvider = ({ children }) => {
-  const [locale, setLocale] = _react.useState.call(void 0, _chunkCHI52KFRcjs.getCurrentLocale.call(void 0, ));
+  const [locale, setLocale] = _react.useState.call(void 0, _chunkRJCZLFHEcjs.getCurrentLocale.call(void 0, ));
   _react.useEffect.call(void 0, () => {
-    const unsubscribe = _chunkCHI52KFRcjs.onLanguageChange.call(void 0, (newLocale) => {
+    const unsubscribe = _chunkRJCZLFHEcjs.onLanguageChange.call(void 0, (newLocale) => {
       setLocale(newLocale);
     });
     return unsubscribe;
   }, []);
   const value = _react.useMemo.call(void 0, 
     () => ({
-      t: _chunkCHI52KFRcjs.t,
+      t: _chunkRJCZLFHEcjs.t,
       locale
     }),
     [locale]