@promptscript/cli 1.0.0-alpha.6 → 1.0.0-alpha.7

package/index.js

@@ -1,7 +1,7 @@
 // packages/cli/src/cli.ts
 import { Command } from "commander";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname7 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname9 } from "path";
 
 // packages/core/src/types/constants.ts
 var BLOCK_TYPES = [
@@ -306,7 +306,7 @@ var noopLogger = {
 
 // packages/cli/src/commands/init.ts
 import { fileURLToPath } from "url";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname3 } from "path";
 
 // packages/cli/src/services.ts
 import { writeFile, mkdir, readFile, readdir } from "fs/promises";
@@ -1366,9 +1366,410 @@ Before completing migration:
 - No duplicate content across blocks
 `;
 
+// packages/cli/src/utils/manifest-loader.ts
+import { join as join3, dirname as dirname2 } from "path";
+import { parse as parseYaml2 } from "yaml";
+var OFFICIAL_REGISTRY = {
+  name: "PromptScript Official Registry",
+  url: "https://github.com/mrwogu/promptscript-registry.git",
+  branch: "main",
+  manifestUrl: "https://raw.githubusercontent.com/mrwogu/promptscript-registry/main/registry-manifest.yaml"
+};
+var ManifestLoadError = class extends Error {
+  originalCause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "ManifestLoadError";
+    this.originalCause = cause;
+  }
+};
+var manifestCache = /* @__PURE__ */ new Map();
+var MANIFEST_FILENAME = "registry-manifest.yaml";
+async function loadManifest(options = {}, services = createDefaultServices()) {
+  const { registryPath = findDefaultRegistryPath(services), useCache = true } = options;
+  const manifestPath = resolveManifestPath(registryPath, services);
+  if (useCache && manifestCache.has(manifestPath)) {
+    return {
+      manifest: manifestCache.get(manifestPath),
+      path: manifestPath,
+      cached: true
+    };
+  }
+  const manifest = await loadManifestFromPath(manifestPath, services);
+  validateManifest(manifest);
+  if (useCache) {
+    manifestCache.set(manifestPath, manifest);
+  }
+  return {
+    manifest,
+    path: manifestPath,
+    cached: false
+  };
+}
+function findDefaultRegistryPath(services) {
+  const candidates = ["./registry", "../promptscript-registry", "./.promptscript-registry"];
+  for (const candidate of candidates) {
+    const manifestPath = join3(services.cwd, candidate, MANIFEST_FILENAME);
+    if (services.fs.existsSync(manifestPath)) {
+      return candidate;
+    }
+  }
+  return "./registry";
+}
+function resolveManifestPath(registryPath, services) {
+  if (registryPath.endsWith(".yaml") || registryPath.endsWith(".yml")) {
+    return join3(services.cwd, registryPath);
+  }
+  return join3(services.cwd, registryPath, MANIFEST_FILENAME);
+}
+async function loadManifestFromPath(manifestPath, services) {
+  if (!services.fs.existsSync(manifestPath)) {
+    throw new ManifestLoadError(
+      `Registry manifest not found at: ${manifestPath}
+Run \`prs pull\` to fetch the registry or check your registry configuration.`
+    );
+  }
+  try {
+    const content = await services.fs.readFile(manifestPath, "utf-8");
+    const manifest = parseYaml2(content);
+    return manifest;
+  } catch (error) {
+    throw new ManifestLoadError(
+      `Failed to parse manifest: ${manifestPath}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function validateManifest(manifest) {
+  if (!manifest.version) {
+    throw new ManifestLoadError("Manifest missing required field: version");
+  }
+  if (manifest.version !== "1") {
+    throw new ManifestLoadError(`Unsupported manifest version: ${manifest.version}`);
+  }
+  if (!manifest.meta) {
+    throw new ManifestLoadError("Manifest missing required field: meta");
+  }
+  if (!manifest.catalog) {
+    throw new ManifestLoadError("Manifest missing required field: catalog");
+  }
+  if (!Array.isArray(manifest.catalog)) {
+    throw new ManifestLoadError("Manifest catalog must be an array");
+  }
+}
+async function loadManifestFromUrl(url = OFFICIAL_REGISTRY.manifestUrl, useCache = true) {
+  if (useCache && manifestCache.has(url)) {
+    return {
+      manifest: manifestCache.get(url),
+      url,
+      cached: true
+    };
+  }
+  try {
+    const response = await fetch(url, {
+      headers: {
+        Accept: "application/x-yaml, text/yaml, text/plain",
+        "User-Agent": "PromptScript-CLI"
+      }
+    });
+    if (!response.ok) {
+      throw new ManifestLoadError(
+        `Failed to fetch manifest from ${url}: ${response.status} ${response.statusText}`
+      );
+    }
+    const content = await response.text();
+    const manifest = parseYaml2(content);
+    validateManifest(manifest);
+    if (useCache) {
+      manifestCache.set(url, manifest);
+    }
+    return {
+      manifest,
+      url,
+      cached: false
+    };
+  } catch (error) {
+    if (error instanceof ManifestLoadError) {
+      throw error;
+    }
+    throw new ManifestLoadError(
+      `Failed to load manifest from ${url}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function isValidGitUrl(url, allowedHosts) {
+  try {
+    if (url.startsWith("git@")) {
+      const hostMatch = url.match(/^git@([^:]+):/);
+      if (hostMatch && hostMatch[1]) {
+        const host = hostMatch[1];
+        return allowedHosts ? allowedHosts.includes(host) : true;
+      }
+      return false;
+    }
+    if (!url.startsWith("https://") && !url.startsWith("http://")) {
+      return false;
+    }
+    const parsed = new URL(url);
+    if (!parsed.hostname || parsed.hostname.length === 0) {
+      return false;
+    }
+    if (allowedHosts) {
+      return allowedHosts.includes(parsed.hostname);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// packages/cli/src/utils/suggestion-engine.ts
+async function buildProjectContext(projectInfo, services = createDefaultServices()) {
+  const files = await detectProjectFiles(services);
+  const dependencies = await detectDependencies(services);
+  return {
+    files,
+    dependencies,
+    languages: projectInfo.languages,
+    frameworks: projectInfo.frameworks
+  };
+}
+async function detectProjectFiles(services) {
+  const relevantFiles = [
+    "package.json",
+    "tsconfig.json",
+    "pyproject.toml",
+    "requirements.txt",
+    "Cargo.toml",
+    "go.mod",
+    "pom.xml",
+    "build.gradle",
+    ".git",
+    ".env",
+    ".env.example",
+    "jest.config.js",
+    "vitest.config.ts",
+    "vitest.config.js",
+    "pytest.ini",
+    "next.config.js",
+    "next.config.mjs",
+    "next.config.ts",
+    "nuxt.config.js",
+    "nuxt.config.ts",
+    "vite.config.js",
+    "vite.config.ts",
+    "Dockerfile",
+    "docker-compose.yml"
+  ];
+  const existingFiles = [];
+  for (const file of relevantFiles) {
+    if (services.fs.existsSync(file)) {
+      existingFiles.push(file);
+    }
+  }
+  return existingFiles;
+}
+async function detectDependencies(services) {
+  if (!services.fs.existsSync("package.json")) {
+    return [];
+  }
+  try {
+    const content = await services.fs.readFile("package.json", "utf-8");
+    const pkg = JSON.parse(content);
+    return [...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {})];
+  } catch {
+    return [];
+  }
+}
+function calculateSuggestions(manifest, context) {
+  const result = {
+    inherit: void 0,
+    use: [],
+    skills: [],
+    reasoning: []
+  };
+  const suggestedUse = /* @__PURE__ */ new Set();
+  const suggestedSkills = /* @__PURE__ */ new Set();
+  for (const rule of manifest.suggestionRules) {
+    const match = matchCondition(rule.condition, context);
+    if (match.matches) {
+      if (rule.suggest.inherit) {
+        if (!result.inherit) {
+          result.inherit = rule.suggest.inherit;
+          result.reasoning.push({
+            suggestion: `inherit: ${rule.suggest.inherit}`,
+            reason: match.reason,
+            trigger: match.trigger,
+            matchedValue: match.matchedValue
+          });
+        }
+      }
+      if (rule.suggest.use) {
+        for (const useItem of rule.suggest.use) {
+          if (!suggestedUse.has(useItem)) {
+            suggestedUse.add(useItem);
+            result.use.push(useItem);
+            result.reasoning.push({
+              suggestion: `use: ${useItem}`,
+              reason: match.reason,
+              trigger: match.trigger,
+              matchedValue: match.matchedValue
+            });
+          }
+        }
+      }
+      if (rule.suggest.skills) {
+        for (const skill of rule.suggest.skills) {
+          if (!suggestedSkills.has(skill)) {
+            suggestedSkills.add(skill);
+            result.skills.push(skill);
+            result.reasoning.push({
+              suggestion: `skill: ${skill}`,
+              reason: match.reason,
+              trigger: match.trigger,
+              matchedValue: match.matchedValue
+            });
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+function matchCondition(condition, context) {
+  if (condition.always) {
+    return {
+      matches: true,
+      reason: "Default recommendation",
+      trigger: "always"
+    };
+  }
+  if (condition.files) {
+    for (const file of condition.files) {
+      if (context.files.includes(file)) {
+        return {
+          matches: true,
+          reason: `Detected file: ${file}`,
+          trigger: "file",
+          matchedValue: file
+        };
+      }
+    }
+  }
+  if (condition.dependencies) {
+    for (const dep of condition.dependencies) {
+      if (context.dependencies.includes(dep)) {
+        return {
+          matches: true,
+          reason: `Detected dependency: ${dep}`,
+          trigger: "dependency",
+          matchedValue: dep
+        };
+      }
+    }
+  }
+  if (condition.languages) {
+    for (const lang of condition.languages) {
+      if (context.languages.includes(lang)) {
+        return {
+          matches: true,
+          reason: `Detected language: ${lang}`,
+          trigger: "language",
+          matchedValue: lang
+        };
+      }
+    }
+  }
+  if (condition.frameworks) {
+    for (const framework of condition.frameworks) {
+      if (context.frameworks.includes(framework)) {
+        return {
+          matches: true,
+          reason: `Detected framework: ${framework}`,
+          trigger: "framework",
+          matchedValue: framework
+        };
+      }
+    }
+  }
+  return {
+    matches: false,
+    reason: "",
+    trigger: "always"
+  };
+}
+function formatSuggestionResult(result) {
+  const lines = [];
+  if (result.inherit) {
+    lines.push(`\u{1F4E6} Inherit: ${result.inherit}`);
+  }
+  if (result.use.length > 0) {
+    lines.push(`\u{1F527} Use: ${result.use.join(", ")}`);
+  }
+  if (result.skills.length > 0) {
+    lines.push(`\u26A1 Skills: ${result.skills.join(", ")}`);
+  }
+  if (result.reasoning.length > 0) {
+    lines.push("");
+    lines.push("Reasoning:");
+    for (const r of result.reasoning) {
+      lines.push(`  \u2022 ${r.suggestion} (${r.reason})`);
+    }
+  }
+  return lines;
+}
+function createSuggestionChoices(manifest, result) {
+  const choices = [];
+  if (result.inherit) {
+    const entry = manifest.catalog.find((e) => e.id === result.inherit);
+    choices.push({
+      name: `${result.inherit} (inherit)`,
+      value: `inherit:${result.inherit}`,
+      checked: true,
+      description: entry?.description
+    });
+  }
+  for (const use of result.use) {
+    const entry = manifest.catalog.find((e) => e.id === use);
+    choices.push({
+      name: `${use} (use)`,
+      value: `use:${use}`,
+      checked: true,
+      description: entry?.description
+    });
+  }
+  for (const skill of result.skills) {
+    const entry = manifest.catalog.find((e) => e.id === skill);
+    choices.push({
+      name: `${skill} (skill)`,
+      value: `skill:${skill}`,
+      checked: true,
+      description: entry?.description
+    });
+  }
+  return choices;
+}
+function parseSelectedChoices(selected) {
+  const result = {
+    use: [],
+    skills: []
+  };
+  for (const choice of selected) {
+    if (choice.startsWith("inherit:")) {
+      result.inherit = choice.slice("inherit:".length);
+    } else if (choice.startsWith("use:")) {
+      result.use.push(choice.slice("use:".length));
+    } else if (choice.startsWith("skill:")) {
+      result.skills.push(choice.slice("skill:".length));
+    }
+  }
+  return result;
+}
+
 // packages/cli/src/commands/init.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname2(__filename);
+var __dirname = dirname3(__filename);
 async function initCommand(options, services = createDefaultServices()) {
   const { fs: fs4 } = services;
   if (fs4.existsSync("promptscript.yaml") && !options.force) {
@@ -1380,11 +1781,22 @@ async function initCommand(options, services = createDefaultServices()) {
     const projectInfo = await detectProject(services);
     const aiToolsDetection = await detectAITools(services);
     const prettierConfigPath = findPrettierConfig(process.cwd());
+    let manifest;
+    try {
+      const registryPath = options.registry ?? "./registry";
+      const { manifest: loadedManifest } = await loadManifest({ registryPath }, services);
+      manifest = loadedManifest;
+    } catch (error) {
+      if (!(error instanceof ManifestLoadError)) {
+        throw error;
+      }
+    }
     const config = await resolveConfig(
       options,
       projectInfo,
       aiToolsDetection,
       prettierConfigPath,
+      manifest,
       services
     );
     const spinner = createSpinner("Creating PromptScript configuration...").start();
@@ -1440,7 +1852,14 @@ async function initCommand(options, services = createDefaultServices()) {
       ConsoleOutput.muted(`  Inherit: ${config.inherit}`);
     }
     if (config.registry) {
-      ConsoleOutput.muted(`  Registry: ${config.registry}`);
+      if (config.registry.type === "git") {
+        ConsoleOutput.muted(`  Registry: ${config.registry.url} (${config.registry.ref})`);
+      } else {
+        ConsoleOutput.muted(`  Registry: ${config.registry.path} (local)`);
+      }
+    }
+    if (config.use && config.use.length > 0) {
+      ConsoleOutput.muted(`  Use: ${config.use.join(", ")}`);
     }
     ConsoleOutput.newline();
     if (config.prettierConfigPath) {
@@ -1494,23 +1913,46 @@ async function initCommand(options, services = createDefaultServices()) {
     process.exit(1);
   }
 }
-async function resolveConfig(options, projectInfo, aiToolsDetection, prettierConfigPath, services) {
+async function resolveConfig(options, projectInfo, aiToolsDetection, prettierConfigPath, manifest, services) {
   if (options.yes) {
+    let inherit = options.inherit;
+    let use;
+    let activeManifest = manifest;
+    if (!activeManifest) {
+      try {
+        const { manifest: remoteManifest } = await loadManifestFromUrl();
+        activeManifest = remoteManifest;
+      } catch {
+      }
+    }
+    if (activeManifest) {
+      const context = await buildProjectContext(projectInfo, services);
+      const suggestions = calculateSuggestions(activeManifest, context);
+      if (!inherit && suggestions.inherit) {
+        inherit = suggestions.inherit;
+      }
+      if (suggestions.use.length > 0) {
+        use = suggestions.use;
+      }
+    }
+    const registry = options.registry ? { type: "local", path: options.registry } : { type: "git", url: OFFICIAL_REGISTRY.url, ref: OFFICIAL_REGISTRY.branch };
     return {
       projectId: options.name ?? projectInfo.name,
       team: options.team,
-      inherit: options.inherit,
-      registry: options.registry ?? "./registry",
+      inherit,
+      use,
+      registry,
       targets: options.targets ?? getSuggestedTargets(aiToolsDetection),
       prettierConfigPath
     };
   }
   if (!options.interactive && options.name && options.targets) {
+    const registry = options.registry ? { type: "local", path: options.registry } : void 0;
     return {
       projectId: options.name,
       team: options.team,
       inherit: options.inherit,
-      registry: options.registry,
+      registry,
       targets: options.targets,
       prettierConfigPath
     };
@@ -1520,10 +1962,11 @@ async function resolveConfig(options, projectInfo, aiToolsDetection, prettierCon
     projectInfo,
     aiToolsDetection,
     prettierConfigPath,
+    manifest,
     services
   );
 }
-async function runInteractivePrompts(options, projectInfo, aiToolsDetection, prettierConfigPath, services) {
+async function runInteractivePrompts(options, projectInfo, aiToolsDetection, prettierConfigPath, manifest, services) {
   const { prompts: prompts2 } = services;
   ConsoleOutput.newline();
   console.log("\u{1F680} PromptScript Setup");
@@ -1549,33 +1992,124 @@ async function runInteractivePrompts(options, projectInfo, aiToolsDetection, pre
     message: "Project name:",
     default: options.name ?? projectInfo.name
   });
-  const wantsInherit = await prompts2.confirm({
-    message: "Do you want to inherit from a parent configuration?",
-    default: false
+  let registry;
+  let activeManifest = manifest;
+  const registryChoice = await prompts2.select({
+    message: "Registry configuration:",
+    choices: [
+      {
+        name: `\u{1F4E6} Use official PromptScript Registry (${OFFICIAL_REGISTRY.url})`,
+        value: "official"
+      },
+      {
+        name: "\u{1F517} Connect to a custom Git registry",
+        value: "custom-git"
+      },
+      {
+        name: "\u{1F4C1} Use a local registry directory",
+        value: "local"
+      },
+      {
+        name: "\u23ED\uFE0F  Skip registry (configure later)",
+        value: "skip"
+      }
+    ],
+    default: manifest ? "official" : "skip"
   });
-  let inherit;
-  if (wantsInherit) {
-    inherit = await prompts2.input({
-      message: "Inheritance path (e.g., @company/team):",
-      default: options.inherit ?? "@company/team",
+  if (registryChoice === "official") {
+    registry = {
+      type: "git",
+      url: OFFICIAL_REGISTRY.url,
+      ref: OFFICIAL_REGISTRY.branch
+    };
+    if (!activeManifest) {
+      try {
+        ConsoleOutput.muted("Fetching registry manifest...");
+        const { manifest: remoteManifest } = await loadManifestFromUrl();
+        activeManifest = remoteManifest;
+        ConsoleOutput.success(
+          `Loaded ${remoteManifest.catalog.length} configurations from official registry`
+        );
+      } catch {
+        ConsoleOutput.warn("Could not fetch registry manifest - suggestions will be limited");
+      }
+    }
+  } else if (registryChoice === "custom-git") {
+    const gitUrl = await prompts2.input({
+      message: "Git repository URL:",
+      default: "https://github.com/your-org/your-registry.git",
       validate: (value) => {
-        if (!value.startsWith("@")) {
-          return "Inheritance path should start with @";
+        if (!isValidGitUrl(value)) {
+          return "Please enter a valid Git repository URL (https:// or git@)";
         }
         return true;
       }
     });
-  }
-  const wantsRegistry = await prompts2.confirm({
-    message: "Do you want to configure a registry?",
-    default: false
-  });
-  let registry;
-  if (wantsRegistry) {
-    registry = await prompts2.input({
-      message: "Registry path:",
+    const gitRef = await prompts2.input({
+      message: "Branch or tag:",
+      default: "main"
+    });
+    registry = {
+      type: "git",
+      url: gitUrl,
+      ref: gitRef
+    };
+  } else if (registryChoice === "local") {
+    const localPath = await prompts2.input({
+      message: "Local registry path:",
       default: options.registry ?? "./registry"
     });
+    registry = {
+      type: "local",
+      path: localPath
+    };
+  }
+  let inherit = options.inherit;
+  let use;
+  if (activeManifest) {
+    const context = await buildProjectContext(projectInfo, services);
+    const suggestions = calculateSuggestions(activeManifest, context);
+    if (suggestions.inherit || suggestions.use.length > 0) {
+      ConsoleOutput.newline();
+      console.log("\u{1F4E6} Suggested configurations based on your project:");
+      const suggestionLines = formatSuggestionResult(suggestions);
+      for (const line of suggestionLines) {
+        ConsoleOutput.muted(`  ${line}`);
+      }
+      ConsoleOutput.newline();
+      const choices = createSuggestionChoices(activeManifest, suggestions);
+      if (choices.length > 0) {
+        const selected = await prompts2.checkbox({
+          message: "Select configurations to use:",
+          choices: choices.map((c) => ({
+            name: c.description ? `${c.name} - ${c.description}` : c.name,
+            value: c.value,
+            checked: c.checked
+          }))
+        });
+        const parsed = parseSelectedChoices(selected);
+        inherit = parsed.inherit;
+        use = parsed.use.length > 0 ? parsed.use : void 0;
+      }
+    }
+  }
+  if (!inherit) {
+    const wantsInherit = await prompts2.confirm({
+      message: "Do you want to inherit from a parent configuration?",
+      default: false
+    });
+    if (wantsInherit) {
+      inherit = await prompts2.input({
+        message: "Inheritance path (e.g., @stacks/react):",
+        default: options.inherit ?? "@stacks/react",
+        validate: (value) => {
+          if (!value.startsWith("@")) {
+            return "Inheritance path should start with @";
+          }
+          return true;
+        }
+      });
+    }
   }
   const suggestedTargets = getSuggestedTargets(aiToolsDetection);
   const allTargets = getAllTargets();
@@ -1604,6 +2138,7 @@ async function runInteractivePrompts(options, projectInfo, aiToolsDetection, pre
     projectId,
     team,
     inherit,
+    use,
     registry,
     targets,
     prettierConfigPath
@@ -1627,13 +2162,34 @@ function generateConfig(config) {
   if (config.inherit) {
     lines.push(`inherit: '${config.inherit}'`);
   } else {
-    lines.push("# inherit: '@company/team'");
+    lines.push("# inherit: '@stacks/react'");
+  }
+  lines.push("");
+  if (config.use && config.use.length > 0) {
+    lines.push("use:");
+    for (const useItem of config.use) {
+      lines.push(`  - '${useItem}'`);
+    }
+  } else {
+    lines.push("# use:", "#   - '@fragments/testing'", "#   - '@fragments/typescript'");
   }
   lines.push("");
   if (config.registry) {
-    lines.push("registry:", `  path: '${config.registry}'`);
+    if (config.registry.type === "git") {
+      lines.push("registry:", "  git:", `    url: '${config.registry.url}'`);
+      if (config.registry.ref) {
+        lines.push(`    ref: '${config.registry.ref}'`);
+      }
+    } else {
+      lines.push("registry:", `  path: '${config.registry.path}'`);
+    }
   } else {
-    lines.push("# registry:", "#   path: './registry'");
+    lines.push(
+      "# registry:",
+      "#   git:",
+      "#     url: 'https://github.com/mrwogu/promptscript-registry.git'",
+      "#     ref: 'main'"
+    );
   }
   lines.push("", "targets:");
   for (const target of config.targets) {
@@ -1654,7 +2210,13 @@ function generateConfig(config) {
   return lines.join("\n");
 }
 function generateProjectPs(config, projectInfo) {
-  const inheritLine = config.inherit ? `@inherit ${config.inherit}` : "# @inherit @company/team";
+  const inheritLine = config.inherit ? `@inherit ${config.inherit}` : "# @inherit @stacks/react";
+  let useLines = "";
+  if (config.use && config.use.length > 0) {
+    useLines = config.use.map((u) => `@use ${u}`).join("\n");
+  } else {
+    useLines = "# @use @fragments/testing\n# @use @fragments/typescript";
+  }
   const languagesLine = projectInfo.languages.length > 0 ? `  languages: [${projectInfo.languages.join(", ")}]` : "  # languages: [typescript]";
   const frameworksLine = projectInfo.frameworks.length > 0 ? `  frameworks: [${projectInfo.frameworks.join(", ")}]` : "  # frameworks: []";
   const syntaxVersion = getPackageVersion(__dirname, "./package.json");
@@ -1667,11 +2229,12 @@ function generateProjectPs(config, projectInfo) {
 }
 
 ${inheritLine}
+${useLines}
 
 @identity {
   """
   You are working on the ${config.projectId} project.
-  
+
   [Describe your project here]
   """
 }
@@ -1700,7 +2263,7 @@ ${frameworksLine}
 }
 
 // packages/cli/src/commands/compile.ts
-import { resolve as resolve4, dirname as dirname5 } from "path";
+import { resolve as resolve4, dirname as dirname6 } from "path";
 import { writeFile as writeFile2, mkdir as mkdir2, readFile as readFile6 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
 import chokidar from "chokidar";
@@ -1708,7 +2271,7 @@ import chokidar from "chokidar";
 // packages/cli/src/config/loader.ts
 import { readFile as readFile3 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import { parse as parseYaml2 } from "yaml";
+import { parse as parseYaml3 } from "yaml";
 var CONFIG_FILES = [
   "promptscript.yaml",
   "promptscript.yml",
@@ -1755,7 +2318,7 @@ async function loadConfig(customPath) {
   let content = await readFile3(configFile, "utf-8");
   content = interpolateEnvVars(content);
   try {
-    return parseYaml2(content);
+    return parseYaml3(content);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown parse error";
     throw new Error(`Failed to parse ${configFile}: ${message}`);
@@ -15317,7 +15880,7 @@ function parse(source, options = {}) {
 
 // packages/resolver/src/loader.ts
 import { readFile as readFile4 } from "fs/promises";
-import { resolve as resolve2, dirname as dirname3, isAbsolute } from "path";
+import { resolve as resolve2, dirname as dirname4, isAbsolute } from "path";
 var FileLoader = class {
   registryPath;
   localPath;
@@ -15378,7 +15941,7 @@ var FileLoader = class {
    */
   resolveRef(ref, fromFile) {
     if (ref.isRelative) {
-      const dir = dirname3(fromFile);
+      const dir = dirname4(fromFile);
       const rawPath = ref.raw.endsWith(".prs") ? ref.raw : `${ref.raw}.prs`;
       return resolve2(dir, rawPath);
     }
@@ -16040,7 +16603,7 @@ function uniqueConcat3(parent, child) {
 
 // packages/resolver/src/skills.ts
 import { readFile as readFile5, access } from "fs/promises";
-import { resolve as resolve3, dirname as dirname4 } from "path";
+import { resolve as resolve3, dirname as dirname5 } from "path";
 function parseSkillMd(content) {
   const lines = content.split("\n");
   let inFrontmatter = false;
@@ -16095,7 +16658,7 @@ async function resolveNativeSkills(ast, registryPath, sourceFile) {
   const skillsContent = skillsBlock.content;
   const updatedProperties = { ...skillsContent.properties };
   let hasUpdates = false;
-  const sourceDir = dirname4(sourceFile);
+  const sourceDir = dirname5(sourceFile);
   const isSkillsDir = sourceDir.includes("@skills");
   for (const [skillName, skillValue] of Object.entries(skillsContent.properties)) {
     if (typeof skillValue !== "object" || skillValue === null || Array.isArray(skillValue)) {
@@ -16323,7 +16886,7 @@ var Resolver = class {
 
 // packages/resolver/src/registry.ts
 import { existsSync as existsSync4, promises as fs } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 var FileSystemRegistry = class {
   rootPath;
   constructor(options) {
@@ -16333,7 +16896,7 @@ var FileSystemRegistry = class {
    * Resolve a path relative to the registry root.
    */
   resolvePath(path) {
-    return join3(this.rootPath, path);
+    return join4(this.rootPath, path);
   }
   async fetch(path) {
     const fullPath = this.resolvePath(path);
@@ -16548,12 +17111,12 @@ function createHttpRegistry(options) {
 
 // packages/resolver/src/git-registry.ts
 import { existsSync as existsSync6, promises as fs3 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { simpleGit } from "simple-git";
 
 // packages/resolver/src/git-cache-manager.ts
 import { existsSync as existsSync5, promises as fs2 } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { homedir } from "os";
 
 // packages/resolver/src/git-url-utils.ts
@@ -16661,7 +17224,7 @@ function parseVersionedPath(path) {
 }
 
 // packages/resolver/src/git-cache-manager.ts
-var DEFAULT_CACHE_DIR = join4(homedir(), ".promptscript", ".cache", "git");
+var DEFAULT_CACHE_DIR = join5(homedir(), ".promptscript", ".cache", "git");
 var DEFAULT_TTL = 36e5;
 var METADATA_FILE = ".prs-cache-meta.json";
 var GitCacheManager = class {
@@ -16680,7 +17243,7 @@ var GitCacheManager = class {
    */
   getCachePath(url, ref) {
     const cacheKey = getCacheKey(url, ref);
-    return join4(this.cacheDir, cacheKey);
+    return join5(this.cacheDir, cacheKey);
   }
   /**
    * Check if a cache entry exists and is not stale.
@@ -16786,7 +17349,7 @@ var GitCacheManager = class {
       if (!dir.isDirectory()) {
         continue;
       }
-      const cachePath = join4(this.cacheDir, dir.name);
+      const cachePath = join5(this.cacheDir, dir.name);
       const metadata = await this.readMetadata(cachePath);
       if (metadata) {
         const isStale = Date.now() - metadata.lastUpdated > this.ttl;
@@ -16834,7 +17397,7 @@ var GitCacheManager = class {
     let size = 0;
     const entries = await fs2.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join4(dirPath, entry.name);
+      const fullPath = join5(dirPath, entry.name);
       if (entry.isDirectory()) {
         size += await this.calculateDirSize(fullPath);
       } else {
@@ -16848,7 +17411,7 @@ var GitCacheManager = class {
    * Read metadata from a cache directory.
    */
   async readMetadata(cachePath) {
-    const metadataPath = join4(cachePath, METADATA_FILE);
+    const metadataPath = join5(cachePath, METADATA_FILE);
     if (!existsSync5(metadataPath)) {
       return null;
     }
@@ -16863,7 +17426,7 @@ var GitCacheManager = class {
    * Write metadata to a cache directory.
    */
   async writeMetadata(cachePath, metadata) {
-    const metadataPath = join4(cachePath, METADATA_FILE);
+    const metadataPath = join5(cachePath, METADATA_FILE);
     await fs2.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
   }
 };
@@ -17154,9 +17717,9 @@ var GitRegistry = class {
       cleanPath += ".prs";
     }
     if (this.subPath) {
-      return join5(repoPath, this.subPath, cleanPath);
+      return join6(repoPath, this.subPath, cleanPath);
     }
-    return join5(repoPath, cleanPath);
+    return join6(repoPath, cleanPath);
   }
   /**
    * Resolve a directory path within the repository.
@@ -17166,9 +17729,9 @@ var GitRegistry = class {
    */
   resolveDirectoryPath(repoPath, relativePath) {
     if (this.subPath) {
-      return join5(repoPath, this.subPath, relativePath);
+      return join6(repoPath, this.subPath, relativePath);
     }
-    return join5(repoPath, relativePath);
+    return join6(repoPath, relativePath);
   }
   /**
    * Check if an error is an authentication error.
@@ -17886,8 +18449,8 @@ var Compiler = class _Compiler {
    */
   async watch(entryPath, options = {}) {
     const { default: chokidar2 } = await import("chokidar");
-    const { dirname: dirname8, resolve: resolve9 } = await import("path");
-    const baseDir = dirname8(resolve9(entryPath));
+    const { dirname: dirname10, resolve: resolve9 } = await import("path");
+    const baseDir = dirname10(resolve9(entryPath));
     const includePatterns = options.include ?? ["**/*.prs"];
     const excludePatterns = options.exclude ?? ["**/node_modules/**"];
     const debounceMs = options.debounce ?? 300;
@@ -18107,6 +18670,69 @@ function createPager(enabled = true) {
   return new Pager(enabled);
 }
 
+// packages/cli/src/utils/registry-resolver.ts
+import { join as join7 } from "path";
+async function resolveRegistryPath(config) {
+  if (config.registry?.git) {
+    const gitConfig = config.registry.git;
+    const ref = gitConfig.ref ?? "main";
+    const cacheManager = new GitCacheManager({
+      ttl: config.registry.cache?.ttl
+    });
+    const normalizedUrl = normalizeGitUrl(gitConfig.url);
+    const cachePath = cacheManager.getCachePath(normalizedUrl, ref);
+    const isValid = await cacheManager.isValid(normalizedUrl, ref);
+    if (isValid) {
+      const subPath2 = gitConfig.path ?? "";
+      return {
+        path: subPath2 ? join7(cachePath, subPath2) : cachePath,
+        isRemote: true,
+        source: "git"
+      };
+    }
+    const registry = createGitRegistry({
+      url: gitConfig.url,
+      ref,
+      path: gitConfig.path,
+      auth: gitConfig.auth,
+      cache: {
+        enabled: config.registry.cache?.enabled ?? true,
+        ttl: config.registry.cache?.ttl
+      }
+    });
+    try {
+      await registry.fetch("registry-manifest.yaml");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!message.includes("not found") && !message.includes("FileNotFoundError")) {
+        throw new Error(
+          `Failed to clone registry from ${gitConfig.url}: ${message}. Please check your network connection and registry configuration.`
+        );
+      }
+    }
+    const subPath = gitConfig.path ?? "";
+    return {
+      path: subPath ? join7(cachePath, subPath) : cachePath,
+      isRemote: true,
+      source: "git"
+    };
+  }
+  if (config.registry?.url) {
+    const localPath = config.registry?.path ?? "./registry";
+    return {
+      path: localPath,
+      isRemote: true,
+      source: "http"
+    };
+  }
+  const registryPath = config.registry?.path ?? "./registry";
+  return {
+    path: registryPath,
+    isRemote: false,
+    source: "local"
+  };
+}
+
 // packages/cli/src/commands/compile.ts
 var PROMPTSCRIPT_MARKERS = [
   "<!-- PromptScript",
@@ -18207,7 +18833,7 @@ async function writeOutputs(outputs, options, _config, services) {
       continue;
     }
     if (!fileExists2) {
-      await mkdir2(dirname5(outputPath), { recursive: true });
+      await mkdir2(dirname6(outputPath), { recursive: true });
       await writeFile2(outputPath, output.content, "utf-8");
       ConsoleOutput.success(outputPath);
       result.written.push(outputPath);
@@ -18223,14 +18849,14 @@ async function writeOutputs(outputs, options, _config, services) {
         result.unchanged.push(outputPath);
         continue;
       }
-      await mkdir2(dirname5(outputPath), { recursive: true });
+      await mkdir2(dirname6(outputPath), { recursive: true });
       await writeFile2(outputPath, output.content, "utf-8");
       ConsoleOutput.success(outputPath);
       result.written.push(outputPath);
       continue;
     }
     if (options.force || overwriteAll) {
-      await mkdir2(dirname5(outputPath), { recursive: true });
+      await mkdir2(dirname6(outputPath), { recursive: true });
       await writeFile2(outputPath, output.content, "utf-8");
       ConsoleOutput.success(outputPath);
       result.written.push(outputPath);
@@ -18243,7 +18869,7 @@ async function writeOutputs(outputs, options, _config, services) {
     const response = await promptForOverwrite(outputPath, services);
     switch (response) {
       case "yes":
-        await mkdir2(dirname5(outputPath), { recursive: true });
+        await mkdir2(dirname6(outputPath), { recursive: true });
         await writeFile2(outputPath, output.content, "utf-8");
         ConsoleOutput.success(outputPath);
         result.written.push(outputPath);
@@ -18254,7 +18880,7 @@ async function writeOutputs(outputs, options, _config, services) {
         break;
       case "all":
         overwriteAll = true;
-        await mkdir2(dirname5(outputPath), { recursive: true });
+        await mkdir2(dirname6(outputPath), { recursive: true });
         await writeFile2(outputPath, output.content, "utf-8");
         ConsoleOutput.success(outputPath);
         result.written.push(outputPath);
@@ -18293,10 +18919,20 @@ async function compileCommand(options, services = createDefaultServices()) {
   try {
     logger.verbose("Loading configuration...");
     const config = await loadConfig(options.config);
-    spinner.text = "Compiling...";
     const selectedTarget = options.target ?? options.format;
     const targets = selectedTarget ? [{ name: selectedTarget }] : parseTargets(config.targets);
-    const registryPath = options.registry ?? config.registry?.path ?? "./registry";
+    let registryPath;
+    if (options.registry) {
+      registryPath = options.registry;
+    } else {
+      spinner.text = "Resolving registry...";
+      const registry = await resolveRegistryPath(config);
+      registryPath = registry.path;
+      if (registry.isRemote) {
+        logger.verbose(`Using cached git registry: ${registryPath}`);
+      }
+    }
+    spinner.text = "Compiling...";
     logger.verbose(`Registry: ${registryPath}`);
     logger.debug(`Config: ${JSON.stringify(config, null, 2)}`);
     const prettierOptions = await resolvePrettierOptions(config, process.cwd());
@@ -18472,10 +19108,12 @@ async function validateCommand(options) {
   const spinner = isJsonFormat ? createSpinner("").stop() : createSpinner("Loading configuration...").start();
   try {
     const config = await loadConfig();
+    if (!isJsonFormat) spinner.text = "Resolving registry...";
+    const registry = await resolveRegistryPath(config);
     if (!isJsonFormat) spinner.text = "Validating...";
     const compiler = new Compiler({
       resolver: {
-        registryPath: config.registry?.path ?? "./registry",
+        registryPath: registry.path,
         localPath: "./.promptscript"
       },
       validator: config.validation,
@@ -18524,7 +19162,7 @@ function outputJsonResult(result) {
 // packages/cli/src/commands/pull.ts
 import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
 import { existsSync as existsSync9 } from "fs";
-import { resolve as resolve6, dirname as dirname6 } from "path";
+import { resolve as resolve6, dirname as dirname7 } from "path";
 async function pullCommand(options) {
   const spinner = createSpinner("Loading configuration...").start();
   try {
@@ -18563,7 +19201,7 @@ async function pullCommand(options) {
       }
       return;
     }
-    await mkdir3(dirname6(destPath), { recursive: true });
+    await mkdir3(dirname7(destPath), { recursive: true });
     await writeFile3(destPath, content, "utf-8");
     spinner.succeed("Pulled from registry");
     ConsoleOutput.success(destPath);
@@ -18719,11 +19357,13 @@ async function diffCommand(options) {
   const spinner = createSpinner("Loading configuration...").start();
   try {
     const config = await loadConfig();
+    spinner.text = "Resolving registry...";
+    const registry = await resolveRegistryPath(config);
     spinner.text = "Compiling...";
     const targets = options.target ? [{ name: options.target }] : parseTargets2(config.targets);
     const compiler = new Compiler({
       resolver: {
-        registryPath: config.registry?.path ?? "./registry",
+        registryPath: registry.path,
         localPath: "./.promptscript"
       },
       validator: config.validation,
@@ -18957,11 +19597,189 @@ function printResults(results) {
   }
 }
 
-// packages/cli/src/cli.ts
+// packages/cli/src/commands/update-check.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname8 } from "path";
+
+// packages/cli/src/utils/version-check.ts
+import { homedir as homedir2 } from "os";
+import { join as join8 } from "path";
+import { existsSync as existsSync12, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
+var NPM_REGISTRY_URL = "https://registry.npmjs.org/@promptscript/cli/latest";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 3e3;
+function getCacheDir() {
+  return join8(homedir2(), ".promptscript", ".cache");
+}
+function getCachePath() {
+  return join8(getCacheDir(), "version.json");
+}
+function readCache() {
+  try {
+    const cachePath = getCachePath();
+    if (!existsSync12(cachePath)) {
+      return null;
+    }
+    const content = readFileSync3(cachePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeCache(cache) {
+  try {
+    const cacheDir = getCacheDir();
+    if (!existsSync12(cacheDir)) {
+      mkdirSync(cacheDir, { recursive: true });
+    }
+    const cachePath = getCachePath();
+    writeFileSync(cachePath, JSON.stringify(cache, null, 2), "utf-8");
+  } catch {
+  }
+}
+function isCacheValid(cache) {
+  try {
+    const lastCheck = new Date(cache.lastCheck).getTime();
+    const now = Date.now();
+    return now - lastCheck < CACHE_TTL_MS;
+  } catch {
+    return false;
+  }
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const response = await fetch(NPM_REGISTRY_URL, {
+      signal: controller.signal,
+      headers: {
+        Accept: "application/json"
+      }
+    });
+    clearTimeout(timeout);
+    if (!response.ok) {
+      if (isVerbose()) {
+        ConsoleOutput.verbose(`Could not check for updates: HTTP ${response.status}`);
+      }
+      return null;
+    }
+    const data = await response.json();
+    return data.version ?? null;
+  } catch (error) {
+    if (isVerbose()) {
+      const code = error.code;
+      const message = error instanceof Error ? error.message : "Unknown error";
+      ConsoleOutput.verbose(`Could not check for updates: ${code ?? message}`);
+    }
+    return null;
+  }
+}
+function isNewerVersion(currentVersion, latestVersion) {
+  const cleanCurrent = currentVersion.replace(/^v/, "");
+  const cleanLatest = latestVersion.replace(/^v/, "");
+  const [currentBase, currentPrerelease] = cleanCurrent.split("-");
+  const [latestBase, latestPrerelease] = cleanLatest.split("-");
+  const currentParts = (currentBase ?? "").split(".").map((p) => parseInt(p, 10) || 0);
+  const latestParts = (latestBase ?? "").split(".").map((p) => parseInt(p, 10) || 0);
+  for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
+    const c = currentParts[i] ?? 0;
+    const l = latestParts[i] ?? 0;
+    if (l > c) return true;
+    if (l < c) return false;
+  }
+  if (currentPrerelease && !latestPrerelease) {
+    return true;
+  }
+  return false;
+}
+async function checkForUpdates(currentVersion) {
+  if (process.env["PROMPTSCRIPT_NO_UPDATE_CHECK"]) {
+    return null;
+  }
+  if (isQuiet()) {
+    return null;
+  }
+  const cache = readCache();
+  if (cache && isCacheValid(cache) && cache.currentVersion === currentVersion) {
+    if (isNewerVersion(currentVersion, cache.latestVersion)) {
+      return {
+        currentVersion,
+        latestVersion: cache.latestVersion,
+        updateAvailable: true
+      };
+    }
+    return null;
+  }
+  const latestVersion = await fetchLatestVersion();
+  if (!latestVersion) {
+    return null;
+  }
+  writeCache({
+    lastCheck: (/* @__PURE__ */ new Date()).toISOString(),
+    latestVersion,
+    currentVersion
+  });
+  if (isNewerVersion(currentVersion, latestVersion)) {
+    return {
+      currentVersion,
+      latestVersion,
+      updateAvailable: true
+    };
+  }
+  return null;
+}
+async function forceCheckForUpdates(currentVersion) {
+  const latestVersion = await fetchLatestVersion();
+  if (!latestVersion) {
+    return { info: null, error: true };
+  }
+  writeCache({
+    lastCheck: (/* @__PURE__ */ new Date()).toISOString(),
+    latestVersion,
+    currentVersion
+  });
+  const updateAvailable = isNewerVersion(currentVersion, latestVersion);
+  return {
+    info: {
+      currentVersion,
+      latestVersion,
+      updateAvailable
+    },
+    error: false
+  };
+}
+function printUpdateNotification(info) {
+  console.log(
+    `Update available: ${info.currentVersion} \u2192 ${info.latestVersion} (npm i -g @promptscript/cli)`
+  );
+}
+
+// packages/cli/src/commands/update-check.ts
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname7(__filename2);
+var __dirname2 = dirname8(__filename2);
+async function updateCheckCommand() {
+  const currentVersion = getPackageVersion(__dirname2, "../../package.json");
+  console.log(`@promptscript/cli v${currentVersion}`);
+  const { info, error } = await forceCheckForUpdates(currentVersion);
+  if (error) {
+    ConsoleOutput.error("Could not check for updates");
+    process.exitCode = 1;
+    return;
+  }
+  if (info?.updateAvailable) {
+    console.log(
+      `Update available: ${info.currentVersion} \u2192 ${info.latestVersion} (npm i -g @promptscript/cli)`
+    );
+  } else {
+    ConsoleOutput.success("Up to date");
+  }
+}
+
+// packages/cli/src/cli.ts
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = dirname9(__filename3);
 var program = new Command();
-program.name("prs").description("PromptScript CLI - Standardize AI instructions").version(getPackageVersion(__dirname2, "./package.json")).option("--verbose", "Enable verbose output").option("--debug", "Enable debug output (includes verbose)").option("--quiet", "Suppress non-error output").hook("preAction", (thisCommand) => {
+program.name("prs").description("PromptScript CLI - Standardize AI instructions").version(getPackageVersion(__dirname3, "../package.json")).option("--verbose", "Enable verbose output").option("--debug", "Enable debug output (includes verbose)").option("--quiet", "Suppress non-error output").hook("preAction", async (thisCommand, actionCommand) => {
   const opts = thisCommand.opts();
   if (opts["quiet"]) {
     setContext({ logLevel: 0 /* Quiet */ });
@@ -18975,13 +19793,22 @@ program.name("prs").description("PromptScript CLI - Standardize AI instructions"
   } else if (process.env["PROMPTSCRIPT_VERBOSE"] === "1" || process.env["PROMPTSCRIPT_VERBOSE"] === "true") {
     setContext({ logLevel: 2 /* Verbose */ });
   }
+  if (actionCommand.name() === "update-check") {
+    return;
+  }
+  const currentVersion = getPackageVersion(__dirname3, "../package.json");
+  const updateInfo = await checkForUpdates(currentVersion);
+  if (updateInfo) {
+    printUpdateNotification(updateInfo);
+  }
 });
 program.command("init").description("Initialize PromptScript in current directory").option("-n, --name <name>", "Project name (auto-detected from package.json, etc.)").option("-t, --team <team>", "Team namespace").option("--inherit <path>", "Inheritance path (e.g., @company/team)").option("--registry <path>", "Registry path").option("--targets <targets...>", "Target AI tools (github, claude, cursor)").option("-i, --interactive", "Force interactive mode").option("-y, --yes", "Skip prompts, use defaults").option("-f, --force", "Force reinitialize even if already initialized").option("-m, --migrate", "Install migration skill for AI-assisted migration").action((opts) => initCommand(opts));
 program.command("compile").description("Compile PromptScript to target formats").option("-t, --target <target>", "Specific target (github, claude, cursor)").option("-f, --format <format>", "Output format (alias for --target)").option("-a, --all", "All configured targets", true).option("-w, --watch", "Watch mode").option("-o, --output <dir>", "Output directory").option("--dry-run", "Preview changes").option("--registry <path>", "Registry path (overrides config)").option("-c, --config <path>", "Path to custom config file").option("--force", "Force overwrite existing files without prompts").action((opts) => compileCommand(opts));
 program.command("validate").description("Validate PromptScript files").option("--strict", "Treat warnings as errors").option("--format <format>", "Output format (text, json)", "text").action(validateCommand);
 program.command("pull").description("Pull updates from registry").option("-f, --force", "Force overwrite").option("--dry-run", "Preview changes without pulling").option("-b, --branch <name>", "Git branch to pull from").option("--tag <name>", "Git tag to pull from").option("--commit <hash>", "Git commit to pull from").option("--refresh", "Force re-fetch from remote (ignore cache)").action(pullCommand);
 program.command("diff").description("Show diff for compiled output").option("-t, --target <target>", "Specific target").option("-a, --all", "Show diff for all targets at once").option("--full", "Show full diff without truncation").option("--no-pager", "Disable pager output").option("--color", "Force colored output").option("--no-color", "Disable colored output").action(diffCommand);
-program.command("check").description("Check configuration and dependencies health").option("--fix", "Attempt to fix issues").action(checkCommand);
+program.command("check").description("Check configuration and dependencies health").action(checkCommand);
+program.command("update-check").description("Check for CLI updates").action(updateCheckCommand);
 function run(args = process.argv) {
   program.parse(args);
 }
@@ -18991,18 +19818,25 @@ export {
   ConsoleOutput,
   LogLevel,
   checkCommand,
+  checkForUpdates,
   compileCommand,
   createSpinner,
   diffCommand,
+  fetchLatestVersion,
   findConfigFile,
+  forceCheckForUpdates,
+  getCacheDir,
+  getCachePath,
   getContext,
   initCommand,
   isQuiet,
   isVerbose,
   loadConfig,
+  printUpdateNotification,
   pullCommand,
   run,
   setContext,
+  updateCheckCommand,
   validateCommand
 };
 /*! Bundled license information: