@xelauvas/xela-cli 0.1.0

package/src/commands/thinkback/thinkback.tsx

@@ -0,0 +1,554 @@
+import { c as _c } from "react/compiler-runtime";
+import { execa } from 'execa';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+import * as React from 'react';
+import { useCallback, useEffect, useState } from 'react';
+import type { CommandResultDisplay } from '../../commands.js';
+import { Select } from '../../components/CustomSelect/select.js';
+import { Dialog } from '../../components/design-system/Dialog.js';
+import { Spinner } from '../../components/Spinner.js';
+import instances from '../../ink/instances.js';
+import { Box, Text } from '../../ink.js';
+import { enablePluginOp } from '../../services/plugins/pluginOperations.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { isENOENT, toError } from '../../utils/errors.js';
+import { execFileNoThrow } from '../../utils/execFileNoThrow.js';
+import { pathExists } from '../../utils/file.js';
+import { logError } from '../../utils/log.js';
+import { getPlatform } from '../../utils/platform.js';
+import { clearAllCaches } from '../../utils/plugins/cacheUtils.js';
+import { isPluginInstalled } from '../../utils/plugins/installedPluginsManager.js';
+import { addMarketplaceSource, clearMarketplacesCache, loadKnownMarketplacesConfig, refreshMarketplace } from '../../utils/plugins/marketplaceManager.js';
+import { OFFICIAL_MARKETPLACE_NAME } from '../../utils/plugins/officialMarketplace.js';
+import { loadAllPlugins } from '../../utils/plugins/pluginLoader.js';
+import { installSelectedPlugins } from '../../utils/plugins/pluginStartupCheck.js';
+
+// Marketplace and plugin identifiers - varies by user type
+const INTERNAL_MARKETPLACE_NAME = 'claude-code-marketplace';
+const INTERNAL_MARKETPLACE_REPO = 'anthropics/claude-code-marketplace';
+const OFFICIAL_MARKETPLACE_REPO = 'anthropics/claude-plugins-official';
+function getMarketplaceName(): string {
+  return "external" === 'ant' ? INTERNAL_MARKETPLACE_NAME : OFFICIAL_MARKETPLACE_NAME;
+}
+function getMarketplaceRepo(): string {
+  return "external" === 'ant' ? INTERNAL_MARKETPLACE_REPO : OFFICIAL_MARKETPLACE_REPO;
+}
+function getPluginId(): string {
+  return `thinkback@${getMarketplaceName()}`;
+}
+const SKILL_NAME = 'thinkback';
+
+/**
+ * Get the thinkback skill directory from the installed plugin's cache path
+ */
+async function getThinkbackSkillDir(): Promise<string | null> {
+  const {
+    enabled
+  } = await loadAllPlugins();
+  const thinkbackPlugin = enabled.find(p => p.name === 'thinkback' || p.source && p.source.includes(getPluginId()));
+  if (!thinkbackPlugin) {
+    return null;
+  }
+  const skillDir = join(thinkbackPlugin.path, 'skills', SKILL_NAME);
+  if (await pathExists(skillDir)) {
+    return skillDir;
+  }
+  return null;
+}
+export async function playAnimation(skillDir: string): Promise<{
+  success: boolean;
+  message: string;
+}> {
+  const dataPath = join(skillDir, 'year_in_review.js');
+  const playerPath = join(skillDir, 'player.js');
+
+  // Both files are prerequisites for the node subprocess. Read them here
+  // (not at call sites) so all callers get consistent error messaging. The
+  // subprocess runs with reject: false, so a missing file would otherwise
+  // silently return success. Using readFile (not access) per CLAUDE.md.
+  //
+  // Non-ENOENT errors (EACCES etc) are logged and returned as failures rather
+  // than thrown — the old pathExists-based code never threw, and one caller
+  // (handleSelect) uses `void playAnimation().then(...)` without a .catch().
+  try {
+    await readFile(dataPath);
+  } catch (e: unknown) {
+    if (isENOENT(e)) {
+      return {
+        success: false,
+        message: 'No animation found. Run /think-back first to generate one.'
+      };
+    }
+    logError(e);
+    return {
+      success: false,
+      message: `Could not access animation data: ${toError(e).message}`
+    };
+  }
+  try {
+    await readFile(playerPath);
+  } catch (e: unknown) {
+    if (isENOENT(e)) {
+      return {
+        success: false,
+        message: 'Player script not found. The player.js file is missing from the thinkback skill.'
+      };
+    }
+    logError(e);
+    return {
+      success: false,
+      message: `Could not access player script: ${toError(e).message}`
+    };
+  }
+
+  // Get ink instance for terminal takeover
+  const inkInstance = instances.get(process.stdout);
+  if (!inkInstance) {
+    return {
+      success: false,
+      message: 'Failed to access terminal instance'
+    };
+  }
+  inkInstance.enterAlternateScreen();
+  try {
+    await execa('node', [playerPath], {
+      stdio: 'inherit',
+      cwd: skillDir,
+      reject: false
+    });
+  } catch {
+    // Animation may have been interrupted (e.g., Ctrl+C)
+  } finally {
+    inkInstance.exitAlternateScreen();
+  }
+
+  // Open the HTML file in browser for video download
+  const htmlPath = join(skillDir, 'year_in_review.html');
+  if (await pathExists(htmlPath)) {
+    const platform = getPlatform();
+    const openCmd = platform === 'macos' ? 'open' : platform === 'windows' ? 'start' : 'xdg-open';
+    void execFileNoThrow(openCmd, [htmlPath]);
+  }
+  return {
+    success: true,
+    message: 'Year in review animation complete!'
+  };
+}
+type InstallState = {
+  phase: 'checking';
+} | {
+  phase: 'installing-marketplace';
+} | {
+  phase: 'installing-plugin';
+} | {
+  phase: 'enabling-plugin';
+} | {
+  phase: 'ready';
+} | {
+  phase: 'error';
+  message: string;
+};
+function ThinkbackInstaller({
+  onReady,
+  onError
+}: {
+  onReady: () => void;
+  onError: (message: string) => void;
+}): React.ReactNode {
+  const [state, setState] = useState<InstallState>({
+    phase: 'checking'
+  });
+  const [progressMessage, setProgressMessage] = useState('');
+  useEffect(() => {
+    async function checkAndInstall(): Promise<void> {
+      try {
+        // Check if marketplace is installed
+        const knownMarketplaces = await loadKnownMarketplacesConfig();
+        const marketplaceName = getMarketplaceName();
+        const marketplaceRepo = getMarketplaceRepo();
+        const pluginId = getPluginId();
+        const marketplaceInstalled = marketplaceName in knownMarketplaces;
+
+        // Check if plugin is already installed first
+        const pluginAlreadyInstalled = isPluginInstalled(pluginId);
+        if (!marketplaceInstalled) {
+          // Install the marketplace
+          setState({
+            phase: 'installing-marketplace'
+          });
+          logForDebugging(`Installing marketplace ${marketplaceRepo}`);
+          await addMarketplaceSource({
+            source: 'github',
+            repo: marketplaceRepo
+          }, message => {
+            setProgressMessage(message);
+          });
+          clearAllCaches();
+          logForDebugging(`Marketplace ${marketplaceName} installed`);
+        } else if (!pluginAlreadyInstalled) {
+          // Marketplace installed but plugin not installed - refresh to get latest plugins
+          // Only refresh when needed to avoid potentially destructive git operations
+          setState({
+            phase: 'installing-marketplace'
+          });
+          setProgressMessage('Updating marketplace…');
+          logForDebugging(`Refreshing marketplace ${marketplaceName}`);
+          await refreshMarketplace(marketplaceName, message_0 => {
+            setProgressMessage(message_0);
+          });
+          clearMarketplacesCache();
+          clearAllCaches();
+          logForDebugging(`Marketplace ${marketplaceName} refreshed`);
+        }
+        if (!pluginAlreadyInstalled) {
+          // Install the plugin
+          setState({
+            phase: 'installing-plugin'
+          });
+          logForDebugging(`Installing plugin ${pluginId}`);
+          const result = await installSelectedPlugins([pluginId]);
+          if (result.failed.length > 0) {
+            const errorMsg = result.failed.map(f => `${f.name}: ${f.error}`).join(', ');
+            throw new Error(`Failed to install plugin: ${errorMsg}`);
+          }
+          clearAllCaches();
+          logForDebugging(`Plugin ${pluginId} installed`);
+        } else {
+          // Plugin is installed, check if it's enabled
+          const {
+            disabled
+          } = await loadAllPlugins();
+          const isDisabled = disabled.some(p => p.name === 'thinkback' || p.source?.includes(pluginId));
+          if (isDisabled) {
+            // Enable the plugin
+            setState({
+              phase: 'enabling-plugin'
+            });
+            logForDebugging(`Enabling plugin ${pluginId}`);
+            const enableResult = await enablePluginOp(pluginId);
+            if (!enableResult.success) {
+              throw new Error(`Failed to enable plugin: ${enableResult.message}`);
+            }
+            clearAllCaches();
+            logForDebugging(`Plugin ${pluginId} enabled`);
+          }
+        }
+        setState({
+          phase: 'ready'
+        });
+        onReady();
+      } catch (error) {
+        const err = toError(error);
+        logError(err);
+        setState({
+          phase: 'error',
+          message: err.message
+        });
+        onError(err.message);
+      }
+    }
+    void checkAndInstall();
+  }, [onReady, onError]);
+  if (state.phase === 'error') {
+    return <Box flexDirection="column">
+        <Text color="error">Error: {state.message}</Text>
+      </Box>;
+  }
+  if (state.phase === 'ready') {
+    return null;
+  }
+  const statusMessage = state.phase === 'checking' ? 'Checking thinkback installation…' : state.phase === 'installing-marketplace' ? 'Installing marketplace…' : state.phase === 'enabling-plugin' ? 'Enabling thinkback plugin…' : 'Installing thinkback plugin…';
+  return <Box flexDirection="column">
+      <Box>
+        <Spinner />
+        <Text>{progressMessage || statusMessage}</Text>
+      </Box>
+    </Box>;
+}
+type MenuAction = 'play' | 'edit' | 'fix' | 'regenerate';
+type GenerativeAction = Exclude<MenuAction, 'play'>;
+function ThinkbackMenu(t0) {
+  const $ = _c(19);
+  const {
+    onDone,
+    onAction,
+    skillDir,
+    hasGenerated
+  } = t0;
+  const [hasSelected, setHasSelected] = useState(false);
+  let t1;
+  if ($[0] !== hasGenerated) {
+    t1 = hasGenerated ? [{
+      label: "Play animation",
+      value: "play" as const,
+      description: "Watch your year in review"
+    }, {
+      label: "Edit content",
+      value: "edit" as const,
+      description: "Modify the animation"
+    }, {
+      label: "Fix errors",
+      value: "fix" as const,
+      description: "Fix validation or rendering issues"
+    }, {
+      label: "Regenerate",
+      value: "regenerate" as const,
+      description: "Create a new animation from scratch"
+    }] : [{
+      label: "Let's go!",
+      value: "regenerate" as const,
+      description: "Generate your personalized animation"
+    }];
+    $[0] = hasGenerated;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const options = t1;
+  let t2;
+  if ($[2] !== onAction || $[3] !== onDone || $[4] !== skillDir) {
+    t2 = function handleSelect(value) {
+      setHasSelected(true);
+      if (value === "play") {
+        playAnimation(skillDir).then(() => {
+          onDone(undefined, {
+            display: "skip"
+          });
+        });
+      } else {
+        onAction(value);
+      }
+    };
+    $[2] = onAction;
+    $[3] = onDone;
+    $[4] = skillDir;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const handleSelect = t2;
+  let t3;
+  if ($[6] !== onDone) {
+    t3 = function handleCancel() {
+      onDone(undefined, {
+        display: "skip"
+      });
+    };
+    $[6] = onDone;
+    $[7] = t3;
+  } else {
+    t3 = $[7];
+  }
+  const handleCancel = t3;
+  if (hasSelected) {
+    return null;
+  }
+  let t4;
+  if ($[8] !== hasGenerated) {
+    t4 = !hasGenerated && <Box flexDirection="column"><Text>Relive your year of coding with Claude.</Text><Text dimColor={true}>{"We'll create a personalized ASCII animation celebrating your journey."}</Text></Box>;
+    $[8] = hasGenerated;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  let t5;
+  if ($[10] !== handleSelect || $[11] !== options) {
+    t5 = <Select options={options} onChange={handleSelect} visibleOptionCount={5} />;
+    $[10] = handleSelect;
+    $[11] = options;
+    $[12] = t5;
+  } else {
+    t5 = $[12];
+  }
+  let t6;
+  if ($[13] !== t4 || $[14] !== t5) {
+    t6 = <Box flexDirection="column" gap={1}>{t4}{t5}</Box>;
+    $[13] = t4;
+    $[14] = t5;
+    $[15] = t6;
+  } else {
+    t6 = $[15];
+  }
+  let t7;
+  if ($[16] !== handleCancel || $[17] !== t6) {
+    t7 = <Dialog title="Think Back on 2025 with Claude Code" subtitle="Generate your 2025 Claude Code Think Back (takes a few minutes to run)" onCancel={handleCancel} color="claude">{t6}</Dialog>;
+    $[16] = handleCancel;
+    $[17] = t6;
+    $[18] = t7;
+  } else {
+    t7 = $[18];
+  }
+  return t7;
+}
+const EDIT_PROMPT = 'Use the Skill tool to invoke the "thinkback" skill with mode=edit to modify my existing Claude Code year in review animation. Ask me what I want to change. When the animation is ready, tell the user to run /think-back again to play it.';
+const FIX_PROMPT = 'Use the Skill tool to invoke the "thinkback" skill with mode=fix to fix validation or rendering errors in my existing Claude Code year in review animation. Run the validator, identify errors, and fix them. When the animation is ready, tell the user to run /think-back again to play it.';
+const REGENERATE_PROMPT = 'Use the Skill tool to invoke the "thinkback" skill with mode=regenerate to create a completely new Claude Code year in review animation from scratch. Delete the existing animation and start fresh. When the animation is ready, tell the user to run /think-back again to play it.';
+function ThinkbackFlow(t0) {
+  const $ = _c(27);
+  const {
+    onDone
+  } = t0;
+  const [installComplete, setInstallComplete] = useState(false);
+  const [installError, setInstallError] = useState(null);
+  const [skillDir, setSkillDir] = useState(null);
+  const [hasGenerated, setHasGenerated] = useState(null);
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = function handleReady() {
+      setInstallComplete(true);
+    };
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const handleReady = t1;
+  let t2;
+  if ($[1] !== onDone) {
+    t2 = message => {
+      setInstallError(message);
+      onDone(`Error with thinkback: ${message}. Try running /plugin to manually install the think-back plugin.`, {
+        display: "system"
+      });
+    };
+    $[1] = onDone;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  const handleError = t2;
+  let t3;
+  let t4;
+  if ($[3] !== handleError || $[4] !== installComplete || $[5] !== installError || $[6] !== skillDir) {
+    t3 = () => {
+      if (installComplete && !skillDir && !installError) {
+        getThinkbackSkillDir().then(dir => {
+          if (dir) {
+            logForDebugging(`Thinkback skill directory: ${dir}`);
+            setSkillDir(dir);
+          } else {
+            handleError("Could not find thinkback skill directory");
+          }
+        });
+      }
+    };
+    t4 = [installComplete, skillDir, installError, handleError];
+    $[3] = handleError;
+    $[4] = installComplete;
+    $[5] = installError;
+    $[6] = skillDir;
+    $[7] = t3;
+    $[8] = t4;
+  } else {
+    t3 = $[7];
+    t4 = $[8];
+  }
+  useEffect(t3, t4);
+  let t5;
+  let t6;
+  if ($[9] !== skillDir) {
+    t5 = () => {
+      if (!skillDir) {
+        return;
+      }
+      const dataPath = join(skillDir, "year_in_review.js");
+      pathExists(dataPath).then(exists => {
+        logForDebugging(`Checking for ${dataPath}: ${exists ? "found" : "not found"}`);
+        setHasGenerated(exists);
+      });
+    };
+    t6 = [skillDir];
+    $[9] = skillDir;
+    $[10] = t5;
+    $[11] = t6;
+  } else {
+    t5 = $[10];
+    t6 = $[11];
+  }
+  useEffect(t5, t6);
+  let t7;
+  if ($[12] !== onDone) {
+    t7 = function handleAction(action) {
+      const prompts = {
+        edit: EDIT_PROMPT,
+        fix: FIX_PROMPT,
+        regenerate: REGENERATE_PROMPT
+      };
+      onDone(prompts[action], {
+        display: "user",
+        shouldQuery: true
+      });
+    };
+    $[12] = onDone;
+    $[13] = t7;
+  } else {
+    t7 = $[13];
+  }
+  const handleAction = t7;
+  if (installError) {
+    let t8;
+    if ($[14] !== installError) {
+      t8 = <Text color="error">Error: {installError}</Text>;
+      $[14] = installError;
+      $[15] = t8;
+    } else {
+      t8 = $[15];
+    }
+    let t9;
+    if ($[16] === Symbol.for("react.memo_cache_sentinel")) {
+      t9 = <Text dimColor={true}>Try running /plugin to manually install the think-back plugin.</Text>;
+      $[16] = t9;
+    } else {
+      t9 = $[16];
+    }
+    let t10;
+    if ($[17] !== t8) {
+      t10 = <Box flexDirection="column">{t8}{t9}</Box>;
+      $[17] = t8;
+      $[18] = t10;
+    } else {
+      t10 = $[18];
+    }
+    return t10;
+  }
+  if (!installComplete) {
+    let t8;
+    if ($[19] !== handleError) {
+      t8 = <ThinkbackInstaller onReady={handleReady} onError={handleError} />;
+      $[19] = handleError;
+      $[20] = t8;
+    } else {
+      t8 = $[20];
+    }
+    return t8;
+  }
+  if (!skillDir || hasGenerated === null) {
+    let t8;
+    if ($[21] === Symbol.for("react.memo_cache_sentinel")) {
+      t8 = <Box><Spinner /><Text>Loading thinkback skill…</Text></Box>;
+      $[21] = t8;
+    } else {
+      t8 = $[21];
+    }
+    return t8;
+  }
+  let t8;
+  if ($[22] !== handleAction || $[23] !== hasGenerated || $[24] !== onDone || $[25] !== skillDir) {
+    t8 = <ThinkbackMenu onDone={onDone} onAction={handleAction} skillDir={skillDir} hasGenerated={hasGenerated} />;
+    $[22] = handleAction;
+    $[23] = hasGenerated;
+    $[24] = onDone;
+    $[25] = skillDir;
+    $[26] = t8;
+  } else {
+    t8 = $[26];
+  }
+  return t8;
+}
+export async function call(onDone: (result?: string, options?: {
+  display?: CommandResultDisplay;
+  shouldQuery?: boolean;
+}) => void): Promise<React.ReactNode> {
+  return <ThinkbackFlow onDone={onDone} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["execa","readFile","join","React","useCallback","useEffect","useState","CommandResultDisplay","Select","Dialog","Spinner","instances","Box","Text","enablePluginOp","logForDebugging","isENOENT","toError","execFileNoThrow","pathExists","logError","getPlatform","clearAllCaches","isPluginInstalled","addMarketplaceSource","clearMarketplacesCache","loadKnownMarketplacesConfig","refreshMarketplace","OFFICIAL_MARKETPLACE_NAME","loadAllPlugins","installSelectedPlugins","INTERNAL_MARKETPLACE_NAME","INTERNAL_MARKETPLACE_REPO","OFFICIAL_MARKETPLACE_REPO","getMarketplaceName","getMarketplaceRepo","getPluginId","SKILL_NAME","getThinkbackSkillDir","Promise","enabled","thinkbackPlugin","find","p","name","source","includes","skillDir","path","playAnimation","success","message","dataPath","playerPath","e","inkInstance","get","process","stdout","enterAlternateScreen","stdio","cwd","reject","exitAlternateScreen","htmlPath","platform","openCmd","InstallState","phase","ThinkbackInstaller","onReady","onError","ReactNode","state","setState","progressMessage","setProgressMessage","checkAndInstall","knownMarketplaces","marketplaceName","marketplaceRepo","pluginId","marketplaceInstalled","pluginAlreadyInstalled","repo","result","failed","length","errorMsg","map","f","error","Error","disabled","isDisabled","some","enableResult","err","statusMessage","MenuAction","GenerativeAction","Exclude","ThinkbackMenu","t0","$","_c","onDone","onAction","hasGenerated","hasSelected","setHasSelected","t1","label","value","const","description","options","t2","handleSelect","then","undefined","display","t3","handleCancel","t4","t5","t6","t7","EDIT_PROMPT","FIX_PROMPT","REGENERATE_PROMPT","ThinkbackFlow","installComplete","setInstallComplete","installError","setInstallError","setSkillDir","setHasGenerated","Symbol","for","handleReady","handleError","dir","exists","handleAction","action","prompts","edit","fix","regenerate","shouldQuery","t8","t9","t10","call"],"sources":["thinkback.tsx"],"sourcesContent":["import { execa } from 'execa'\nimport { readFile } from 'fs/promises'\nimport { join } from 'path'\nimport * as React from 'react'\nimport { useCallback, useEffect, useState } from 'react'\nimport type { CommandResultDisplay } from '../../commands.js'\nimport { Select } from '../../components/CustomSelect/select.js'\nimport { Dialog } from '../../components/design-system/Dialog.js'\nimport { Spinner } from '../../components/Spinner.js'\nimport instances from '../../ink/instances.js'\nimport { Box, Text } from '../../ink.js'\nimport { enablePluginOp } from '../../services/plugins/pluginOperations.js'\nimport { logForDebugging } from '../../utils/debug.js'\nimport { isENOENT, toError } from '../../utils/errors.js'\nimport { execFileNoThrow } from '../../utils/execFileNoThrow.js'\nimport { pathExists } from '../../utils/file.js'\nimport { logError } from '../../utils/log.js'\nimport { getPlatform } from '../../utils/platform.js'\nimport { clearAllCaches } from '../../utils/plugins/cacheUtils.js'\nimport { isPluginInstalled } from '../../utils/plugins/installedPluginsManager.js'\nimport {\n  addMarketplaceSource,\n  clearMarketplacesCache,\n  loadKnownMarketplacesConfig,\n  refreshMarketplace,\n} from '../../utils/plugins/marketplaceManager.js'\nimport { OFFICIAL_MARKETPLACE_NAME } from '../../utils/plugins/officialMarketplace.js'\nimport { loadAllPlugins } from '../../utils/plugins/pluginLoader.js'\nimport { installSelectedPlugins } from '../../utils/plugins/pluginStartupCheck.js'\n\n// Marketplace and plugin identifiers - varies by user type\nconst INTERNAL_MARKETPLACE_NAME = 'claude-code-marketplace'\nconst INTERNAL_MARKETPLACE_REPO = 'anthropics/claude-code-marketplace'\nconst OFFICIAL_MARKETPLACE_REPO = 'anthropics/claude-plugins-official'\n\nfunction getMarketplaceName(): string {\n  return \"external\" === 'ant'\n    ? INTERNAL_MARKETPLACE_NAME\n    : OFFICIAL_MARKETPLACE_NAME\n}\n\nfunction getMarketplaceRepo(): string {\n  return \"external\" === 'ant'\n    ? INTERNAL_MARKETPLACE_REPO\n    : OFFICIAL_MARKETPLACE_REPO\n}\n\nfunction getPluginId(): string {\n  return `thinkback@${getMarketplaceName()}`\n}\n\nconst SKILL_NAME = 'thinkback'\n\n/**\n * Get the thinkback skill directory from the installed plugin's cache path\n */\nasync function getThinkbackSkillDir(): Promise<string | null> {\n  const { enabled } = await loadAllPlugins()\n  const thinkbackPlugin = enabled.find(\n    p =>\n      p.name === 'thinkback' || (p.source && p.source.includes(getPluginId())),\n  )\n\n  if (!thinkbackPlugin) {\n    return null\n  }\n\n  const skillDir = join(thinkbackPlugin.path, 'skills', SKILL_NAME)\n  if (await pathExists(skillDir)) {\n    return skillDir\n  }\n\n  return null\n}\n\nexport async function playAnimation(skillDir: string): Promise<{\n  success: boolean\n  message: string\n}> {\n  const dataPath = join(skillDir, 'year_in_review.js')\n  const playerPath = join(skillDir, 'player.js')\n\n  // Both files are prerequisites for the node subprocess. Read them here\n  // (not at call sites) so all callers get consistent error messaging. The\n  // subprocess runs with reject: false, so a missing file would otherwise\n  // silently return success. Using readFile (not access) per CLAUDE.md.\n  //\n  // Non-ENOENT errors (EACCES etc) are logged and returned as failures rather\n  // than thrown — the old pathExists-based code never threw, and one caller\n  // (handleSelect) uses `void playAnimation().then(...)` without a .catch().\n  try {\n    await readFile(dataPath)\n  } catch (e: unknown) {\n    if (isENOENT(e)) {\n      return {\n        success: false,\n        message: 'No animation found. Run /think-back first to generate one.',\n      }\n    }\n    logError(e)\n    return {\n      success: false,\n      message: `Could not access animation data: ${toError(e).message}`,\n    }\n  }\n\n  try {\n    await readFile(playerPath)\n  } catch (e: unknown) {\n    if (isENOENT(e)) {\n      return {\n        success: false,\n        message:\n          'Player script not found. The player.js file is missing from the thinkback skill.',\n      }\n    }\n    logError(e)\n    return {\n      success: false,\n      message: `Could not access player script: ${toError(e).message}`,\n    }\n  }\n\n  // Get ink instance for terminal takeover\n  const inkInstance = instances.get(process.stdout)\n  if (!inkInstance) {\n    return { success: false, message: 'Failed to access terminal instance' }\n  }\n\n  inkInstance.enterAlternateScreen()\n  try {\n    await execa('node', [playerPath], {\n      stdio: 'inherit',\n      cwd: skillDir,\n      reject: false,\n    })\n  } catch {\n    // Animation may have been interrupted (e.g., Ctrl+C)\n  } finally {\n    inkInstance.exitAlternateScreen()\n  }\n\n  // Open the HTML file in browser for video download\n  const htmlPath = join(skillDir, 'year_in_review.html')\n  if (await pathExists(htmlPath)) {\n    const platform = getPlatform()\n    const openCmd =\n      platform === 'macos'\n        ? 'open'\n        : platform === 'windows'\n          ? 'start'\n          : 'xdg-open'\n    void execFileNoThrow(openCmd, [htmlPath])\n  }\n\n  return { success: true, message: 'Year in review animation complete!' }\n}\n\ntype InstallState =\n  | { phase: 'checking' }\n  | { phase: 'installing-marketplace' }\n  | { phase: 'installing-plugin' }\n  | { phase: 'enabling-plugin' }\n  | { phase: 'ready' }\n  | { phase: 'error'; message: string }\n\nfunction ThinkbackInstaller({\n  onReady,\n  onError,\n}: {\n  onReady: () => void\n  onError: (message: string) => void\n}): React.ReactNode {\n  const [state, setState] = useState<InstallState>({ phase: 'checking' })\n  const [progressMessage, setProgressMessage] = useState('')\n\n  useEffect(() => {\n    async function checkAndInstall(): Promise<void> {\n      try {\n        // Check if marketplace is installed\n        const knownMarketplaces = await loadKnownMarketplacesConfig()\n        const marketplaceName = getMarketplaceName()\n        const marketplaceRepo = getMarketplaceRepo()\n        const pluginId = getPluginId()\n        const marketplaceInstalled = marketplaceName in knownMarketplaces\n\n        // Check if plugin is already installed first\n        const pluginAlreadyInstalled = isPluginInstalled(pluginId)\n\n        if (!marketplaceInstalled) {\n          // Install the marketplace\n          setState({ phase: 'installing-marketplace' })\n          logForDebugging(`Installing marketplace ${marketplaceRepo}`)\n\n          await addMarketplaceSource(\n            { source: 'github', repo: marketplaceRepo },\n            message => {\n              setProgressMessage(message)\n            },\n          )\n          clearAllCaches()\n          logForDebugging(`Marketplace ${marketplaceName} installed`)\n        } else if (!pluginAlreadyInstalled) {\n          // Marketplace installed but plugin not installed - refresh to get latest plugins\n          // Only refresh when needed to avoid potentially destructive git operations\n          setState({ phase: 'installing-marketplace' })\n          setProgressMessage('Updating marketplace…')\n          logForDebugging(`Refreshing marketplace ${marketplaceName}`)\n\n          await refreshMarketplace(marketplaceName, message => {\n            setProgressMessage(message)\n          })\n          clearMarketplacesCache()\n          clearAllCaches()\n          logForDebugging(`Marketplace ${marketplaceName} refreshed`)\n        }\n\n        if (!pluginAlreadyInstalled) {\n          // Install the plugin\n          setState({ phase: 'installing-plugin' })\n          logForDebugging(`Installing plugin ${pluginId}`)\n\n          const result = await installSelectedPlugins([pluginId])\n\n          if (result.failed.length > 0) {\n            const errorMsg = result.failed\n              .map(f => `${f.name}: ${f.error}`)\n              .join(', ')\n            throw new Error(`Failed to install plugin: ${errorMsg}`)\n          }\n\n          clearAllCaches()\n          logForDebugging(`Plugin ${pluginId} installed`)\n        } else {\n          // Plugin is installed, check if it's enabled\n          const { disabled } = await loadAllPlugins()\n          const isDisabled = disabled.some(\n            p => p.name === 'thinkback' || p.source?.includes(pluginId),\n          )\n\n          if (isDisabled) {\n            // Enable the plugin\n            setState({ phase: 'enabling-plugin' })\n            logForDebugging(`Enabling plugin ${pluginId}`)\n\n            const enableResult = await enablePluginOp(pluginId)\n            if (!enableResult.success) {\n              throw new Error(\n                `Failed to enable plugin: ${enableResult.message}`,\n              )\n            }\n\n            clearAllCaches()\n            logForDebugging(`Plugin ${pluginId} enabled`)\n          }\n        }\n\n        setState({ phase: 'ready' })\n        onReady()\n      } catch (error) {\n        const err = toError(error)\n        logError(err)\n        setState({ phase: 'error', message: err.message })\n        onError(err.message)\n      }\n    }\n\n    void checkAndInstall()\n  }, [onReady, onError])\n\n  if (state.phase === 'error') {\n    return (\n      <Box flexDirection=\"column\">\n        <Text color=\"error\">Error: {state.message}</Text>\n      </Box>\n    )\n  }\n\n  if (state.phase === 'ready') {\n    return null\n  }\n\n  const statusMessage =\n    state.phase === 'checking'\n      ? 'Checking thinkback installation…'\n      : state.phase === 'installing-marketplace'\n        ? 'Installing marketplace…'\n        : state.phase === 'enabling-plugin'\n          ? 'Enabling thinkback plugin…'\n          : 'Installing thinkback plugin…'\n\n  return (\n    <Box flexDirection=\"column\">\n      <Box>\n        <Spinner />\n        <Text>{progressMessage || statusMessage}</Text>\n      </Box>\n    </Box>\n  )\n}\n\ntype MenuAction = 'play' | 'edit' | 'fix' | 'regenerate'\ntype GenerativeAction = Exclude<MenuAction, 'play'>\n\nfunction ThinkbackMenu({\n  onDone,\n  onAction,\n  skillDir,\n  hasGenerated,\n}: {\n  onDone: (\n    result?: string,\n    options?: { display?: CommandResultDisplay; shouldQuery?: boolean },\n  ) => void\n  onAction: (action: GenerativeAction) => void\n  skillDir: string\n  hasGenerated: boolean\n}): React.ReactNode {\n  const [hasSelected, setHasSelected] = useState(false)\n\n  const options = hasGenerated\n    ? [\n        {\n          label: 'Play animation',\n          value: 'play' as const,\n          description: 'Watch your year in review',\n        },\n        {\n          label: 'Edit content',\n          value: 'edit' as const,\n          description: 'Modify the animation',\n        },\n        {\n          label: 'Fix errors',\n          value: 'fix' as const,\n          description: 'Fix validation or rendering issues',\n        },\n        {\n          label: 'Regenerate',\n          value: 'regenerate' as const,\n          description: 'Create a new animation from scratch',\n        },\n      ]\n    : [\n        {\n          label: \"Let's go!\",\n          value: 'regenerate' as const,\n          description: 'Generate your personalized animation',\n        },\n      ]\n\n  function handleSelect(value: MenuAction): void {\n    setHasSelected(true)\n    if (value === 'play') {\n      // Play runs the terminal-takeover animation, then signal done with skip\n      void playAnimation(skillDir).then(() => {\n        onDone(undefined, { display: 'skip' })\n      })\n    } else {\n      onAction(value)\n    }\n  }\n\n  function handleCancel(): void {\n    onDone(undefined, { display: 'skip' })\n  }\n\n  if (hasSelected) {\n    return null\n  }\n\n  return (\n    <Dialog\n      title=\"Think Back on 2025 with Claude Code\"\n      subtitle=\"Generate your 2025 Claude Code Think Back (takes a few minutes to run)\"\n      onCancel={handleCancel}\n      color=\"claude\"\n    >\n      <Box flexDirection=\"column\" gap={1}>\n        {/* Description for first-time users */}\n        {!hasGenerated && (\n          <Box flexDirection=\"column\">\n            <Text>Relive your year of coding with Claude.</Text>\n            <Text dimColor>\n              {\n                \"We'll create a personalized ASCII animation celebrating your journey.\"\n              }\n            </Text>\n          </Box>\n        )}\n\n        {/* Menu */}\n        <Select\n          options={options}\n          onChange={handleSelect}\n          visibleOptionCount={5}\n        />\n      </Box>\n    </Dialog>\n  )\n}\n\nconst EDIT_PROMPT =\n  'Use the Skill tool to invoke the \"thinkback\" skill with mode=edit to modify my existing Claude Code year in review animation. Ask me what I want to change. When the animation is ready, tell the user to run /think-back again to play it.'\n\nconst FIX_PROMPT =\n  'Use the Skill tool to invoke the \"thinkback\" skill with mode=fix to fix validation or rendering errors in my existing Claude Code year in review animation. Run the validator, identify errors, and fix them. When the animation is ready, tell the user to run /think-back again to play it.'\n\nconst REGENERATE_PROMPT =\n  'Use the Skill tool to invoke the \"thinkback\" skill with mode=regenerate to create a completely new Claude Code year in review animation from scratch. Delete the existing animation and start fresh. When the animation is ready, tell the user to run /think-back again to play it.'\n\nfunction ThinkbackFlow({\n  onDone,\n}: {\n  onDone: (\n    result?: string,\n    options?: { display?: CommandResultDisplay; shouldQuery?: boolean },\n  ) => void\n}): React.ReactNode {\n  const [installComplete, setInstallComplete] = useState(false)\n  const [installError, setInstallError] = useState<string | null>(null)\n  const [skillDir, setSkillDir] = useState<string | null>(null)\n  const [hasGenerated, setHasGenerated] = useState<boolean | null>(null)\n\n  function handleReady(): void {\n    setInstallComplete(true)\n  }\n\n  const handleError = useCallback(\n    (message: string): void => {\n      setInstallError(message)\n      // Call onDone with the error message so the model can continue\n      onDone(\n        `Error with thinkback: ${message}. Try running /plugin to manually install the think-back plugin.`,\n        { display: 'system' },\n      )\n    },\n    [onDone],\n  )\n\n  useEffect(() => {\n    if (installComplete && !skillDir && !installError) {\n      // Get the skill directory after installation\n      void getThinkbackSkillDir().then(dir => {\n        if (dir) {\n          logForDebugging(`Thinkback skill directory: ${dir}`)\n          setSkillDir(dir)\n        } else {\n          handleError('Could not find thinkback skill directory')\n        }\n      })\n    }\n  }, [installComplete, skillDir, installError, handleError])\n\n  // Check for generated file once we have skillDir\n  useEffect(() => {\n    if (!skillDir) {\n      return\n    }\n\n    const dataPath = join(skillDir, 'year_in_review.js')\n    void pathExists(dataPath).then(exists => {\n      logForDebugging(\n        `Checking for ${dataPath}: ${exists ? 'found' : 'not found'}`,\n      )\n      setHasGenerated(exists)\n    })\n  }, [skillDir])\n\n  function handleAction(action: GenerativeAction): void {\n    // Send prompt to model based on action\n    const prompts: Record<GenerativeAction, string> = {\n      edit: EDIT_PROMPT,\n      fix: FIX_PROMPT,\n      regenerate: REGENERATE_PROMPT,\n    }\n    onDone(prompts[action], { display: 'user', shouldQuery: true })\n  }\n\n  if (installError) {\n    return (\n      <Box flexDirection=\"column\">\n        <Text color=\"error\">Error: {installError}</Text>\n        <Text dimColor>\n          Try running /plugin to manually install the think-back plugin.\n        </Text>\n      </Box>\n    )\n  }\n\n  if (!installComplete) {\n    return <ThinkbackInstaller onReady={handleReady} onError={handleError} />\n  }\n\n  if (!skillDir || hasGenerated === null) {\n    return (\n      <Box>\n        <Spinner />\n        <Text>Loading thinkback skill…</Text>\n      </Box>\n    )\n  }\n\n  return (\n    <ThinkbackMenu\n      onDone={onDone}\n      onAction={handleAction}\n      skillDir={skillDir}\n      hasGenerated={hasGenerated}\n    />\n  )\n}\n\nexport async function call(\n  onDone: (\n    result?: string,\n    options?: { display?: CommandResultDisplay; shouldQuery?: boolean },\n  ) => void,\n): Promise<React.ReactNode> {\n  return <ThinkbackFlow onDone={onDone} />\n}\n"],"mappings":"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","ignoreList":[]}

package/src/commands/thinkback-play/index.ts

@@ -0,0 +1,17 @@
+import type { Command } from '../../commands.js'
+import { checkStatsigFeatureGate_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js'
+
+// Hidden command that just plays the animation
+// Called by the thinkback skill after generation is complete
+const thinkbackPlay = {
+  type: 'local',
+  name: 'thinkback-play',
+  description: 'Play the thinkback animation',
+  isEnabled: () =>
+    checkStatsigFeatureGate_CACHED_MAY_BE_STALE('tengu_thinkback'),
+  isHidden: true,
+  supportsNonInteractive: false,
+  load: () => import('./thinkback-play.js'),
+} satisfies Command
+
+export default thinkbackPlay