skillo 0.2.6 → 0.2.8

package/dist/chunk-U53QWUOR.js

@@ -0,0 +1,727 @@
+#!/usr/bin/env node
+import {
+  logger_default
+} from "./chunk-VAQ73XPE.js";
+import {
+  SkilloDatabase
+} from "./chunk-73NUWYUO.js";
+import {
+  loadConfig
+} from "./chunk-QUXHHRRK.js";
+import {
+  ensureDirectory,
+  getConfigFile,
+  getDataDir
+} from "./chunk-63FVALWX.js";
+
+// src/commands/shell.ts
+import { existsSync, writeFileSync, readFileSync, appendFileSync } from "fs";
+import { spawn } from "child_process";
+import { homedir } from "os";
+import { join } from "path";
+import { Command } from "commander";
+var UNSYNCED_REMINDER_THRESHOLD = 50;
+async function checkLoginStatus() {
+  try {
+    const { getApiClient } = await import("./api-client-BF6GDR7Q.js");
+    const client = getApiClient();
+    return client.hasApiKey();
+  } catch {
+    return false;
+  }
+}
+function getUnsyncedCounterPath() {
+  return join(getDataDir(), "unsynced-count");
+}
+function incrementUnsyncedCounter() {
+  const counterPath = getUnsyncedCounterPath();
+  let count = 0;
+  try {
+    if (existsSync(counterPath)) {
+      const parsed = parseInt(readFileSync(counterPath, "utf-8").trim(), 10);
+      count = Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+    }
+  } catch {
+  }
+  count++;
+  try {
+    writeFileSync(counterPath, String(count), "utf-8");
+  } catch {
+  }
+  return count;
+}
+function resetUnsyncedCounter() {
+  try {
+    writeFileSync(getUnsyncedCounterPath(), "0", "utf-8");
+  } catch {
+  }
+}
+function normalizeCommand(cmd) {
+  const variables = {};
+  let normalized = cmd;
+  let varIndex = 0;
+  normalized = normalized.replace(/(?:^|\s)(\/[\w\-.\/]+)/g, (match, path) => {
+    const key = `$PATH${varIndex++}`;
+    variables[key] = path;
+    return match.replace(path, key);
+  });
+  normalized = normalized.replace(
+    /https?:\/\/[^\s]+/g,
+    (match) => {
+      const key = `$URL${varIndex++}`;
+      variables[key] = match;
+      return key;
+    }
+  );
+  normalized = normalized.replace(/\b\d{4,}\b/g, (match) => {
+    const key = `$NUM${varIndex++}`;
+    variables[key] = match;
+    return key;
+  });
+  normalized = normalized.replace(/"[^"]+"/g, (match) => {
+    const key = `$STR${varIndex++}`;
+    variables[key] = match;
+    return key;
+  });
+  normalized = normalized.replace(/'[^']+'/g, (match) => {
+    const key = `$STR${varIndex++}`;
+    variables[key] = match;
+    return key;
+  });
+  return { normalized: normalized.trim(), variables };
+}
+var shellCommand = new Command("shell").description("Start a tracked terminal session").option("-s, --shell <shell>", "Shell to use (default: $SHELL or cmd on Windows)").option("-p, --project <path>", "Project path to track").action(async (options) => {
+  if (!existsSync(getConfigFile())) {
+    logger_default.error("Skillo not initialized. Run 'skillo init' first.");
+    process.exit(1);
+  }
+  const config = loadConfig();
+  let shell = options.shell || config.defaultShell;
+  if (!shell) {
+    if (process.platform === "win32") {
+      shell = process.env.COMSPEC || "cmd.exe";
+    } else {
+      shell = process.env.SHELL || "/bin/bash";
+    }
+  }
+  const projectPath = options.project || process.cwd();
+  logger_default.blank();
+  logger_default.info("Starting tracked shell session...");
+  logger_default.dim(`Shell: ${shell}`);
+  logger_default.dim(`Project: ${projectPath}`);
+  logger_default.blank();
+  logger_default.dim("All commands will be tracked. Type 'exit' to end the session.");
+  logger_default.blank();
+  const db = new SkilloDatabase();
+  await db.initialize();
+  const sessionId = await db.createSession(shell, projectPath);
+  let commandCount = 0;
+  let currentCommand = "";
+  let commandStartTime = null;
+  const shellArgs = process.platform === "win32" ? [] : ["-i"];
+  const child = spawn(shell, shellArgs, {
+    stdio: ["inherit", "inherit", "inherit"],
+    shell: false,
+    cwd: projectPath,
+    env: {
+      ...process.env,
+      SKILLO_SESSION: sessionId,
+      SKILLO_TRACKING: "1"
+    }
+  });
+  child.on("exit", async (code) => {
+    await db.endSession(sessionId);
+    db.close();
+    logger_default.blank();
+    logger_default.success(`Session ended. Tracked ${commandCount} command(s).`);
+    logger_default.dim(`Session ID: ${sessionId.slice(0, 8)}`);
+    logger_default.blank();
+    process.exit(code || 0);
+  });
+  child.on("error", async (error) => {
+    logger_default.error(`Failed to start shell: ${error.message}`);
+    await db.endSession(sessionId);
+    db.close();
+    process.exit(1);
+  });
+});
+var recordCommand = new Command("record").description("Record a command (used by shell integration)").argument("<command>", "Command that was executed").option("--session <id>", "Session ID").option("--cwd <path>", "Working directory").option("--exit-code <code>", "Exit code").option("--duration <ms>", "Duration in milliseconds").option("--no-sync", "Don't sync to platform").action(
+  async (command, options) => {
+    const cwd = options.cwd || process.cwd();
+    const exitCode = options.exitCode ? parseInt(options.exitCode, 10) : null;
+    const durationMs = options.duration ? parseInt(options.duration, 10) : null;
+    const sessionId = options.session || process.env.SKILLO_SESSION || "default";
+    const { normalized, variables } = normalizeCommand(command);
+    const db = new SkilloDatabase();
+    await db.initialize();
+    await db.addCommand({
+      command,
+      normalized,
+      cwd,
+      sessionId,
+      exitCode,
+      durationMs,
+      variables: Object.keys(variables).length > 0 ? variables : null
+    });
+    db.close();
+    if (options.sync !== false) {
+      try {
+        const isLoggedIn = await checkLoginStatus();
+        if (isLoggedIn) {
+          const { getApiClient } = await import("./api-client-BF6GDR7Q.js");
+          const client = getApiClient();
+          await client.syncCommands([{
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            command,
+            normalized,
+            cwd,
+            exitCode,
+            durationMs,
+            sessionId: sessionId !== "default" ? sessionId : void 0,
+            variables: Object.keys(variables).length > 0 ? variables : null
+          }]);
+          resetUnsyncedCounter();
+        } else {
+          const count = incrementUnsyncedCounter();
+          if (count === UNSYNCED_REMINDER_THRESHOLD) {
+            process.stderr.write(
+              `\x1B[33m[!] You have ${UNSYNCED_REMINDER_THRESHOLD}+ commands tracked locally but not synced. Run 'skillo login' to enable cloud sync.\x1B[0m
+`
+            );
+          }
+        }
+      } catch {
+      }
+    }
+  }
+);
+var setupShellCommand = new Command("setup-shell").description("Set up shell integration for automatic command tracking").option("--bash", "Set up Bash integration").option("--zsh", "Set up Zsh integration").option("--powershell", "Set up PowerShell integration").option("--fish", "Set up Fish integration").option("--uninstall", "Remove shell integration").action(async (options) => {
+  logger_default.blank();
+  const home = homedir();
+  const dataDir = getDataDir();
+  ensureDirectory(dataDir);
+  let shell = null;
+  if (options.bash) shell = "bash";
+  else if (options.zsh) shell = "zsh";
+  else if (options.powershell) shell = "powershell";
+  else if (options.fish) shell = "fish";
+  else {
+    if (process.platform === "win32") {
+      if (process.env.MSYSTEM || process.env.SHELL?.includes("bash") || process.env.TERM === "mintty") {
+        shell = "bash";
+      } else {
+        shell = "powershell";
+      }
+    } else {
+      const currentShell = process.env.SHELL || "";
+      if (currentShell.includes("zsh")) shell = "zsh";
+      else if (currentShell.includes("fish")) shell = "fish";
+      else shell = "bash";
+    }
+    logger_default.info(`Detected shell: ${shell}`);
+  }
+  if (options.uninstall) {
+    logger_default.info(`Removing ${shell} integration...`);
+    await uninstallShellIntegration(shell, home);
+    logger_default.success("Shell integration removed.");
+    logger_default.dim("Restart your terminal for changes to take effect.");
+    logger_default.blank();
+    return;
+  }
+  const isLoggedIn = await checkLoginStatus();
+  logger_default.info(`Setting up ${shell} integration...`);
+  logger_default.blank();
+  await installShellIntegration(shell, home, dataDir);
+  logger_default.blank();
+  logger_default.success("Shell integration installed!");
+  logger_default.blank();
+  if (!isLoggedIn) {
+    logger_default.warn("You're not logged in. Commands will be tracked locally only.");
+    logger_default.dim("Run 'skillo login' to enable cloud sync.");
+    logger_default.blank();
+  }
+  logger_default.dim("Restart your terminal or run:");
+  if (shell === "powershell") {
+    logger_default.highlight("  . $PROFILE");
+  } else if (shell === "bash") {
+    logger_default.highlight("  source ~/.bashrc");
+  } else if (shell === "zsh") {
+    logger_default.highlight("  source ~/.zshrc");
+  } else if (shell === "fish") {
+    logger_default.highlight("  source ~/.config/fish/config.fish");
+  }
+  logger_default.blank();
+  if (isLoggedIn) {
+    logger_default.dim("All commands you run will now be tracked and synced to Skillo.");
+  } else {
+    logger_default.dim("All commands will be tracked locally. Login to sync to Skillo.");
+  }
+  logger_default.blank();
+});
+function generatePosixSyncStatusLines() {
+  return [
+    "# Show sync status on startup (respects SKILLO_CONFIG_DIR and XDG_CONFIG_HOME)",
+    'if [ -n "$SKILLO_CONFIG_DIR" ]; then',
+    '    _skillo_config="$SKILLO_CONFIG_DIR/config.yaml"',
+    'elif [ -n "$XDG_CONFIG_HOME" ]; then',
+    '    _skillo_config="$XDG_CONFIG_HOME/skillo/config.yaml"',
+    "else",
+    '    _skillo_config="$HOME/.config/skillo/config.yaml"',
+    "fi",
+    'if [ -f "$_skillo_config" ] && grep -q "api_key:" "$_skillo_config" 2>/dev/null; then',
+    '    echo -e "\\033[90mSkillo: Command tracking enabled (syncing to platform)\\033[0m"',
+    "else",
+    `    echo -e "\\033[33mSkillo: Command tracking enabled (local only \u2014 run 'skillo login' to sync)\\033[0m"`,
+    "fi"
+  ];
+}
+async function installShellIntegration(shell, home, dataDir) {
+  const scriptPath = join(dataDir, "shell-integration");
+  ensureDirectory(scriptPath);
+  if (shell === "powershell") {
+    const psScript = `# Skillo CLI Integration
+# Records commands to Skillo platform
+# Works in two modes:
+# 1. Platform mode: Uses SKILLO_SESSION and SKILLO_USER_ID env vars (set by platform launch)
+# 2. Standalone mode: Uses skillo CLI which handles auth via API key
+
+$Global:SkilloLastHistoryId = 0
+$Global:SkilloStandaloneSessionId = $null
+$Global:SkilloSessionStartTime = $null
+
+# Check if launched from platform (has session/user env vars) or standalone
+$Global:SkilloPlatformMode = $false
+if ($env:SKILLO_SESSION -and $env:SKILLO_USER_ID) {
+    $Global:SkilloPlatformMode = $true
+    $Global:SkilloSessionId = $env:SKILLO_SESSION
+    $Global:SkilloUserId = $env:SKILLO_USER_ID
+    $Global:SkilloBaseUrl = if ($env:SKILLO_API_URL) { $env:SKILLO_API_URL } else { 'http://localhost:3000' }
+}
+
+function Send-SkilloCommandPlatform {
+    param($Command, $Duration, $ExitCode, $Cwd)
+
+    try {
+        $body = @{
+            type = 'commands'
+            data = @(@{
+                timestamp = (Get-Date).ToString('o')
+                command = $Command
+                normalized = $Command
+                cwd = $Cwd
+                exitCode = $ExitCode
+                durationMs = $Duration
+                sessionId = $Global:SkilloSessionId
+            })
+        } | ConvertTo-Json -Depth 3 -Compress
+
+        $uri = "$($Global:SkilloBaseUrl)/api/cli/sync"
+
+        $webRequest = [System.Net.HttpWebRequest]::Create($uri)
+        $webRequest.Method = 'POST'
+        $webRequest.ContentType = 'application/json'
+        $webRequest.Headers.Add('x-skillo-session', $Global:SkilloSessionId)
+        $webRequest.Headers.Add('x-skillo-user-id', $Global:SkilloUserId)
+        $webRequest.Timeout = 5000
+
+        $bytes = [System.Text.Encoding]::UTF8.GetBytes($body)
+        $webRequest.ContentLength = $bytes.Length
+        $stream = $webRequest.GetRequestStream()
+        $stream.Write($bytes, 0, $bytes.Length)
+        $stream.Close()
+
+        $response = $webRequest.GetResponse()
+        $response.Close()
+    } catch {
+        # Silently ignore errors
+    }
+}
+
+function Send-SkilloCommandCLI {
+    param($Command, $Duration, $ExitCode, $Cwd)
+
+    # Create session on first command if not exists
+    if (-not $Global:SkilloStandaloneSessionId) {
+        $Global:SkilloSessionStartTime = (Get-Date).ToString('o')
+        try {
+            $result = & skillo session start --shell "PowerShell" 2>$null
+            if ($result -match 'Session ID: ([a-f0-9-]+)') {
+                $Global:SkilloStandaloneSessionId = $Matches[1]
+                # Write PID file for session cleanup
+                $_pidDir = Join-Path (Join-Path $env:USERPROFILE '.skillo') 'active-sessions'
+                if (-not (Test-Path $_pidDir)) { New-Item -ItemType Directory -Path $_pidDir -Force | Out-Null }
+                $_json = '{"sessionId":"' + $Global:SkilloStandaloneSessionId + '","pid":' + $PID + '}'
+                [IO.File]::WriteAllText((Join-Path $_pidDir "$PID.json"), $_json)
+            }
+        } catch {
+            # If session command doesn't exist, generate a local ID
+            $Global:SkilloStandaloneSessionId = [guid]::NewGuid().ToString()
+        }
+    }
+
+    # Run skillo record in background with session ID
+    Start-Job -ScriptBlock {
+        param($cmd, $cwd, $exit, $dur, $sessionId)
+        & skillo record $cmd --cwd $cwd --exit-code $exit --duration $dur --session $sessionId 2>$null
+    } -ArgumentList $Command, $Cwd, $ExitCode, $Duration, $Global:SkilloStandaloneSessionId | Out-Null
+}
+
+# Override prompt to capture commands after execution
+$Global:SkilloOriginalPrompt = $function:prompt
+function Global:prompt {
+    $lastCmd = Get-History -Count 1 -ErrorAction SilentlyContinue
+
+    if ($lastCmd -and $lastCmd.Id -gt $Global:SkilloLastHistoryId) {
+        $Global:SkilloLastHistoryId = $lastCmd.Id
+
+        $duration = 0
+        if ($lastCmd.EndExecutionTime -and $lastCmd.StartExecutionTime) {
+            $duration = [int]($lastCmd.EndExecutionTime - $lastCmd.StartExecutionTime).TotalMilliseconds
+        }
+        $exit = if ($null -eq $LASTEXITCODE) { 0 } else { $LASTEXITCODE }
+        $cwd = (Get-Location).Path
+
+        if ($Global:SkilloPlatformMode) {
+            Send-SkilloCommandPlatform -Command $lastCmd.CommandLine -Duration $duration -ExitCode $exit -Cwd $cwd
+        } else {
+            Send-SkilloCommandCLI -Command $lastCmd.CommandLine -Duration $duration -ExitCode $exit -Cwd $cwd
+        }
+    }
+
+    & $Global:SkilloOriginalPrompt
+}
+
+# Register exit handler to end session when terminal closes
+$null = Register-EngineEvent -SourceIdentifier PowerShell.Exiting -Action {
+    if ($Global:SkilloPlatformMode -and $Global:SkilloSessionId) {
+        # End platform session
+        try {
+            $body = @{ sessionId = $Global:SkilloSessionId } | ConvertTo-Json -Compress
+            $uri = "$($Global:SkilloBaseUrl)/api/sessions"
+
+            $webRequest = [System.Net.HttpWebRequest]::Create($uri)
+            $webRequest.Method = 'PATCH'
+            $webRequest.ContentType = 'application/json'
+            $webRequest.Headers.Add('x-skillo-session', $Global:SkilloSessionId)
+            $webRequest.Headers.Add('x-skillo-user-id', $Global:SkilloUserId)
+            $webRequest.Timeout = 3000
+
+            $bytes = [System.Text.Encoding]::UTF8.GetBytes($body)
+            $webRequest.ContentLength = $bytes.Length
+            $stream = $webRequest.GetRequestStream()
+            $stream.Write($bytes, 0, $bytes.Length)
+            $stream.Close()
+
+            $response = $webRequest.GetResponse()
+            $response.Close()
+        } catch {
+            # Ignore errors on exit
+        }
+    } elseif ($Global:SkilloStandaloneSessionId) {
+        # End standalone session via CLI
+        try {
+            & skillo session end --session $Global:SkilloStandaloneSessionId 2>$null
+        } catch {
+            # Ignore errors on exit
+        }
+        # Clean up PID file
+        $_pidFile = Join-Path (Join-Path (Join-Path $env:USERPROFILE '.skillo') 'active-sessions') "$PID.json"
+        if (Test-Path $_pidFile) { Remove-Item $_pidFile -Force -ErrorAction SilentlyContinue }
+    }
+}
+
+# Show sync status on startup
+if ($Global:SkilloPlatformMode) {
+    Write-Host "Skillo: Command tracking enabled (syncing to platform)" -ForegroundColor DarkGray
+} else {
+    # Check if logged in by looking for api_key in config (respects SKILLO_CONFIG_DIR and XDG_CONFIG_HOME)
+    if ($env:SKILLO_CONFIG_DIR) {
+        $skilloConfigPath = Join-Path $env:SKILLO_CONFIG_DIR "config.yaml"
+    } elseif ($env:XDG_CONFIG_HOME) {
+        $skilloConfigPath = Join-Path $env:XDG_CONFIG_HOME "skillo" "config.yaml"
+    } else {
+        $skilloConfigPath = Join-Path $HOME ".config" "skillo" "config.yaml"
+    }
+    $skilloLoggedIn = $false
+    if (Test-Path $skilloConfigPath) {
+        $skilloLoggedIn = (Select-String -Path $skilloConfigPath -Pattern "api_key:" -Quiet) -eq $true
+    }
+    if ($skilloLoggedIn) {
+        Write-Host "Skillo: Command tracking enabled (syncing to platform)" -ForegroundColor DarkGray
+    } else {
+        Write-Host "Skillo: Command tracking enabled (local only - run 'skillo login' to sync)" -ForegroundColor Yellow
+    }
+}
+`;
+    const psScriptFile = join(scriptPath, "skillo.ps1");
+    writeFileSync(psScriptFile, psScript, "utf-8");
+    logger_default.success(`Created ${psScriptFile}`);
+    const profilePath = join(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
+    const profileDir = join(home, "Documents", "WindowsPowerShell");
+    ensureDirectory(profileDir);
+    const sourceLine = `
+# Skillo CLI Integration
+. "${psScriptFile}"
+`;
+    if (existsSync(profilePath)) {
+      const content = readFileSync(profilePath, "utf-8");
+      if (!content.includes("Skillo CLI Integration")) {
+        appendFileSync(profilePath, sourceLine);
+        logger_default.success("Added to PowerShell profile");
+      } else {
+        logger_default.dim("Already in PowerShell profile");
+      }
+    } else {
+      writeFileSync(profilePath, sourceLine, "utf-8");
+      logger_default.success("Created PowerShell profile");
+    }
+  } else if (shell === "bash") {
+    const bashScript = [
+      "# Skillo CLI Integration",
+      "# Records commands and auto-detects tracked projects",
+      "",
+      '_skillo_session="${SKILLO_SESSION:-default}"',
+      "_skillo_last_cwd=",
+      "",
+      "_skillo_preexec() {",
+      '    _skillo_cmd="$1"',
+      "    _skillo_start_time=$(date +%s)",
+      "}",
+      "",
+      "_skillo_check_project() {",
+      "    # Fast path: skip if CWD unchanged",
+      '    if [ "$PWD" = "$_skillo_last_cwd" ]; then',
+      "        return",
+      "    fi",
+      '    _skillo_last_cwd="$PWD"',
+      "",
+      "    # Run session-auto (handles create/end via cache file)",
+      "    local result _pid",
+      "    _pid=$(cat /proc/$$/winpid 2>/dev/null || echo $$)",
+      '    result=$(skillo session-auto "$PWD" --pid $_pid --shell bash 2>/dev/null)',
+      '    if [ -n "$result" ]; then',
+      '        export SKILLO_SESSION="$result"',
+      '        _skillo_session="$result"',
+      "    fi",
+      "}",
+      "",
+      "_skillo_precmd() {",
+      "    local exit_code=$?",
+      "",
+      "    # Check for project change",
+      "    _skillo_check_project",
+      "",
+      '    if [ -n "$_skillo_cmd" ]; then',
+      "        local duration=0",
+      '        if [ -n "$_skillo_start_time" ]; then',
+      "            local end_time=$(date +%s)",
+      "            duration=$(( (end_time - _skillo_start_time) * 1000 ))",
+      "        fi",
+      '        (skillo record "$_skillo_cmd" --cwd "$PWD" --exit-code "$exit_code" --duration "$duration" --session "$_skillo_session" >/dev/null &)',
+      '        _skillo_cmd=""',
+      "    fi",
+      "}",
+      "",
+      "# Clean up session on terminal exit",
+      "_skillo_cleanup() {",
+      '    if [ -n "$SKILLO_SESSION" ] && [ "$SKILLO_SESSION" != "default" ]; then',
+      '        skillo session end --session "$SKILLO_SESSION" >/dev/null 2>&1',
+      "    fi",
+      "}",
+      "trap _skillo_cleanup EXIT",
+      "",
+      "# Use DEBUG trap for preexec",
+      `trap '_skillo_preexec "$BASH_COMMAND"' DEBUG`,
+      "",
+      "# Add precmd to PROMPT_COMMAND",
+      'if [[ ! "$PROMPT_COMMAND" =~ _skillo_precmd ]]; then',
+      '    PROMPT_COMMAND="_skillo_precmd${PROMPT_COMMAND:+;$PROMPT_COMMAND}"',
+      "fi",
+      "",
+      "# Initial project check",
+      "_skillo_check_project",
+      "",
+      ...generatePosixSyncStatusLines()
+    ].join("\n");
+    const bashScriptFile = join(scriptPath, "skillo.bash");
+    writeFileSync(bashScriptFile, bashScript, "utf-8");
+    logger_default.success(`Created ${bashScriptFile}`);
+    const bashrcPath = join(home, ".bashrc");
+    const sourceLine = `
+# Skillo CLI Integration
+[ -f "${bashScriptFile}" ] && source "${bashScriptFile}"
+`;
+    if (existsSync(bashrcPath)) {
+      const content = readFileSync(bashrcPath, "utf-8");
+      if (!content.includes("Skillo CLI Integration")) {
+        appendFileSync(bashrcPath, sourceLine);
+        logger_default.success("Added to ~/.bashrc");
+      } else {
+        logger_default.dim("Already in ~/.bashrc");
+      }
+    } else {
+      writeFileSync(bashrcPath, sourceLine, "utf-8");
+      logger_default.success("Created ~/.bashrc");
+    }
+  } else if (shell === "zsh") {
+    const zshScript = [
+      "# Skillo CLI Integration",
+      "# Records commands and auto-detects tracked projects",
+      "",
+      '_skillo_session="${SKILLO_SESSION:-default}"',
+      "_skillo_last_cwd=",
+      "",
+      "_skillo_preexec() {",
+      '    _skillo_cmd="$1"',
+      "    _skillo_start_time=$(date +%s)",
+      "}",
+      "",
+      "_skillo_check_project() {",
+      "    # Fast path: skip if CWD unchanged",
+      '    if [[ "$PWD" == "$_skillo_last_cwd" ]]; then',
+      "        return",
+      "    fi",
+      '    _skillo_last_cwd="$PWD"',
+      "",
+      "    # Run session-auto (handles create/end via cache file)",
+      "    local result _pid",
+      "    _pid=$(cat /proc/$$/winpid 2>/dev/null || echo $$)",
+      '    result=$(skillo session-auto "$PWD" --pid $_pid --shell zsh 2>/dev/null)',
+      '    if [[ -n "$result" ]]; then',
+      '        export SKILLO_SESSION="$result"',
+      '        _skillo_session="$result"',
+      "    fi",
+      "}",
+      "",
+      "_skillo_precmd() {",
+      "    local exit_code=$?",
+      "",
+      "    # Check for project change",
+      "    _skillo_check_project",
+      "",
+      '    if [[ -n "$_skillo_cmd" ]]; then',
+      "        local duration=0",
+      '        if [[ -n "$_skillo_start_time" ]]; then',
+      "            local end_time=$(date +%s)",
+      "            duration=$(( (end_time - _skillo_start_time) * 1000 ))",
+      "        fi",
+      '        (skillo record "$_skillo_cmd" --cwd "$PWD" --exit-code "$exit_code" --duration "$duration" --session "$_skillo_session" >/dev/null &)',
+      '        _skillo_cmd=""',
+      "    fi",
+      "}",
+      "",
+      "# Clean up session on terminal exit",
+      "_skillo_cleanup() {",
+      '    if [[ -n "$SKILLO_SESSION" ]] && [[ "$SKILLO_SESSION" != "default" ]]; then',
+      '        skillo session end --session "$SKILLO_SESSION" >/dev/null 2>&1',
+      "    fi",
+      "}",
+      "trap _skillo_cleanup EXIT",
+      "",
+      "autoload -Uz add-zsh-hook",
+      "add-zsh-hook preexec _skillo_preexec",
+      "add-zsh-hook precmd _skillo_precmd",
+      "",
+      "# Initial project check",
+      "_skillo_check_project",
+      "",
+      ...generatePosixSyncStatusLines()
+    ].join("\n");
+    const zshScriptFile = join(scriptPath, "skillo.zsh");
+    writeFileSync(zshScriptFile, zshScript, "utf-8");
+    logger_default.success(`Created ${zshScriptFile}`);
+    const zshrcPath = join(home, ".zshrc");
+    const sourceLine = `
+# Skillo CLI Integration
+[ -f "${zshScriptFile}" ] && source "${zshScriptFile}"
+`;
+    if (existsSync(zshrcPath)) {
+      const content = readFileSync(zshrcPath, "utf-8");
+      if (!content.includes("Skillo CLI Integration")) {
+        appendFileSync(zshrcPath, sourceLine);
+        logger_default.success("Added to ~/.zshrc");
+      } else {
+        logger_default.dim("Already in ~/.zshrc");
+      }
+    } else {
+      writeFileSync(zshrcPath, sourceLine, "utf-8");
+      logger_default.success("Created ~/.zshrc");
+    }
+  } else if (shell === "fish") {
+    const fishScript = [
+      "# Skillo CLI Integration",
+      "# Records commands to Skillo platform",
+      "",
+      'set -q SKILLO_SESSION; or set -g SKILLO_SESSION "default"',
+      "",
+      "function _skillo_postexec --on-event fish_postexec",
+      "    set -l cmd $argv[1]",
+      "    set -l exit_code $status",
+      '    skillo record "$cmd" --cwd (pwd) --exit-code $exit_code --session $SKILLO_SESSION >/dev/null &',
+      "end",
+      "",
+      "# Show sync status on startup (respects SKILLO_CONFIG_DIR and XDG_CONFIG_HOME)",
+      "if set -q SKILLO_CONFIG_DIR",
+      '    set _skillo_config "$SKILLO_CONFIG_DIR/config.yaml"',
+      "else if set -q XDG_CONFIG_HOME",
+      '    set _skillo_config "$XDG_CONFIG_HOME/skillo/config.yaml"',
+      "else",
+      '    set _skillo_config "$HOME/.config/skillo/config.yaml"',
+      "end",
+      'if test -f "$_skillo_config"; and grep -q "api_key:" "$_skillo_config" 2>/dev/null',
+      '    echo -e "\\033[90mSkillo: Command tracking enabled (syncing to platform)\\033[0m"',
+      "else",
+      `    echo -e "\\033[33mSkillo: Command tracking enabled (local only \u2014 run 'skillo login' to sync)\\033[0m"`,
+      "end"
+    ].join("\n");
+    const fishScriptFile = join(scriptPath, "skillo.fish");
+    writeFileSync(fishScriptFile, fishScript, "utf-8");
+    logger_default.success(`Created ${fishScriptFile}`);
+    const fishConfigDir = join(home, ".config", "fish");
+    ensureDirectory(fishConfigDir);
+    const fishConfigPath = join(fishConfigDir, "config.fish");
+    const sourceLine = `
+# Skillo CLI Integration
+if test -f "${fishScriptFile}"
+    source "${fishScriptFile}"
+end
+`;
+    if (existsSync(fishConfigPath)) {
+      const content = readFileSync(fishConfigPath, "utf-8");
+      if (!content.includes("Skillo CLI Integration")) {
+        appendFileSync(fishConfigPath, sourceLine);
+        logger_default.success("Added to ~/.config/fish/config.fish");
+      } else {
+        logger_default.dim("Already in fish config");
+      }
+    } else {
+      writeFileSync(fishConfigPath, sourceLine, "utf-8");
+      logger_default.success("Created fish config");
+    }
+  }
+}
+async function uninstallShellIntegration(shell, home) {
+  const removeFromFile = (filePath) => {
+    if (!existsSync(filePath)) return;
+    let content = readFileSync(filePath, "utf-8");
+    content = content.replace(/\n# Skillo CLI Integration\n[^\n]*\n/g, "\n");
+    writeFileSync(filePath, content, "utf-8");
+  };
+  if (shell === "powershell") {
+    const profilePath = join(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
+    removeFromFile(profilePath);
+  } else if (shell === "bash") {
+    removeFromFile(join(home, ".bashrc"));
+  } else if (shell === "zsh") {
+    removeFromFile(join(home, ".zshrc"));
+  } else if (shell === "fish") {
+    removeFromFile(join(home, ".config", "fish", "config.fish"));
+  }
+}
+
+export {
+  shellCommand,
+  recordCommand,
+  setupShellCommand
+};
+//# sourceMappingURL=chunk-U53QWUOR.js.map