openkitt 0.3.3 → 0.3.5

package/dist/cli.js

@@ -2583,9 +2583,12 @@ var exports_config = {};
 __export(exports_config, {
   updateLlmModel: () => updateLlmModel,
   storeLlmCredentials: () => storeLlmCredentials,
+  storeCopilotCredentials: () => storeCopilotCredentials,
   isLlmConfigured: () => isLlmConfigured,
   getLlmConfig: () => getLlmConfig,
   getLlmApiKey: () => getLlmApiKey,
+  getCopilotToken: () => getCopilotToken,
+  exchangeCopilotToken: () => exchangeCopilotToken,
   clearLlmCredentials: () => clearLlmCredentials
 });
 import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, statSync as statSync2, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
@@ -2656,7 +2659,10 @@ function writeConfig(config) {
   }
 }
 function isStoredProvider(value) {
-  return value === "anthropic" || value === "openai" || value === "gemini";
+  return value === "anthropic" || value === "openai" || value === "gemini" || value === "github-copilot";
+}
+function isStoredAuthType(value) {
+  return value === "api-key" || value === "github-copilot";
 }
 function getStoredLlm(config) {
   const llm = config.llm;
@@ -2675,6 +2681,17 @@ function getStoredLlm(config) {
   if (llm.storage !== "keychain" && llm.storage !== "encrypted") {
     return null;
   }
+  if (llm.provider === "github-copilot" && llm.authType === "github-copilot") {
+    const c = llm;
+    if (typeof c.githubToken !== "string" || typeof c.githubIv !== "string" || typeof c.githubSalt !== "string" || typeof c.githubAuthTag !== "string" || typeof c.copilotToken !== "string" || typeof c.copilotIv !== "string" || typeof c.copilotSalt !== "string" || typeof c.copilotAuthTag !== "string" || typeof c.copilotTokenExpiresAt !== "number") {
+      return null;
+    }
+    return c;
+  }
+  const authType = llm.authType;
+  if (authType !== undefined && !isStoredAuthType(authType)) {
+    return null;
+  }
   return llm;
 }
 async function storeLlmCredentials(provider, model, apiKey) {
@@ -2688,6 +2705,7 @@ async function storeLlmCredentials(provider, model, apiKey) {
           provider,
           model,
           validatedAt,
+          authType: "api-key",
           storage: "keychain"
         }
       });
