claude-think 0.5.2 → 0.5.3

package/CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.3] - 2026-02-09
+
+### Added
+- **Inline profile creation in TUI** — create new profiles with role-based defaults without leaving the TUI
+  - Select a role (Senior Dev, Mid-level, Junior, Founder, Student, Hobbyist) and profile files are auto-generated
+  - No longer exits to `think setup` CLI wizard when creating empty profiles
+- **`P profiles` visible in status bar** — profile switching shortcut is now discoverable
+
+### Changed
+- Extracted profile generation logic into shared `profile-generator.ts` module (used by both CLI setup and TUI)
+
 ## [0.5.2] - 2026-02-08
 
 ### Fixed

package/README.md

@@ -79,7 +79,7 @@ Switch between different configurations for work, personal projects, or clients:
 think switch work     # Switch profile (auto-syncs)
 ```
 
-Press `P` in the TUI to manage profiles interactively (create, delete, switch).
+Press `P` in the TUI to manage profiles interactively (create, delete, switch). New profiles can be created with role-based defaults without leaving the TUI.
 
 ## TUI
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-think",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "Personal context manager for Claude - manage your preferences, patterns, and memory",
   "author": "Amit Feldman",
   "license": "MIT",

package/src/cli/commands/setup.ts

@@ -7,179 +7,19 @@ import { ensureProfilesStructure } from "../../core/profiles.ts";
 import { generatePlugin } from "../../core/generator.ts";
 import { detectProject } from "../../core/project-detect.ts";
 import type { ProjectInfo } from "../../core/project-detect.ts";
-
-// ── Description maps ──────────────────────────────────────────────
-
-const styleDescriptions: Record<string, string[]> = {
-  direct: [
-    "Be direct and minimal - no fluff, just answers and code",
-    "Skip lengthy reasoning unless asked",
-    "Don't explain obvious things",
-  ],
-  conversational: [
-    "Be friendly but efficient",
-    "Brief explanations when helpful",
-    "Keep a conversational tone",
-  ],
-  detailed: [
-    "Provide thorough explanations",
-    "Include context and reasoning",
-    "Explain trade-offs and alternatives",
-  ],
-};
-
-const roleDescriptions: Record<string, string> = {
-  "senior-dev": "Senior developer - experienced and autonomous, prefers concise guidance",
-  "mid-dev": "Mid-level developer - competent but appreciates context on complex topics",
-  "junior-dev": "Junior developer - learning, benefits from more explanation and examples",
-  founder: "Founder/Tech Lead - focused on shipping, pragmatic decisions over perfect code",
-  student: "Student - learning fundamentals, explain concepts when relevant",
-  hobbyist: "Hobbyist - exploring for fun, balance learning with getting things done",
-};
-
-const personalityDescriptions: Record<string, string[]> = {
-  "pair-programmer": [
-    "Act as a pair programmer - think out loud, collaborate on solutions",
-    "Discuss trade-offs and alternatives when relevant",
-    "Catch potential issues early, suggest improvements as we go",
-  ],
-  "senior-dev": [
-    "Act as a senior developer - give direction, review approaches",
-    "Point out potential issues and better patterns",
-    "Be opinionated when it matters, flexible when it doesn't",
-  ],
-  assistant: [
-    "Act as an efficient assistant - execute tasks with minimal chatter",
-    "Ask clarifying questions only when truly needed",
-    "Focus on delivering what was asked",
-  ],
-  mentor: [
-    "Act as a mentor - teach concepts, explain the 'why'",
-    "Use opportunities to share knowledge",
-    "Suggest learning resources when helpful",
-  ],
-  "rubber-duck": [
-    "Act as a rubber duck - help me think through problems",
-    "Ask probing questions rather than giving immediate answers",
-    "Help me discover solutions myself",
-  ],
-};
-
-const planningDescriptions: Record<string, string> = {
-  "plan-first": "Discuss architecture and approach before writing code",
-  iterate: "Start with a rough plan, refine as we go",
-  "dive-in": "Start coding quickly, figure out structure as needed",
-};
-
-const testingDescriptions: Record<string, string> = {
-  tdd: "Write tests first (TDD), then implement",
-  "test-after": "Write tests after implementation",
-  "critical-paths": "Test critical paths and edge cases",
-  minimal: "Minimal testing - add tests when necessary",
-};
-
-const reviewDescriptions: Record<string, string> = {
-  "review-before-commit": "Review changes before committing - catch issues early",
-  "review-on-request": "Review code when explicitly asked",
-  "self-review": "I review my own code, no automatic reviews needed",
-};
-
-const gitDescriptions: Record<string, string> = {
-  "small-commits": "Small, atomic commits - easy to review and revert",
-  "feature-branches": "Feature branches with squash merges",
-  "trunk-based": "Trunk-based development with feature flags",
-  flexible: "Flexible git workflow based on project needs",
-};
-
-const docDescriptions: Record<string, string> = {
-  inline: "Document with inline comments as code is written",
-  "readme-driven": "README-driven development - docs first",
-  minimal: "Minimal documentation - code should be self-documenting",
-  "on-request": "Add documentation when requested",
-};
-
-const debugDescriptions: Record<string, string> = {
-  systematic: "Debug systematically - isolate, reproduce, trace",
-  hypothesis: "Hypothesis-driven debugging - test likely causes first",
-  printf: "Printf debugging - add logs and observe",
-  "whatever-works": "Whatever works to fix the issue quickly",
-};
-
-const refactorDescriptions: Record<string, string> = {
-  proactive: "Proactively suggest refactoring opportunities",
-  "on-request": "Refactor only when asked",
-  "boy-scout": "Boy scout rule - leave code better than you found it",
-  "if-broken": "Don't refactor working code unless necessary",
-};
-
-// ── Role-based workflow defaults ──────────────────────────────────
-
-interface WorkflowDefaults {
-  planning: string;
-  testing: string;
-  review: string;
-  git: string;
-  docs: string;
-  debug: string;
-  refactor: string;
-}
-
-const roleWorkflowDefaults: Record<string, WorkflowDefaults> = {
-  "senior-dev": {
-    planning: "plan-first",
-    testing: "tdd",
-    review: "review-before-commit",
-    git: "small-commits",
-    docs: "minimal",
-    debug: "systematic",
-    refactor: "boy-scout",
-  },
-  "mid-dev": {
-    planning: "iterate",
-    testing: "test-after",
-    review: "review-before-commit",
-    git: "feature-branches",
-    docs: "inline",
-    debug: "hypothesis",
-    refactor: "on-request",
-  },
-  "junior-dev": {
-    planning: "plan-first",
-    testing: "test-after",
-    review: "review-before-commit",
-    git: "feature-branches",
-    docs: "inline",
-    debug: "systematic",
-    refactor: "proactive",
-  },
-  founder: {
-    planning: "dive-in",
-    testing: "critical-paths",
-    review: "self-review",
-    git: "trunk-based",
-    docs: "minimal",
-    debug: "whatever-works",
-    refactor: "if-broken",
-  },
-  student: {
-    planning: "plan-first",
-    testing: "test-after",
-    review: "review-on-request",
-    git: "feature-branches",
-    docs: "inline",
-    debug: "systematic",
-    refactor: "proactive",
-  },
-  hobbyist: {
-    planning: "iterate",
-    testing: "minimal",
-    review: "self-review",
-    git: "flexible",
-    docs: "on-request",
-    debug: "printf",
-    refactor: "if-broken",
-  },
-};
+import {
+  styleDescriptions,
+  roleDescriptions,
+  personalityDescriptions,
+  planningDescriptions,
+  testingDescriptions,
+  reviewDescriptions,
+  gitDescriptions,
+  docDescriptions,
+  debugDescriptions,
+  refactorDescriptions,
+  roleWorkflowDefaults,
+} from "../../core/profile-generator.ts";
 
 // ── Helpers ───────────────────────────────────────────────────────
 

package/src/core/profile-generator.ts

@@ -0,0 +1,290 @@
+import { writeFile } from "fs/promises";
+import { join } from "path";
+import { CONFIG } from "./config.ts";
+
+// ── Description maps ──────────────────────────────────────────────
+
+export const styleDescriptions: Record<string, string[]> = {
+  direct: [
+    "Be direct and minimal - no fluff, just answers and code",
+    "Skip lengthy reasoning unless asked",
+    "Don't explain obvious things",
+  ],
+  conversational: [
+    "Be friendly but efficient",
+    "Brief explanations when helpful",
+    "Keep a conversational tone",
+  ],
+  detailed: [
+    "Provide thorough explanations",
+    "Include context and reasoning",
+    "Explain trade-offs and alternatives",
+  ],
+};
+
+export const roleDescriptions: Record<string, string> = {
+  "senior-dev": "Senior developer - experienced and autonomous, prefers concise guidance",
+  "mid-dev": "Mid-level developer - competent but appreciates context on complex topics",
+  "junior-dev": "Junior developer - learning, benefits from more explanation and examples",
+  founder: "Founder/Tech Lead - focused on shipping, pragmatic decisions over perfect code",
+  student: "Student - learning fundamentals, explain concepts when relevant",
+  hobbyist: "Hobbyist - exploring for fun, balance learning with getting things done",
+};
+
+export const personalityDescriptions: Record<string, string[]> = {
+  "pair-programmer": [
+    "Act as a pair programmer - think out loud, collaborate on solutions",
+    "Discuss trade-offs and alternatives when relevant",
+    "Catch potential issues early, suggest improvements as we go",
+  ],
+  "senior-dev": [
+    "Act as a senior developer - give direction, review approaches",
+    "Point out potential issues and better patterns",
+    "Be opinionated when it matters, flexible when it doesn't",
+  ],
+  assistant: [
+    "Act as an efficient assistant - execute tasks with minimal chatter",
+    "Ask clarifying questions only when truly needed",
+    "Focus on delivering what was asked",
+  ],
+  mentor: [
+    "Act as a mentor - teach concepts, explain the 'why'",
+    "Use opportunities to share knowledge",
+    "Suggest learning resources when helpful",
+  ],
+  "rubber-duck": [
+    "Act as a rubber duck - help me think through problems",
+    "Ask probing questions rather than giving immediate answers",
+    "Help me discover solutions myself",
+  ],
+};
+
+export const planningDescriptions: Record<string, string> = {
+  "plan-first": "Discuss architecture and approach before writing code",
+  iterate: "Start with a rough plan, refine as we go",
+  "dive-in": "Start coding quickly, figure out structure as needed",
+};
+
+export const testingDescriptions: Record<string, string> = {
+  tdd: "Write tests first (TDD), then implement",
+  "test-after": "Write tests after implementation",
+  "critical-paths": "Test critical paths and edge cases",
+  minimal: "Minimal testing - add tests when necessary",
+};
+
+export const reviewDescriptions: Record<string, string> = {
+  "review-before-commit": "Review changes before committing - catch issues early",
+  "review-on-request": "Review code when explicitly asked",
+  "self-review": "I review my own code, no automatic reviews needed",
+};
+
+export const gitDescriptions: Record<string, string> = {
+  "small-commits": "Small, atomic commits - easy to review and revert",
+  "feature-branches": "Feature branches with squash merges",
+  "trunk-based": "Trunk-based development with feature flags",
+  flexible: "Flexible git workflow based on project needs",
+};
+
+export const docDescriptions: Record<string, string> = {
+  inline: "Document with inline comments as code is written",
+  "readme-driven": "README-driven development - docs first",
+  minimal: "Minimal documentation - code should be self-documenting",
+  "on-request": "Add documentation when requested",
+};
+
+export const debugDescriptions: Record<string, string> = {
+  systematic: "Debug systematically - isolate, reproduce, trace",
+  hypothesis: "Hypothesis-driven debugging - test likely causes first",
+  printf: "Printf debugging - add logs and observe",
+  "whatever-works": "Whatever works to fix the issue quickly",
+};
+
+export const refactorDescriptions: Record<string, string> = {
+  proactive: "Proactively suggest refactoring opportunities",
+  "on-request": "Refactor only when asked",
+  "boy-scout": "Boy scout rule - leave code better than you found it",
+  "if-broken": "Don't refactor working code unless necessary",
+};
+
+// ── Role-based workflow defaults ──────────────────────────────────
+
+export interface WorkflowDefaults {
+  planning: string;
+  testing: string;
+  review: string;
+  git: string;
+  docs: string;
+  debug: string;
+  refactor: string;
+}
+
+export const roleWorkflowDefaults: Record<string, WorkflowDefaults> = {
+  "senior-dev": {
+    planning: "plan-first",
+    testing: "tdd",
+    review: "review-before-commit",
+    git: "small-commits",
+    docs: "minimal",
+    debug: "systematic",
+    refactor: "boy-scout",
+  },
+  "mid-dev": {
+    planning: "iterate",
+    testing: "test-after",
+    review: "review-before-commit",
+    git: "feature-branches",
+    docs: "inline",
+    debug: "hypothesis",
+    refactor: "on-request",
+  },
+  "junior-dev": {
+    planning: "plan-first",
+    testing: "test-after",
+    review: "review-before-commit",
+    git: "feature-branches",
+    docs: "inline",
+    debug: "systematic",
+    refactor: "proactive",
+  },
+  founder: {
+    planning: "dive-in",
+    testing: "critical-paths",
+    review: "self-review",
+    git: "trunk-based",
+    docs: "minimal",
+    debug: "whatever-works",
+    refactor: "if-broken",
+  },
+  student: {
+    planning: "plan-first",
+    testing: "test-after",
+    review: "review-on-request",
+    git: "feature-branches",
+    docs: "inline",
+    debug: "systematic",
+    refactor: "proactive",
+  },
+  hobbyist: {
+    planning: "iterate",
+    testing: "minimal",
+    review: "self-review",
+    git: "flexible",
+    docs: "on-request",
+    debug: "printf",
+    refactor: "if-broken",
+  },
+};
+
+// ── Role-based personality/style defaults ─────────────────────────
+
+const rolePersonalityDefaults: Record<string, string> = {
+  "senior-dev": "assistant",
+  "mid-dev": "pair-programmer",
+  "junior-dev": "mentor",
+  founder: "assistant",
+  student: "mentor",
+  hobbyist: "pair-programmer",
+};
+
+const roleStyleDefaults: Record<string, string> = {
+  "senior-dev": "direct",
+  "mid-dev": "conversational",
+  "junior-dev": "detailed",
+  founder: "direct",
+  student: "detailed",
+  hobbyist: "conversational",
+};
+
+// ── Profile generation ────────────────────────────────────────────
+
+export interface ProfileGenerationOptions {
+  name?: string;
+  role: string;
+  style?: string;
+  personality?: string;
+}
+
+/**
+ * Generate profile files with role-based defaults.
+ * Creates profile.md and preferences/anti-patterns.md in the given profile directory.
+ */
+export async function generateProfileFiles(
+  profileDir: string,
+  options: ProfileGenerationOptions,
+): Promise<void> {
+  const { role } = options;
+  const name = options.name ?? "";
+  const style = options.style ?? roleStyleDefaults[role] ?? "direct";
+  const personality = options.personality ?? rolePersonalityDefaults[role] ?? "assistant";
+  const defaults = roleWorkflowDefaults[role] ?? roleWorkflowDefaults["senior-dev"]!;
+
+  // ── Write profile.md ────────────────────────────────────────────
+  const profileContent = `---
+name: ${name}
+role: ${role}
+style: ${style}
+personality: ${personality}
+---
+
+# Who I Am
+
+${roleDescriptions[role] ?? role}
+
+# How Claude Should Behave
+
+${(personalityDescriptions[personality] ?? []).map((line) => `- ${line}`).join("\n")}
+
+# Communication Style
+
+${(styleDescriptions[style] ?? []).map((line) => `- ${line}`).join("\n")}
+- No emojis unless explicitly requested
+- Show code when it's clearer than explanation
+
+# Development Workflow
+
+## Planning
+- ${planningDescriptions[defaults.planning] ?? defaults.planning}
+
+## Testing
+- ${testingDescriptions[defaults.testing] ?? defaults.testing}
+
+## Code Review
+- ${reviewDescriptions[defaults.review] ?? defaults.review}
+
+## Git Workflow
+- ${gitDescriptions[defaults.git] ?? defaults.git}
+
+## Documentation
+- ${docDescriptions[defaults.docs] ?? defaults.docs}
+
+## Debugging
+- ${debugDescriptions[defaults.debug] ?? defaults.debug}
+
+## Refactoring
+- ${refactorDescriptions[defaults.refactor] ?? defaults.refactor}
+`;
+
+  await writeFile(join(profileDir, CONFIG.files.profile), profileContent);
+
+  // ── Write anti-patterns.md (moderate defaults) ──────────────────
+  const antiContent = `# Anti-Patterns to Avoid
+
+## Code Style
+- Don't add comments for obvious code
+- Don't add type annotations that can be inferred
+- Don't create abstractions for one-time use
+
+## Architecture
+- Don't over-engineer solutions
+- Don't add features that weren't requested
+- Don't create unnecessary indirection
+- Don't add "future-proofing" complexity
+
+## Communication
+- Don't explain obvious things
+- Don't repeat back what was just said
+- Don't pad responses with unnecessary context
+`;
+
+  await writeFile(join(profileDir, CONFIG.files.antiPatterns), antiContent);
+}

package/src/tui/App.tsx

@@ -16,7 +16,6 @@ import { ProfileSwitcher } from "./components/ProfileSwitcher.tsx";
 import { FullScreen, useTerminalSize } from "./components/FullScreen.tsx";
 import { existsSync, readdirSync } from "fs";
 import { readFile } from "fs/promises";
-import { spawn } from "child_process";
 import { CONFIG, getActiveProfile, estimateTokens, formatTokens } from "../core/config.ts";
 import { switchProfile } from "../core/profiles.ts";
 import { generatePlugin } from "../core/generator.ts";
@@ -151,16 +150,6 @@ export function App() {
     setModal("none");
   }
 
-  function handleSetup() {
-    isExitingRef.current = true;
-    exit();
-    setTimeout(() => {
-      spawn("think", ["setup"], {
-        stdio: "inherit",
-      });
-    }, 100);
-  }
-
   // Don't render while exiting
   if (isExitingRef.current) {
     return null;
@@ -224,7 +213,6 @@ export function App() {
           <ProfileSwitcher
             onClose={() => setModal("none")}
             onSwitch={handleProfileSwitch}
-            onSetup={handleSetup}
           />
         </Box>
       </FullScreen>

package/src/tui/components/ProfileSwitcher.tsx

@@ -3,22 +3,34 @@ import { Box, Text, useInput } from "ink";
 import TextInput from "ink-text-input";
 import type { ProfileInfo } from "../../core/profiles.ts";
 import { listProfiles, createProfile, deleteProfile } from "../../core/profiles.ts";
+import { profilePath } from "../../core/config.ts";
+import { roleDescriptions, generateProfileFiles } from "../../core/profile-generator.ts";
 
 interface ProfileSwitcherProps {
   onClose: () => void;
   onSwitch: (name: string) => void;
-  onSetup?: () => void;
 }
 
-type Mode = "list" | "create" | "confirmCopy" | "confirmDelete";
+type Mode = "list" | "create" | "confirmCopy" | "confirmDelete" | "selectRole";
 
-export function ProfileSwitcher({ onClose, onSwitch, onSetup }: ProfileSwitcherProps) {
+const roles = [
+  { value: "senior-dev", label: "Senior Developer", hint: "experienced, autonomous" },
+  { value: "mid-dev", label: "Mid-level Developer", hint: "some guidance helpful" },
+  { value: "junior-dev", label: "Junior Developer", hint: "more explanation needed" },
+  { value: "founder", label: "Founder / Tech Lead", hint: "shipping matters" },
+  { value: "student", label: "Student", hint: "learning fundamentals" },
+  { value: "hobbyist", label: "Hobbyist", hint: "exploring for fun" },
+];
+
+export function ProfileSwitcher({ onClose, onSwitch }: ProfileSwitcherProps) {
   const [profiles, setProfiles] = useState<ProfileInfo[]>([]);
   const [selected, setSelected] = useState(0);
   const [loading, setLoading] = useState(true);
   const [mode, setMode] = useState<Mode>("list");
   const [newName, setNewName] = useState("");
   const [error, setError] = useState<string | null>(null);
+  const [roleIndex, setRoleIndex] = useState(0);
+  const [generating, setGenerating] = useState(false);
 
   function loadProfiles() {
     const loaded = listProfiles();
@@ -47,8 +59,11 @@ export function ProfileSwitcher({ onClose, onSwitch, onSetup }: ProfileSwitcherP
     try {
       createProfile(name, copyFrom);
 
-      if (!copyFrom && onSetup) {
-        onSetup();
+      if (!copyFrom) {
+        // No source to copy from — go to role selection
+        setMode("selectRole");
+        setRoleIndex(0);
+        setError(null);
         return;
       }
 
@@ -62,6 +77,25 @@ export function ProfileSwitcher({ onClose, onSwitch, onSetup }: ProfileSwitcherP
     }
   }
 
+  async function handleRoleSelect() {
+    const name = newName.trim();
+    const role = roles[roleIndex]!;
+    setGenerating(true);
+    try {
+      const dir = profilePath(name);
+      await generateProfileFiles(dir, { role: role.value });
+      setNewName("");
+      setMode("list");
+      setError(null);
+      setGenerating(false);
+      loadProfiles();
+      onSwitch(name);
+    } catch {
+      setError("Failed to generate profile");
+      setGenerating(false);
+    }
+  }
+
   function handleDelete() {
     const profile = profiles[selected];
     if (!profile) return;
@@ -111,6 +145,26 @@ export function ProfileSwitcher({ onClose, onSwitch, onSetup }: ProfileSwitcherP
       return;
     }
 
+    // Select role mode
+    if (mode === "selectRole") {
+      if (generating) return;
+      if (key.escape) {
+        setMode("list");
+        setNewName("");
+        setError(null);
+      }
+      if (key.upArrow || input === "k") {
+        setRoleIndex((i) => (i - 1 + roles.length) % roles.length);
+      }
+      if (key.downArrow || input === "j") {
+        setRoleIndex((i) => (i + 1) % roles.length);
+      }
+      if (key.return) {
+        handleRoleSelect();
+      }
+      return;
+    }
+
     // Confirm delete mode
     if (mode === "confirmDelete") {
       if (input === "y" || input === "Y") {
@@ -217,6 +271,43 @@ export function ProfileSwitcher({ onClose, onSwitch, onSetup }: ProfileSwitcherP
     );
   }
 
+  // Select role mode
+  if (mode === "selectRole") {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <Text bold color="cyan">Select Role for "{newName}"</Text>
+
+        <Box flexDirection="column" marginTop={1}>
+          {roles.map((role, i) => (
+            <Box key={role.value}>
+              <Text color={i === roleIndex ? "cyan" : undefined} dimColor={i !== roleIndex}>
+                {i === roleIndex ? "  \u25b8 " : "    "}
+              </Text>
+              <Text bold={i === roleIndex} color={i === roleIndex ? "white" : undefined} dimColor={i !== roleIndex}>
+                {role.label}
+              </Text>
+              <Text dimColor> {role.hint}</Text>
+            </Box>
+          ))}
+        </Box>
+
+        {generating && (
+          <Box marginTop={1}>
+            <Text color="yellow">  Generating profile...</Text>
+          </Box>
+        )}
+        {error && (
+          <Box marginTop={1}>
+            <Text color="red">  {error}</Text>
+          </Box>
+        )}
+        <Box marginTop={1}>
+          <Text dimColor>  {"\u2191\u2193"}: select | Enter: create | Esc: cancel</Text>
+        </Box>
+      </Box>
+    );
+  }
+
   // Confirm delete mode
   if (mode === "confirmDelete") {
     const profile = profiles[selected];

package/src/tui/components/StatusBar.tsx

@@ -49,7 +49,7 @@ export function StatusBar({ message, section }: StatusBarProps) {
     return (
       <Box>
         <Text dimColor>
-          {"↑↓ nav · "}{sectionHints}{" · / search · ? help · q quit"}
+          {"↑↓ nav · "}{sectionHints}{" · P profiles · / search · ? help · q quit"}
         </Text>
       </Box>
     );
@@ -58,7 +58,7 @@ export function StatusBar({ message, section }: StatusBarProps) {
   return (
     <Box>
       <Text dimColor>
-        {"↑↓ navigate · "}{sectionHints}{" · s sync · p preview · / search · ? help · q quit"}
+        {"↑↓ navigate · "}{sectionHints}{" · s sync · p preview · P profiles · / search · ? help · q quit"}
       </Text>
     </Box>
   );