@@ -2701,6 +2719,7 @@ async function storeLlmCredentials(provider, model, apiKey) {
       provider,
       model,
       validatedAt,
+      authType: "api-key",
       storage: "encrypted",
       apiKey: encrypted.encrypted,
       iv: encrypted.iv,
@@ -2712,26 +2731,124 @@ async function storeLlmCredentials(provider, model, apiKey) {
 async function getLlmApiKey() {
   const config = readConfig();
   const llm = getStoredLlm(config);
-  if (!llm) {
+  if (!llm || llm.authType === "github-copilot") {
     return null;
   }
   if (llm.storage === "keychain") {
     return getKeychainValue(KEYCHAIN_API_KEY);
   }
-  if (typeof llm.apiKey !== "string" || typeof llm.iv !== "string" || typeof llm.salt !== "string" || typeof llm.authTag !== "string") {
+  const enc = llm;
+  if (typeof enc.apiKey !== "string" || typeof enc.iv !== "string" || typeof enc.salt !== "string" || typeof enc.authTag !== "string") {
     return null;
   }
   try {
     return await decrypt({
-      encrypted: llm.apiKey,
-      iv: llm.iv,
-      salt: llm.salt,
-      authTag: llm.authTag
+      encrypted: enc.apiKey,
+      iv: enc.iv,
+      salt: enc.salt,
+      authTag: enc.authTag
     });
   } catch {
     return null;
   }
 }
+async function storeCopilotCredentials(model, githubToken, copilotToken, copilotTokenExpiresAt) {
+  const validatedAt = new Date().toISOString();
+  const [encGithub, encCopilot] = await Promise.all([
+    encrypt(githubToken),
+    encrypt(copilotToken)
+  ]);
+  writeConfig({
+    llm: {
+      provider: "github-copilot",
+      model,
+      validatedAt,
+      authType: "github-copilot",
+      storage: "encrypted",
+      githubToken: encGithub.encrypted,
+      githubIv: encGithub.iv,
+      githubSalt: encGithub.salt,
+      githubAuthTag: encGithub.authTag,
+      copilotToken: encCopilot.encrypted,
+      copilotIv: encCopilot.iv,
+      copilotSalt: encCopilot.salt,
+      copilotAuthTag: encCopilot.authTag,
+      copilotTokenExpiresAt
+    }
+  });
+}
+async function decryptCopilotStored(stored) {
+  try {
+    const [githubToken, copilotToken] = await Promise.all([
+      decrypt({ encrypted: stored.githubToken, iv: stored.githubIv, salt: stored.githubSalt, authTag: stored.githubAuthTag }),
+      decrypt({ encrypted: stored.copilotToken, iv: stored.copilotIv, salt: stored.copilotSalt, authTag: stored.copilotAuthTag })
+    ]);
+    return { githubToken, copilotToken };
+  } catch {
+    return null;
+  }
+}
+async function refreshCopilotToken(githubToken) {
+  let res;
+  try {
+    res = await fetch(COPILOT_TOKEN_URL, {
+      headers: {
+        Authorization: `token ${githubToken}`,
+        "User-Agent": "GithubCopilot/1.250.0",
+        "Editor-Version": "vscode/1.95.0",
+        "Editor-Plugin-Version": "copilot/1.250.0",
+        "X-GitHub-Api-Version": "2025-04-01",
+        Accept: "application/json"
+      }
+    });
+  } catch (err) {
+    throw new Error(`Copilot token exchange failed: network error — ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Copilot token exchange failed (HTTP ${res.status}): ${body.slice(0, 300)}`);
+  }
+  const data = await res.json();
+  if (typeof data.token !== "string" || typeof data.expires_at !== "number") {
+    throw new Error("Copilot token exchange failed: unexpected response shape");
+  }
+  return { token: data.token, expiresAt: data.expires_at * 1000 };
+}
+async function getCopilotToken() {
+  const config = readConfig();
+  const llm = getStoredLlm(config);
+  if (!llm || llm.authType !== "github-copilot") {
+    return null;
+  }
+  const stored = llm;
+  const decrypted = await decryptCopilotStored(stored);
+  if (!decrypted)
+    return null;
+  if (Date.now() < stored.copilotTokenExpiresAt - 60000) {
+    return decrypted.copilotToken;
+  }
+  let refreshed;
+  try {
+    refreshed = await refreshCopilotToken(decrypted.githubToken);
+  } catch {
+    return null;
+  }
+  const encCopilot = await encrypt(refreshed.token);
+  writeConfig({
+    llm: {
+      ...stored,
+      copilotToken: encCopilot.encrypted,
+      copilotIv: encCopilot.iv,
+      copilotSalt: encCopilot.salt,
+      copilotAuthTag: encCopilot.authTag,
+      copilotTokenExpiresAt: refreshed.expiresAt
+    }
+  });
+  return refreshed.token;
+}
+async function exchangeCopilotToken(githubToken) {
+  return refreshCopilotToken(githubToken);
+}
 async function getLlmConfig() {
   const config = readConfig();
   const llm = getStoredLlm(config);
@@ -2741,7 +2858,8 @@ async function getLlmConfig() {
   return {
     provider: llm.provider,
     model: llm.model,
-    validatedAt: llm.validatedAt
+    validatedAt: llm.validatedAt,
+    authType: llm.authType ?? "api-key"
   };
 }
 async function updateLlmModel(model) {
@@ -2769,10 +2887,17 @@ async function clearLlmCredentials() {
   writeConfig(nextConfig);
 }
 async function isLlmConfigured() {
-  const [apiKey, llmConfig] = await Promise.all([getLlmApiKey(), getLlmConfig()]);
-  return apiKey !== null && llmConfig !== null;
+  const llmConfig = await getLlmConfig();
+  if (!llmConfig)
+    return false;
+  if (llmConfig.authType === "github-copilot") {
+    const token = await getCopilotToken();
+    return token !== null;
+  }
+  const apiKey = await getLlmApiKey();
+  return apiKey !== null;
 }
-var CONFIG_DIR, CONFIG_FILE, KEYCHAIN_API_KEY = "llm-api-key", DIR_MODE = 448, FILE_MODE = 384;
+var CONFIG_DIR, CONFIG_FILE, KEYCHAIN_API_KEY = "llm-api-key", DIR_MODE = 448, FILE_MODE = 384, COPILOT_TOKEN_URL = "https://api.github.com/copilot_internal/v2/token";
 var init_config = __esm(() => {
   init_encryption();
   init_keychain();
@@ -255595,9 +255720,9 @@ var {
 var import_picocolors12 = __toESM(require_picocolors(), 1);
 import { createInterface, emitKeypressEvents } from "node:readline";
 import { stdin as input, stdout as output } from "node:process";
-import { existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync15, realpathSync } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { join as join23, resolve as resolve6, dirname as dirname5 } from "node:path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync11, readFileSync as readFileSync15, writeFileSync as writeFileSync15, realpathSync } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join24, resolve as resolve6, dirname as dirname5 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/utils/prerequisites.ts
@@ -257758,11 +257883,36 @@ function createGeminiClient(Provider, apiKey, model, rateLimiter) {
     }
   };
 }
+var COPILOT_BASE_URL = "https://api.githubcopilot.com";
+var COPILOT_HEADERS = {
+  "Editor-Version": "vscode/1.85.0",
+  "Editor-Plugin-Version": "copilot-chat/0.26.7",
+  "Copilot-Integration-Id": "vscode-chat"
+};
+async function createCopilotClient(bearerToken, model, rateLimiter) {
+  const OpenAI2 = (await Promise.resolve().then(() => (init_openai(), exports_openai))).default;
+  const CopilotProvider = function(options) {
+    return new OpenAI2({
+      apiKey: options.apiKey,
+      baseURL: COPILOT_BASE_URL,
+      defaultHeaders: COPILOT_HEADERS
+    });
+  };
+  return createOpenAiClient(CopilotProvider, bearerToken, model, rateLimiter);
+}
 async function createLlmClient(rateLimiter) {
-  const [llmConfig, apiKey] = await Promise.all([getLlmConfig(), getLlmApiKey()]);
+  const llmConfig = await getLlmConfig();
   if (!llmConfig) {
     throw new Error("LLM provider is not configured. Run /login llm to configure it.");
   }
+  if (llmConfig.provider === "github-copilot") {
+    const copilotToken = await getCopilotToken();
+    if (!copilotToken) {
+      throw new Error("GitHub Copilot token unavailable. Run /login llm to re-authenticate.");
+    }
+    return await createCopilotClient(copilotToken, llmConfig.model, rateLimiter);
+  }
+  const apiKey = await getLlmApiKey();
   if (!apiKey) {
     throw new Error("LLM API key is not configured. Run /login llm to configure it.");
   }
@@ -264918,6 +265068,9 @@ async function statusCommand(_context, _args, _commandKey) {
 }
 
 // src/commands/login.ts
+import { existsSync as existsSync19, readFileSync as readFileSync13 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join22 } from "node:path";
 init_config();
 var import_picocolors8 = __toESM(require_picocolors(), 1);
 var PROVIDER_LABELS = {
@@ -264948,10 +265101,23 @@ var MODEL_OPTIONS = {
     { value: "gemini-1.5-pro", label: "gemini-1.5-pro" }
   ]
 };
+var COPILOT_MODEL_OPTIONS = [
+  { value: "claude-sonnet-4", label: "claude-sonnet-4    (recommended — Claude via Copilot)" },
+  { value: "gpt-4o", label: "gpt-4o             (GPT-4o via Copilot)" },
+  { value: "gpt-4.1", label: "gpt-4.1            (GPT-4.1 via Copilot)" },
+  { value: "o4-mini", label: "o4-mini            (o4-mini via Copilot)" },
+  { value: "gemini-2.5-pro", label: "gemini-2.5-pro     (Gemini 2.5 Pro via Copilot)" }
+];
+var GITHUB_DEVICE_CLIENT_ID = "Iv1.b507a08c87ecfe98";
 function cancelled() {
   console.log(import_picocolors8.default.yellow("Cancelled."));
   return true;
 }
+function providerLabel(config) {
+  if (config.authType === "github-copilot")
+    return "GitHub Copilot";
+  return PROVIDER_LABELS[config.provider] ?? config.provider;
+}
 async function runRailwayLogin() {
   const status = await checkRailwayAuth();
   if (status.authenticated) {
@@ -264972,6 +265138,20 @@ async function runRailwayLogin() {
   }
   console.log(import_picocolors8.default.red(loginStatus.error ?? "Failed to authenticate with Railway."));
 }
+async function promptAuthMode() {
+  const mode = await ve({
+    message: "How do you want to connect to an LLM?",
+    options: [
+      { value: "api-key", label: "API Key          (Anthropic, OpenAI, or Gemini — pay per token)" },
+      { value: "github-copilot", label: "GitHub Copilot   (use your Copilot subscription — Claude, GPT, Gemini included)" }
+    ]
+  });
+  if (pD(mode)) {
+    cancelled();
+    return null;
+  }
+  return mode;
+}
 async function promptProvider() {
   const provider = await ve({
     message: "Select LLM provider:",
@@ -264994,14 +265174,105 @@ async function promptModel(provider) {
   }
   return model;
 }
-async function runLlmLogin(context) {
+function readGhCliToken() {
+  try {
+    const hostsFile = join22(homedir5(), ".config", "gh", "hosts.yml");
+    if (!existsSync19(hostsFile))
+      return null;
+    const raw = readFileSync13(hostsFile, "utf-8");
+    for (const line of raw.split(`
+`)) {
+      const match = line.match(/^\s*oauth_token:\s*(.+)$/);
+      if (match?.[1]) {
+        return match[1].trim();
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function runGitHubDeviceFlow() {
+  try {
+    const codeRes = await fetch("https://github.com/login/device/code", {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        client_id: GITHUB_DEVICE_CLIENT_ID,
+        scope: "read:user"
+      })
+    });
+    if (!codeRes.ok) {
+      console.log(import_picocolors8.default.red("Failed to start GitHub login. Check your internet connection."));
+      return null;
+    }
+    const codeData = await codeRes.json();
+    console.log();
+    console.log(import_picocolors8.default.bold("GitHub login"));
+    console.log(`Open ${import_picocolors8.default.cyan(codeData.verification_uri)} and enter code: ${import_picocolors8.default.bold(import_picocolors8.default.yellow(codeData.user_code))}`);
+    console.log();
+    try {
+      const openModule = await import("open");
+      await openModule.default(codeData.verification_uri);
+    } catch {}
+    const intervalMs = (codeData.interval ?? 5) * 1000;
+    const expiresAt = Date.now() + (codeData.expires_in ?? 900) * 1000;
+    while (Date.now() < expiresAt) {
+      await new Promise((resolve6) => setTimeout(resolve6, intervalMs));
+      const tokenRes = await fetch("https://github.com/login/oauth/access_token", {
+        method: "POST",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          client_id: GITHUB_DEVICE_CLIENT_ID,
+          device_code: codeData.device_code,
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+        })
+      });
+      if (!tokenRes.ok)
+        continue;
+      const tokenData = await tokenRes.json();
+      if (tokenData.access_token) {
+        return tokenData.access_token;
+      }
+      if (tokenData.error === "authorization_pending") {
+        continue;
+      }
+      if (tokenData.error === "slow_down") {
+        await new Promise((resolve6) => setTimeout(resolve6, intervalMs));
+        continue;
+      }
+      console.log(import_picocolors8.default.red(tokenData.error_description ?? `GitHub login failed: ${tokenData.error}`));
+      return null;
+    }
+    console.log(import_picocolors8.default.red("GitHub login timed out. Run /login llm again to retry."));
+    return null;
+  } catch {
+    console.log(import_picocolors8.default.red("GitHub login failed. Check your internet connection."));
+    return null;
+  }
+}
+async function getGitHubToken() {
+  const ghToken = readGhCliToken();
+  if (ghToken) {
+    console.log(import_picocolors8.default.dim("Using existing GitHub CLI session."));
+    return ghToken;
+  }
+  console.log(import_picocolors8.default.cyan("No GitHub CLI session found. Opening GitHub login in your browser..."));
+  return runGitHubDeviceFlow();
+}
+async function runCopilotLogin(context) {
   const existingConfig = await getLlmConfig();
-  if (existingConfig) {
-    const providerName = PROVIDER_LABELS[existingConfig.provider];
-    console.log(import_picocolors8.default.green(`✓ LLM ${providerName} (${existingConfig.model}) already configured`));
+  if (existingConfig && existingConfig.authType === "github-copilot") {
+    console.log(import_picocolors8.default.green(`✓ GitHub Copilot (${existingConfig.model}) already configured`));
     if (!context.yes) {
       const shouldChange = await ye({
-        message: "Change LLM provider/model/key?",
+        message: "Change Copilot model or re-authenticate?",
         initialValue: false
       });
       if (pD(shouldChange)) {
@@ -265013,14 +265284,60 @@ async function runLlmLogin(context) {
       }
     }
   }
-  const provider = await promptProvider();
-  if (!provider) {
+  const model = await ve({
+    message: "Select model (via GitHub Copilot):",
+    options: COPILOT_MODEL_OPTIONS
+  });
+  if (pD(model)) {
+    cancelled();
     return;
   }
-  const model = await promptModel(provider);
-  if (!model) {
+  const githubToken = await getGitHubToken();
+  if (!githubToken)
+    return;
+  console.log(import_picocolors8.default.dim("Authenticating with GitHub Copilot..."));
+  let copilotResult;
+  try {
+    copilotResult = await exchangeCopilotToken(githubToken);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Unknown error";
+    console.log(import_picocolors8.default.red(`✗ ${msg}`));
+    console.log(import_picocolors8.default.dim("Make sure your GitHub account has an active Copilot Pro, Pro+, Business, or Enterprise subscription."));
     return;
   }
+  await storeCopilotCredentials(model, githubToken, copilotResult.token, copilotResult.expiresAt);
+  console.log(import_picocolors8.default.green(`✓ GitHub Copilot authenticated (${model})`));
+}
+async function runLlmLogin(context) {
+  const existingConfig = await getLlmConfig();
+  if (existingConfig && !context.yes) {
+    const label = providerLabel(existingConfig);
+    console.log(import_picocolors8.default.green(`✓ LLM ${label} (${existingConfig.model}) already configured`));
+    const shouldChange = await ye({
+      message: "Change LLM provider/model/key?",
+      initialValue: false
+    });
+    if (pD(shouldChange)) {
+      cancelled();
+      return;
+    }
+    if (!shouldChange) {
+      return;
+    }
+  }
+  const authMode = await promptAuthMode();
+  if (!authMode)
+    return;
+  if (authMode === "github-copilot") {
+    await runCopilotLogin(context);
+    return;
+  }
+  const provider = await promptProvider();
+  if (!provider)
+    return;
+  const model = await promptModel(provider);
+  if (!model)
+    return;
   const apiKey = await ge({
     message: `Enter your ${PROVIDER_LABELS[provider]} API key:`,
     validate: (value) => {
@@ -265043,10 +265360,23 @@ async function runModelSwitch() {
     console.log(import_picocolors8.default.red("No LLM provider configured. Run /login llm first."));
     return;
   }
-  const model = await promptModel(config.provider);
-  if (!model) {
+  if (config.authType === "github-copilot") {
+    const model2 = await ve({
+      message: "Select model (via GitHub Copilot):",
+      options: COPILOT_MODEL_OPTIONS
+    });
+    if (pD(model2)) {
+      cancelled();
+      return;
+    }
+    await updateLlmModel(model2);
+    console.log(import_picocolors8.default.green(`✓ Copilot model changed to ${model2}`));
     return;
   }
+  const provider = config.provider;
+  const model = await promptModel(provider);
+  if (!model)
+    return;
   await updateLlmModel(model);
   console.log(import_picocolors8.default.green(`✓ LLM model changed to ${model}`));
 }
@@ -265069,7 +265399,8 @@ async function runFullLogin(context) {
   }
   const [llmConfigured, llmConfig] = await Promise.all([isLlmConfigured(), getLlmConfig()]);
   if (llmConfigured && llmConfig) {
-    console.log(import_picocolors8.default.green(`✓ LLM ${PROVIDER_LABELS[llmConfig.provider]} (${llmConfig.model})`));
+    const label = providerLabel(llmConfig);
+    console.log(import_picocolors8.default.green(`✓ LLM ${label} (${llmConfig.model})`));
   } else {
     await runLlmLogin(context);
   }
@@ -265089,7 +265420,8 @@ async function runFullLogin(context) {
     console.log(import_picocolors8.default.yellow("• Railway: not authenticated"));
   }
   if (finalLlmConfigured && finalLlmConfig) {
-    console.log(import_picocolors8.default.green(`✓ LLM: ${PROVIDER_LABELS[finalLlmConfig.provider]} (${finalLlmConfig.model})`));
+    const label = providerLabel(finalLlmConfig);
+    console.log(import_picocolors8.default.green(`✓ LLM: ${label} (${finalLlmConfig.model})`));
   } else {
     console.log(import_picocolors8.default.yellow("• LLM: not configured"));
   }
@@ -265097,7 +265429,7 @@ async function runFullLogin(context) {
 async function runLogout(context) {
   if (!context.yes) {
     const shouldLogout = await ye({
-      message: "This will log out of Railway and remove your stored LLM API key. Continue?",
+      message: "This will log out of Railway and remove your stored LLM credentials. Continue?",
       initialValue: false
     });
     if (pD(shouldLogout)) {
@@ -265115,7 +265447,7 @@ async function runLogout(context) {
   } else {
     console.log(import_picocolors8.default.yellow("• Railway logout skipped or not authenticated"));
   }
-  console.log(import_picocolors8.default.green("✓ LLM key removed"));
+  console.log(import_picocolors8.default.green("✓ LLM credentials removed"));
 }
 async function loginCommand(context, args, commandKey = "login") {
   if (commandKey === "logout") {
@@ -265144,8 +265476,8 @@ async function loginCommand(context, args, commandKey = "login") {
 }
 
 // src/commands/versions.ts
-import { existsSync as existsSync19, readFileSync as readFileSync13, writeFileSync as writeFileSync14 } from "node:fs";
-import { join as join22 } from "node:path";
+import { existsSync as existsSync20, readFileSync as readFileSync14, writeFileSync as writeFileSync14 } from "node:fs";
+import { join as join23 } from "node:path";
 var import_picocolors9 = __toESM(require_picocolors(), 1);
 var TABLE_HEADER_INTEGRATION = "Integration";
 var TABLE_HEADER_VERSION = "Version";
@@ -265188,13 +265520,13 @@ function loadVersionsContext(logger) {
     logger.cmd("/versions", "FAILED", "not a workspace");
     return null;
   }
-  const versionsPath = join22(workspaceDir, "versions.md");
-  if (!existsSync19(versionsPath)) {
+  const versionsPath = join23(workspaceDir, "versions.md");
+  if (!existsSync20(versionsPath)) {
     error("versions.md not found in workspace root.");
     logger.cmd("/versions", "FAILED", "versions.md missing");
     return null;
   }
-  const versionsMarkdown = readFileSync13(versionsPath, "utf-8");
+  const versionsMarkdown = readFileSync14(versionsPath, "utf-8");
   const result = parseVersionsTable(versionsMarkdown);
   for (const parseError of result.errors) {
     warn(parseError);
@@ -265622,7 +265954,7 @@ async function helpCommand(_context, _args) {
 // package.json
 var package_default = {
   name: "openkitt",
-  version: "0.3.3",
+  version: "0.3.5",
   description: "AI-powered monorepo scaffolding CLI",
   keywords: [
     "cli",
@@ -265694,8 +266026,8 @@ var STATE_CHANGING_COMMANDS = new Set([
   "domain",
   "publish"
 ]);
-var KITT_DIR3 = join23(homedir5(), ".kitt");
-var UPDATE_CHECK_FILE = join23(KITT_DIR3, "update-check.json");
+var KITT_DIR3 = join24(homedir6(), ".kitt");
+var UPDATE_CHECK_FILE = join24(KITT_DIR3, "update-check.json");
 var commandRegistry = {
   init: { handler: initCommand },
   create: { handler: createCommand2 },
@@ -265775,11 +266107,11 @@ function isVersionNewer(latest, current) {
   return false;
 }
 function hasFreshUpdateCache(now) {
-  if (!existsSync20(UPDATE_CHECK_FILE)) {
+  if (!existsSync21(UPDATE_CHECK_FILE)) {
     return false;
   }
   try {
-    const rawCache = readFileSync14(UPDATE_CHECK_FILE, "utf-8").trim();
+    const rawCache = readFileSync15(UPDATE_CHECK_FILE, "utf-8").trim();
     if (rawCache.length === 0) {
       return false;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openkitt",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "AI-powered monorepo scaffolding CLI",
   "keywords": [
     "cli",