@promptscript/cli 1.0.0-alpha.0 → 1.0.0-alpha.2

package/index.js

@@ -617,6 +617,11 @@ var AI_TOOL_PATTERNS = [
     target: "cursor",
     files: [".cursor/rules/project.mdc", ".cursorrules", ".cursor/rules.md"],
     directories: [".cursor", ".cursor/rules"]
+  },
+  {
+    target: "antigravity",
+    files: [".agent/rules/project.md"],
+    directories: [".agent", ".agent/rules"]
   }
 ];
 async function directoryHasContent(dir, services) {
@@ -633,7 +638,8 @@ async function detectAITools(services = createDefaultServices()) {
   const details = {
     github: [],
     claude: [],
-    cursor: []
+    cursor: [],
+    antigravity: []
   };
   for (const pattern of AI_TOOL_PATTERNS) {
     const foundFiles = [];
@@ -655,7 +661,7 @@ async function detectAITools(services = createDefaultServices()) {
   return { detected, details };
 }
 function getAllTargets() {
-  return ["github", "claude", "cursor"];
+  return ["github", "claude", "cursor", "antigravity"];
 }
 function getSuggestedTargets(detection) {
   return detection.detected.length > 0 ? detection.detected : getAllTargets();
@@ -678,8 +684,8 @@ function formatDetectionResults(detection) {
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
 async function initCommand(options, services = createDefaultServices()) {
-  const { fs } = services;
-  if (fs.existsSync("promptscript.yaml") && !options.force) {
+  const { fs: fs4 } = services;
+  if (fs4.existsSync("promptscript.yaml") && !options.force) {
     ConsoleOutput.warn("PromptScript already initialized");
     ConsoleOutput.muted("Use --force to reinitialize");
     return;
@@ -689,11 +695,11 @@ async function initCommand(options, services = createDefaultServices()) {
     const aiToolsDetection = await detectAITools(services);
     const config = await resolveConfig(options, projectInfo, aiToolsDetection, services);
     const spinner = createSpinner("Creating PromptScript configuration...").start();
-    await fs.mkdir(".promptscript", { recursive: true });
+    await fs4.mkdir(".promptscript", { recursive: true });
     const configContent = generateConfig(config);
-    await fs.writeFile("promptscript.yaml", configContent, "utf-8");
+    await fs4.writeFile("promptscript.yaml", configContent, "utf-8");
     const projectPsContent = generateProjectPs(config, projectInfo);
-    await fs.writeFile(".promptscript/project.prs", projectPsContent, "utf-8");
+    await fs4.writeFile(".promptscript/project.prs", projectPsContent, "utf-8");
     spinner.succeed("PromptScript initialized");
     ConsoleOutput.newline();
     console.log("Created:");
@@ -786,7 +792,7 @@ async function runInteractivePrompts(options, projectInfo, aiToolsDetection, ser
   }
   const wantsRegistry = await prompts2.confirm({
     message: "Do you want to configure a registry?",
-    default: true
+    default: false
   });
   let registry;
   if (wantsRegistry) {
@@ -830,7 +836,8 @@ function formatTargetName(target) {
   const names = {
     github: "GitHub Copilot",
     claude: "Claude (Anthropic)",
-    cursor: "Cursor"
+    cursor: "Cursor",
+    antigravity: "Antigravity (Google)"
   };
   return names[target] ?? target;
 }
@@ -907,7 +914,7 @@ ${frameworksLine}
 // packages/cli/src/commands/compile.ts
 import { resolve as resolve2, dirname as dirname3 } from "path";
 import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import chokidar from "chokidar";
 
 // packages/cli/src/config/loader.ts
@@ -1962,21 +1969,13 @@ var GitHubFormatter = class extends BaseFormatter {
     const subsections = [];
     const eslint = configObj["eslint"];
     if (eslint) {
-      const items = [
-        "All package ESLint configs must inherit from `eslint.base.config.cjs` in the root",
-        "Package configs should use `createBaseConfig(__dirname)` from the base config",
-        "Do not duplicate ESLint rules in package configs - modify the base config instead"
-      ];
-      subsections.push(renderer.renderSection("eslint", renderer.renderList(items), 2));
+      const value = this.valueToString(eslint);
+      subsections.push(renderer.renderSection("eslint", `ESLint: ${value}`, 2));
     }
     const vite = configObj["viteRoot"];
     if (vite) {
-      const items = [
-        "Use `__dirname` for the `root` option in both `vite.config.ts` and `vitest.config.mts`",
-        "Do NOT use `import.meta.dirname` - it causes TypeScript errors with current tsconfig settings",
-        "Example: `root: __dirname,`"
-      ];
-      subsections.push(renderer.renderSection("vite-vitest", renderer.renderList(items), 2));
+      const value = this.valueToString(vite);
+      subsections.push(renderer.renderSection("vite-vitest", `Vite root: ${value}`, 2));
     }
     if (subsections.length === 0) return null;
     return renderer.renderSection("configuration-files", subsections.join("\n"));
@@ -2567,7 +2566,9 @@ var ClaudeFormatter = class extends BaseFormatter {
     const identity2 = this.findBlock(ast, "identity");
     if (!identity2) return null;
     const text = this.extractText(identity2.content);
-    const cleanText = text.split("\n").map((line) => line.trim()).filter((line) => line).join("\n");
+    const cleanText = text.split(/\n{2,}/).map(
+      (para) => para.split("\n").map((line) => line.trim()).filter((line) => line).join("\n")
+    ).filter((para) => para).join("\n\n");
     return renderer.renderSection("Project", cleanText) + "\n";
   }
   techStack(ast, renderer) {
@@ -2707,7 +2708,7 @@ var ClaudeFormatter = class extends BaseFormatter {
     if (shortcuts) {
       const props = this.getProps(shortcuts.content);
       for (const [cmd, desc] of Object.entries(props)) {
-        const shortDesc = this.valueToString(desc).split("\n")[0]?.substring(0, 40) ?? "";
+        const shortDesc = this.valueToString(desc).split("\n")[0] ?? "";
         commandLines.push(`${cmd.padEnd(10)} - ${shortDesc}`);
       }
     }
@@ -2796,21 +2797,21 @@ var ClaudeFormatter = class extends BaseFormatter {
 var CURSOR_VERSIONS = {
   modern: {
     name: "modern",
-    description: "MDC format with YAML frontmatter (.cursor/rules/project.mdc)",
+    description: "MDC format with YAML frontmatter (.cursor/rules/project.mdc) + slash commands (.cursor/commands/)",
     outputPath: ".cursor/rules/project.mdc",
     cursorVersion: "0.45+",
     introduced: "2024-12"
   },
   frontmatter: {
     name: "frontmatter",
-    description: "Alias for modern format (MDC with YAML frontmatter)",
+    description: "Alias for modern format (MDC with YAML frontmatter + slash commands)",
     outputPath: ".cursor/rules/project.mdc",
     cursorVersion: "0.45+",
     introduced: "2024-12"
   },
   multifile: {
     name: "multifile",
-    description: "Multiple MDC files with glob-based targeting",
+    description: "Multiple MDC files with glob-based targeting + slash commands",
     outputPath: ".cursor/rules/project.mdc",
     cursorVersion: "0.45+",
     introduced: "2024-12"
@@ -2875,9 +2876,11 @@ var CursorFormatter = class extends BaseFormatter {
     const frontmatter = this.frontmatter(ast);
     sections.push(frontmatter);
     this.addCommonSections(ast, sections);
+    const commandFiles = this.generateCommandFiles(ast);
     return {
       path: options?.outputPath ?? CURSOR_VERSIONS.modern.outputPath,
-      content: sections.join("\n\n") + "\n"
+      content: sections.join("\n\n") + "\n",
+      additionalFiles: commandFiles.length > 0 ? commandFiles : void 0
     };
   }
   /**
@@ -2909,6 +2912,8 @@ var CursorFormatter = class extends BaseFormatter {
     if (shortcutsFile) {
       additionalFiles.push(shortcutsFile);
     }
+    const commandFiles = this.generateCommandFiles(ast);
+    additionalFiles.push(...commandFiles);
     const mainSections = [];
     mainSections.push(this.frontmatter(ast));
     mainSections.push(this.intro(ast));
@@ -3046,6 +3051,34 @@ var CursorFormatter = class extends BaseFormatter {
       content: sections.join("\n\n") + "\n"
     };
   }
+  /**
+   * Generate command files for multi-line shortcuts.
+   *
+   * Shortcuts with multi-line content (containing newlines) are converted
+   * to individual `.cursor/commands/*.md` files that can be invoked as
+   * slash commands in Cursor 1.6+.
+   *
+   * Single-line shortcuts remain as documentation in the rules file.
+   *
+   * @see https://cursor.com/changelog/1-6
+   */
+  generateCommandFiles(ast) {
+    const block = this.findBlock(ast, "shortcuts");
+    if (!block) return [];
+    const props = this.getProps(block.content);
+    const commands = [];
+    for (const [name, value] of Object.entries(props)) {
+      const content = this.valueToString(value);
+      if (content.includes("\n")) {
+        const fileName = name.replace(/^\//, "");
+        commands.push({
+          path: `.cursor/commands/${fileName}.md`,
+          content: content.trim()
+        });
+      }
+    }
+    return commands;
+  }
   /**
    * Add common sections shared between modern and legacy formats.
    */
@@ -3350,24 +3383,24 @@ ${items.map((i) => "- " + i).join("\n")}`;
 ${lines.join("\n")}` : null;
   }
   devCommands(ast) {
-    const context = this.findBlock(ast, "context");
-    if (!context) return null;
-    const cmds = this.getProp(context.content, "commands");
-    if (!cmds) return null;
-    const text = typeof cmds === "string" ? cmds : this.valueToString(cmds);
-    if (!text.trim()) return null;
+    const knowledge = this.findBlock(ast, "knowledge");
+    if (!knowledge) return null;
+    const text = this.extractText(knowledge.content);
+    const match = this.extractSectionWithCodeBlock(text, "## Development Commands");
+    if (!match) return null;
+    const content = match.replace("## Development Commands", "").trim();
     return `Development Commands:
-${text.trim()}`;
+${content}`;
   }
   postWork(ast) {
-    const context = this.findBlock(ast, "context");
-    if (!context) return null;
-    const post = this.getProp(context.content, "post-work-verification");
-    if (!post) return null;
-    const text = typeof post === "string" ? post : this.valueToString(post);
-    if (!text.trim()) return null;
+    const knowledge = this.findBlock(ast, "knowledge");
+    if (!knowledge) return null;
+    const text = this.extractText(knowledge.content);
+    const match = this.extractSectionWithCodeBlock(text, "## Post-Work Verification");
+    if (!match) return null;
+    const content = match.replace("## Post-Work Verification", "").trim();
     return `Post-Work Verification:
-${text.trim()}`;
+${content}`;
   }
   documentation(ast) {
     const items = this.extractDocItems(ast);
@@ -3882,25 +3915,17 @@ ${items.map((i) => "- " + i).join("\n")}`;
     const subsections = [];
     const eslint = configObj["eslint"];
     if (eslint) {
-      const items = [
-        "All package ESLint configs must inherit from `eslint.base.config.cjs` in the root",
-        "Package configs should use `createBaseConfig(__dirname)` from the base config",
-        "Do not duplicate ESLint rules in package configs - modify the base config instead"
-      ];
+      const value = this.valueToString(eslint);
       subsections.push(`### ESLint
 
-${items.map((i) => "- " + i).join("\n")}`);
+- ESLint: ${value}`);
     }
     const vite = configObj["viteRoot"];
     if (vite) {
-      const items = [
-        "Use `__dirname` for the `root` option in both `vite.config.ts` and `vitest.config.mts`",
-        "Do NOT use `import.meta.dirname` - it causes TypeScript errors with current tsconfig settings",
-        "Example: `root: __dirname,`"
-      ];
+      const value = this.valueToString(vite);
       subsections.push(`### Vite/Vitest
 
-${items.map((i) => "- " + i).join("\n")}`);
+- Vite root: ${value}`);
     }
     if (subsections.length === 0) return null;
     return `## Configuration Files
@@ -14414,11 +14439,22 @@ function mergeBlockContent(parent, child) {
   return deepClone(child);
 }
 function mergeTextContent2(parent, child) {
+  const parentVal = parent.value.trim();
+  const childVal = child.value.trim();
+  if (parentVal === childVal) {
+    return { ...child, value: childVal };
+  }
+  if (childVal.includes(parentVal)) {
+    return { ...child, value: childVal };
+  }
+  if (parentVal.includes(childVal)) {
+    return { ...child, value: parentVal };
+  }
   return {
     ...child,
-    value: `${parent.value}
+    value: `${parentVal}
 
-${child.value}`
+${childVal}`
   };
 }
 function mergeObjectContent(parent, child) {
@@ -14436,7 +14472,7 @@ function mergeProperties(parent, child) {
     } else if (Array.isArray(childVal) && Array.isArray(parentVal)) {
       result[key] = uniqueConcat(parentVal, childVal);
     } else if (isTextContent(childVal) && isTextContent(parentVal)) {
-      result[key] = mergeTextContent2(parentVal, childVal);
+      result[key] = deepCloneValue(childVal);
     } else if (isPlainObject2(childVal) && isPlainObject2(parentVal)) {
       result[key] = mergeProperties(
         parentVal,
@@ -14493,36 +14529,189 @@ function deepCloneValue(value) {
 // packages/resolver/src/imports.ts
 var IMPORT_MARKER_PREFIX = "__import__";
 function resolveUses(target, use, source) {
-  const alias = use.alias ?? extractId(source) ?? "import";
-  const markerName = `${IMPORT_MARKER_PREFIX}${alias}`;
-  const marker = {
-    type: "Block",
-    name: markerName,
-    content: {
-      type: "ObjectContent",
-      properties: {
-        __source: use.path.raw,
-        __blocks: source.blocks.map((b) => b.name)
+  const mergedBlocks = mergeBlocks2(target.blocks, source.blocks);
+  const aliasedBlocks = [];
+  if (use.alias) {
+    const alias = use.alias;
+    const markerName = `${IMPORT_MARKER_PREFIX}${alias}`;
+    const marker = {
+      type: "Block",
+      name: markerName,
+      content: {
+        type: "ObjectContent",
+        properties: {
+          __source: use.path.raw,
+          __blocks: source.blocks.map((b) => b.name)
+        },
+        loc: use.loc
       },
       loc: use.loc
-    },
-    loc: use.loc
+    };
+    aliasedBlocks.push(marker);
+    for (const block of source.blocks) {
+      aliasedBlocks.push({
+        ...block,
+        name: `${IMPORT_MARKER_PREFIX}${alias}.${block.name}`
+      });
+    }
+  }
+  return {
+    ...target,
+    blocks: [...mergedBlocks, ...aliasedBlocks]
   };
-  const aliasedBlocks = source.blocks.map((block) => ({
-    ...block,
-    name: `${IMPORT_MARKER_PREFIX}${alias}.${block.name}`
-  }));
+}
+function mergeBlocks2(target, source) {
+  const targetMap = new Map(target.map((b) => [b.name, b]));
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const tb of target) {
+    const sb = source.find((b) => b.name === tb.name);
+    if (sb) {
+      result.push(mergeBlock2(sb, tb));
+      seen.add(tb.name);
+    } else {
+      result.push(deepClone(tb));
+    }
+  }
+  for (const sb of source) {
+    if (!seen.has(sb.name) && !targetMap.has(sb.name)) {
+      result.push(deepClone(sb));
+    }
+  }
+  return result;
+}
+function mergeBlock2(source, target) {
   return {
     ...target,
-    blocks: [...target.blocks, marker, ...aliasedBlocks]
+    content: mergeBlockContent2(source.content, target.content)
   };
 }
-function extractId(program2) {
-  if (!program2.meta?.fields?.["id"]) {
-    return void 0;
+function mergeBlockContent2(source, target) {
+  if (source.type === target.type) {
+    switch (target.type) {
+      case "TextContent":
+        return mergeTextContent3(source, target);
+      case "ObjectContent":
+        return mergeObjectContent2(source, target);
+      case "ArrayContent":
+        return mergeArrayContent2(source, target);
+      case "MixedContent":
+        return mergeMixedContent2(source, target);
+    }
+  }
+  if (source.type === "MixedContent" && target.type === "TextContent") {
+    return {
+      ...source,
+      text: source.text ? mergeTextContent3(source.text, target) : deepClone(target)
+    };
+  }
+  if (source.type === "TextContent" && target.type === "MixedContent") {
+    return {
+      ...target,
+      text: target.text ? mergeTextContent3(source, target.text) : deepClone(source)
+    };
+  }
+  if (source.type === "MixedContent" && target.type === "ObjectContent") {
+    return {
+      ...source,
+      properties: mergeProperties2(source.properties, target.properties)
+    };
+  }
+  if (source.type === "ObjectContent" && target.type === "MixedContent") {
+    return {
+      ...target,
+      properties: mergeProperties2(source.properties, target.properties)
+    };
+  }
+  return deepClone(target);
+}
+function mergeTextContent3(source, target) {
+  const sourceVal = source.value.trim();
+  const targetVal = target.value.trim();
+  if (sourceVal === targetVal) {
+    return { ...target, value: targetVal };
+  }
+  if (targetVal.includes(sourceVal)) {
+    return { ...target, value: targetVal };
+  }
+  if (sourceVal.includes(targetVal)) {
+    return { ...target, value: sourceVal };
+  }
+  return {
+    ...target,
+    value: `${sourceVal}
+
+${targetVal}`
+  };
+}
+function mergeObjectContent2(source, target) {
+  return {
+    ...target,
+    properties: mergeProperties2(source.properties, target.properties)
+  };
+}
+function mergeProperties2(source, target) {
+  const result = { ...source };
+  for (const [key, targetVal] of Object.entries(target)) {
+    const sourceVal = result[key];
+    if (sourceVal === void 0) {
+      result[key] = deepCloneValue2(targetVal);
+    } else if (Array.isArray(targetVal) && Array.isArray(sourceVal)) {
+      result[key] = uniqueConcat2(sourceVal, targetVal);
+    } else if (isTextContent(targetVal) && isTextContent(sourceVal)) {
+    } else if (isTextContent(sourceVal) || isTextContent(targetVal)) {
+    } else if (isPlainObject3(targetVal) && isPlainObject3(sourceVal)) {
+      result[key] = mergeProperties2(
+        sourceVal,
+        targetVal
+      );
+    } else if (typeof sourceVal === typeof targetVal) {
+    } else {
+      result[key] = deepCloneValue2(targetVal);
+    }
+  }
+  return result;
+}
+function mergeArrayContent2(source, target) {
+  return {
+    ...target,
+    elements: uniqueConcat2(source.elements, target.elements)
+  };
+}
+function mergeMixedContent2(source, target) {
+  return {
+    ...target,
+    text: source.text && target.text ? mergeTextContent3(source.text, target.text) : target.text ?? source.text,
+    properties: mergeProperties2(source.properties, target.properties)
+  };
+}
+function uniqueConcat2(source, target) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const item of [...source, ...target]) {
+    const key = typeof item === "object" && item !== null ? JSON.stringify(item) : String(item);
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(deepCloneValue2(item));
+    }
   }
-  const id = program2.meta.fields["id"];
-  return typeof id === "string" ? id : void 0;
+  return result;
+}
+function isPlainObject3(val) {
+  return typeof val === "object" && val !== null && !Array.isArray(val) && Object.getPrototypeOf(val) === Object.prototype;
+}
+function deepCloneValue2(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(deepCloneValue2);
+  }
+  const result = {};
+  for (const [key, val] of Object.entries(value)) {
+    result[key] = deepCloneValue2(val);
+  }
+  return result;
 }
 
 // packages/resolver/src/extensions.ts
@@ -14706,7 +14895,7 @@ function mergeValue2(existing, extContent) {
     return extractValue(extContent);
   }
   if (Array.isArray(existing) && extContent.type === "ArrayContent") {
-    return uniqueConcat2(existing, extContent.elements);
+    return uniqueConcat3(existing, extContent.elements);
   }
   if (typeof existing === "object" && existing !== null && !Array.isArray(existing) && extContent.type === "ObjectContent") {
     const merged = deepMerge(
@@ -14742,13 +14931,13 @@ ${ext.value}`
     case "ArrayContent":
       return {
         ...ext,
-        elements: uniqueConcat2(target.elements, ext.elements)
+        elements: uniqueConcat3(target.elements, ext.elements)
       };
     case "MixedContent":
-      return mergeMixedContent2(target, ext);
+      return mergeMixedContent3(target, ext);
   }
 }
-function mergeMixedContent2(target, ext) {
+function mergeMixedContent3(target, ext) {
   const mergedText = target.text && ext.text ? {
     ...ext.text,
     value: `${target.text.value}
@@ -14799,7 +14988,7 @@ ${ext.value}` } : ext
   }
   return deepClone(ext);
 }
-function uniqueConcat2(parent, child) {
+function uniqueConcat3(parent, child) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (const item of [...parent, ...child]) {
@@ -14956,6 +15145,874 @@ var Resolver = class {
   }
 };
 
+// packages/resolver/src/registry.ts
+import { existsSync as existsSync3, promises as fs } from "fs";
+import { join as join3 } from "path";
+var FileSystemRegistry = class {
+  rootPath;
+  constructor(options) {
+    this.rootPath = options.rootPath;
+  }
+  /**
+   * Resolve a path relative to the registry root.
+   */
+  resolvePath(path) {
+    return join3(this.rootPath, path);
+  }
+  async fetch(path) {
+    const fullPath = this.resolvePath(path);
+    try {
+      return await fs.readFile(fullPath, "utf-8");
+    } catch (err) {
+      const error = err;
+      if (error.code === "ENOENT") {
+        throw new FileNotFoundError(fullPath);
+      }
+      throw err;
+    }
+  }
+  async exists(path) {
+    const fullPath = this.resolvePath(path);
+    return existsSync3(fullPath);
+  }
+  async list(path) {
+    const fullPath = this.resolvePath(path);
+    try {
+      const entries = await fs.readdir(fullPath, { withFileTypes: true });
+      return entries.map((e) => e.isDirectory() ? `${e.name}/` : e.name);
+    } catch {
+      return [];
+    }
+  }
+};
+var HttpRegistry = class {
+  baseUrl;
+  auth;
+  cacheEnabled;
+  cacheTtl;
+  maxRetries;
+  initialDelay;
+  timeout;
+  cache = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.auth = options.auth;
+    this.cacheEnabled = options.cache?.enabled ?? false;
+    this.cacheTtl = options.cache?.ttl ?? 3e5;
+    this.maxRetries = options.retry?.maxRetries ?? 3;
+    this.initialDelay = options.retry?.initialDelay ?? 1e3;
+    this.timeout = options.timeout ?? 3e4;
+  }
+  /**
+   * Build full URL for a path.
+   */
+  buildUrl(path) {
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    return `${this.baseUrl}${normalizedPath}`;
+  }
+  /**
+   * Build headers for request.
+   */
+  buildHeaders() {
+    const headers = {};
+    if (this.auth) {
+      if (this.auth.type === "bearer") {
+        headers["Authorization"] = `Bearer ${this.auth.token}`;
+      } else if (this.auth.type === "basic") {
+        const encoded = Buffer.from(this.auth.token).toString("base64");
+        headers["Authorization"] = `Basic ${encoded}`;
+      }
+    }
+    return headers;
+  }
+  /**
+   * Sleep for specified milliseconds.
+   */
+  sleep(ms) {
+    return new Promise((resolve7) => setTimeout(resolve7, ms));
+  }
+  /**
+   * Fetch with timeout.
+   */
+  async fetchWithTimeout(url, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      return await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Check if an error should not be retried.
+   */
+  isNonRetryableError(error) {
+    return error.isClientError === true || error.name === "AbortError";
+  }
+  /**
+   * Handle HTTP response, throwing for errors.
+   */
+  handleResponse(response) {
+    if (response.ok) {
+      return response;
+    }
+    const errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+    const error = new Error(errorMessage);
+    if (response.status >= 400 && response.status < 500) {
+      error.isClientError = true;
+    }
+    throw error;
+  }
+  /**
+   * Fetch with retry logic.
+   */
+  async fetchWithRetry(url) {
+    let lastError;
+    let delay = this.initialDelay;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const response = await this.fetchWithTimeout(url, {
+          method: "GET",
+          headers: this.buildHeaders()
+        });
+        return this.handleResponse(response);
+      } catch (err) {
+        const error = err;
+        if (this.isNonRetryableError(error)) {
+          if (error.name === "AbortError") {
+            throw new Error(`Request timeout after ${this.timeout}ms`);
+          }
+          throw error;
+        }
+        lastError = error;
+      }
+      if (attempt < this.maxRetries) {
+        await this.sleep(delay);
+        delay *= 2;
+      }
+    }
+    throw lastError ?? new Error("Unknown fetch error");
+  }
+  /**
+   * Check if cached entry is still valid.
+   */
+  isCacheValid(entry) {
+    return Date.now() - entry.timestamp < this.cacheTtl;
+  }
+  async fetch(path) {
+    if (this.cacheEnabled) {
+      const cached = this.cache.get(path);
+      if (cached && this.isCacheValid(cached)) {
+        return cached.content;
+      }
+    }
+    const url = this.buildUrl(path);
+    try {
+      const response = await this.fetchWithRetry(url);
+      const content = await response.text();
+      if (this.cacheEnabled) {
+        this.cache.set(path, {
+          content,
+          timestamp: Date.now()
+        });
+      }
+      return content;
+    } catch (err) {
+      const error = err;
+      if (error.message.includes("404")) {
+        throw new FileNotFoundError(path);
+      }
+      throw new Error(`Failed to fetch ${path}: ${error.message}`);
+    }
+  }
+  async exists(path) {
+    try {
+      const url = this.buildUrl(path);
+      const response = await this.fetchWithTimeout(url, {
+        method: "HEAD",
+        headers: this.buildHeaders()
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async list(path) {
+    const url = this.buildUrl(`${path}/.index.json`);
+    try {
+      const response = await this.fetchWithTimeout(url, {
+        method: "GET",
+        headers: this.buildHeaders()
+      });
+      if (!response.ok) {
+        return [];
+      }
+      const content = await response.text();
+      return JSON.parse(content);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Clear the cache.
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+};
+function createFileSystemRegistry(rootPath) {
+  return new FileSystemRegistry({ rootPath });
+}
+function createHttpRegistry(options) {
+  return new HttpRegistry(options);
+}
+
+// packages/resolver/src/git-registry.ts
+import { existsSync as existsSync5, promises as fs3 } from "fs";
+import { join as join5 } from "path";
+import { simpleGit } from "simple-git";
+
+// packages/resolver/src/git-cache-manager.ts
+import { existsSync as existsSync4, promises as fs2 } from "fs";
+import { join as join4 } from "path";
+import { homedir } from "os";
+
+// packages/resolver/src/git-url-utils.ts
+import { createHash } from "crypto";
+var GIT_URL_PATTERNS = {
+  // HTTPS: https://github.com/org/repo.git or https://github.com/org/repo
+  https: /^https?:\/\/(?<host>[^/:]+)(?::(?<port>\d+))?\/(?<owner>[^/]+)\/(?<repo>[^/]+?)(?:\.git)?$/,
+  // SSH: git@github.com:org/repo.git or git@github.com:org/repo
+  ssh: /^git@(?<host>[^:]+):(?<owner>[^/]+)\/(?<repo>[^/]+?)(?:\.git)?$/,
+  // Git protocol: git://github.com/org/repo.git
+  git: /^git:\/\/(?<host>[^/:]+)(?::(?<port>\d+))?\/(?<owner>[^/]+)\/(?<repo>[^/]+?)(?:\.git)?$/
+};
+function parseGitUrl(url) {
+  if (url.startsWith("git@")) {
+    const match = GIT_URL_PATTERNS.ssh.exec(url);
+    if (match?.groups) {
+      const { host, owner, repo } = match.groups;
+      if (host && owner && repo) {
+        return {
+          original: url,
+          protocol: "ssh",
+          host,
+          owner,
+          repo
+        };
+      }
+    }
+    return null;
+  }
+  if (url.startsWith("git://")) {
+    const match = GIT_URL_PATTERNS.git.exec(url);
+    if (match?.groups) {
+      const { host, owner, repo, port } = match.groups;
+      if (host && owner && repo) {
+        return {
+          original: url,
+          protocol: "git",
+          host,
+          owner,
+          repo,
+          port: port ? parseInt(port, 10) : void 0
+        };
+      }
+    }
+    return null;
+  }
+  if (url.startsWith("https://") || url.startsWith("http://")) {
+    const match = GIT_URL_PATTERNS.https.exec(url);
+    if (match?.groups) {
+      const { host, owner, repo, port } = match.groups;
+      if (host && owner && repo) {
+        return {
+          original: url,
+          protocol: "https",
+          host,
+          owner,
+          repo,
+          port: port ? parseInt(port, 10) : void 0
+        };
+      }
+    }
+  }
+  return null;
+}
+function normalizeGitUrl(url) {
+  const parsed = parseGitUrl(url);
+  if (!parsed) {
+    return url;
+  }
+  const portPart = parsed.port ? `:${parsed.port}` : "";
+  return `https://${parsed.host}${portPart}/${parsed.owner}/${parsed.repo}.git`;
+}
+function buildAuthenticatedUrl(url, token) {
+  const parsed = parseGitUrl(url);
+  if (!parsed) {
+    return url;
+  }
+  if (parsed.protocol === "ssh") {
+    return url;
+  }
+  const portPart = parsed.port ? `:${parsed.port}` : "";
+  return `https://${token}@${parsed.host}${portPart}/${parsed.owner}/${parsed.repo}.git`;
+}
+function getCacheKey(url, ref) {
+  const parsed = parseGitUrl(url);
+  if (!parsed) {
+    const hash2 = createHash("sha256").update(url).digest("hex").slice(0, 8);
+    return `unknown-${hash2}`;
+  }
+  const components = [parsed.host, parsed.owner, parsed.repo];
+  if (ref) {
+    components.push(ref);
+  }
+  const hash = createHash("sha256").update(components.join("/")).digest("hex").slice(0, 8);
+  return `${parsed.host}-${parsed.owner}-${parsed.repo}${ref ? `-${ref}` : ""}-${hash}`;
+}
+function parseVersionedPath(path) {
+  const versionMatch = /@(v?\d+(?:\.\d+)*(?:-[\w.]+)?)$/.exec(path);
+  if (versionMatch) {
+    const version = versionMatch[1];
+    const basePath = path.slice(0, -versionMatch[0].length);
+    return { path: basePath, version };
+  }
+  return { path, version: void 0 };
+}
+
+// packages/resolver/src/git-cache-manager.ts
+var DEFAULT_CACHE_DIR = join4(homedir(), ".promptscript", ".cache", "git");
+var DEFAULT_TTL = 36e5;
+var METADATA_FILE = ".prs-cache-meta.json";
+var GitCacheManager = class {
+  cacheDir;
+  ttl;
+  constructor(options = {}) {
+    this.cacheDir = options.cacheDir ?? DEFAULT_CACHE_DIR;
+    this.ttl = options.ttl ?? DEFAULT_TTL;
+  }
+  /**
+   * Get the cache directory for a given URL and ref.
+   *
+   * @param url - Git repository URL
+   * @param ref - Git ref (branch/tag/commit)
+   * @returns Path to the cache directory
+   */
+  getCachePath(url, ref) {
+    const cacheKey = getCacheKey(url, ref);
+    return join4(this.cacheDir, cacheKey);
+  }
+  /**
+   * Check if a cache entry exists and is not stale.
+   *
+   * @param url - Git repository URL
+   * @param ref - Git ref (branch/tag/commit)
+   * @returns True if cache is valid (exists and not stale)
+   */
+  async isValid(url, ref) {
+    const entry = await this.get(url, ref);
+    return entry !== null && !entry.isStale;
+  }
+  /**
+   * Get a cache entry if it exists.
+   *
+   * @param url - Git repository URL
+   * @param ref - Git ref (branch/tag/commit)
+   * @returns Cache entry or null if not found
+   */
+  async get(url, ref) {
+    const cachePath = this.getCachePath(url, ref);
+    if (!existsSync4(cachePath)) {
+      return null;
+    }
+    const metadata = await this.readMetadata(cachePath);
+    if (!metadata) {
+      return null;
+    }
+    const isStale = Date.now() - metadata.lastUpdated > this.ttl;
+    return {
+      path: cachePath,
+      metadata,
+      isStale
+    };
+  }
+  /**
+   * Create or update a cache entry.
+   *
+   * @param url - Git repository URL
+   * @param ref - Git ref (branch/tag/commit)
+   * @param commitHash - Current commit hash
+   * @returns Path to the cache directory
+   */
+  async set(url, ref, commitHash) {
+    const cachePath = this.getCachePath(url, ref);
+    await fs2.mkdir(cachePath, { recursive: true });
+    const existingMetadata = await this.readMetadata(cachePath);
+    const now = Date.now();
+    const metadata = {
+      url,
+      ref,
+      commitHash,
+      lastUpdated: now,
+      createdAt: existingMetadata?.createdAt ?? now,
+      version: 1
+    };
+    await this.writeMetadata(cachePath, metadata);
+    return cachePath;
+  }
+  /**
+   * Update the lastUpdated timestamp for an existing cache entry.
+   *
+   * @param url - Git repository URL
+   * @param ref - Git ref (branch/tag/commit)
+   * @param commitHash - Optional new commit hash (if fetch resulted in update)
+   */
+  async touch(url, ref, commitHash) {
+    const cachePath = this.getCachePath(url, ref);
+    const metadata = await this.readMetadata(cachePath);
+    if (!metadata) {
+      throw new Error(`Cache entry not found: ${cachePath}`);
+    }
+    metadata.lastUpdated = Date.now();
+    if (commitHash) {
+      metadata.commitHash = commitHash;
+    }
+    await this.writeMetadata(cachePath, metadata);
+  }
+  /**
+   * Remove a cache entry.
+   *
+   * @param url - Git repository URL
+   * @param ref - Git ref (branch/tag/commit)
+   */
+  async remove(url, ref) {
+    const cachePath = this.getCachePath(url, ref);
+    if (existsSync4(cachePath)) {
+      await fs2.rm(cachePath, { recursive: true, force: true });
+    }
+  }
+  /**
+   * List all cache entries.
+   *
+   * @returns Array of cache entries
+   */
+  async list() {
+    if (!existsSync4(this.cacheDir)) {
+      return [];
+    }
+    const entries = [];
+    const dirs = await fs2.readdir(this.cacheDir, { withFileTypes: true });
+    for (const dir of dirs) {
+      if (!dir.isDirectory()) {
+        continue;
+      }
+      const cachePath = join4(this.cacheDir, dir.name);
+      const metadata = await this.readMetadata(cachePath);
+      if (metadata) {
+        const isStale = Date.now() - metadata.lastUpdated > this.ttl;
+        entries.push({ path: cachePath, metadata, isStale });
+      }
+    }
+    return entries;
+  }
+  /**
+   * Remove all stale cache entries.
+   *
+   * @returns Number of entries removed
+   */
+  async cleanupStale() {
+    const entries = await this.list();
+    const staleEntries = entries.filter((e) => e.isStale);
+    for (const entry of staleEntries) {
+      await fs2.rm(entry.path, { recursive: true, force: true });
+    }
+    return staleEntries.length;
+  }
+  /**
+   * Remove all cache entries.
+   */
+  async clear() {
+    if (existsSync4(this.cacheDir)) {
+      await fs2.rm(this.cacheDir, { recursive: true, force: true });
+    }
+  }
+  /**
+   * Get the total size of the cache in bytes.
+   *
+   * @returns Total cache size in bytes
+   */
+  async getSize() {
+    if (!existsSync4(this.cacheDir)) {
+      return 0;
+    }
+    return this.calculateDirSize(this.cacheDir);
+  }
+  /**
+   * Calculate the size of a directory recursively.
+   */
+  async calculateDirSize(dirPath) {
+    let size = 0;
+    const entries = await fs2.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join4(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        size += await this.calculateDirSize(fullPath);
+      } else {
+        const stat = await fs2.stat(fullPath);
+        size += stat.size;
+      }
+    }
+    return size;
+  }
+  /**
+   * Read metadata from a cache directory.
+   */
+  async readMetadata(cachePath) {
+    const metadataPath = join4(cachePath, METADATA_FILE);
+    if (!existsSync4(metadataPath)) {
+      return null;
+    }
+    try {
+      const content = await fs2.readFile(metadataPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Write metadata to a cache directory.
+   */
+  async writeMetadata(cachePath, metadata) {
+    const metadataPath = join4(cachePath, METADATA_FILE);
+    await fs2.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+  }
+};
+
+// packages/resolver/src/git-registry.ts
+var GitCloneError = class extends Error {
+  constructor(message, url, cause) {
+    super(message, { cause });
+    this.url = url;
+    this.name = "GitCloneError";
+    this.cause = cause;
+  }
+  cause;
+};
+var GitAuthError = class extends Error {
+  constructor(message, url, cause) {
+    super(message, { cause });
+    this.url = url;
+    this.name = "GitAuthError";
+    this.cause = cause;
+  }
+  cause;
+};
+var GitRefNotFoundError = class extends Error {
+  constructor(ref, url) {
+    super(`Git ref not found: ${ref} in ${url}`);
+    this.ref = ref;
+    this.url = url;
+    this.name = "GitRefNotFoundError";
+  }
+};
+var GitRegistry = class {
+  url;
+  originalUrl;
+  defaultRef;
+  subPath;
+  auth;
+  cacheEnabled;
+  timeout;
+  cacheManager;
+  initialized = false;
+  constructor(options) {
+    this.originalUrl = options.url;
+    this.url = normalizeGitUrl(options.url);
+    this.defaultRef = options.ref ?? "main";
+    this.subPath = options.path ?? "";
+    this.auth = options.auth;
+    this.cacheEnabled = options.cache?.enabled ?? true;
+    this.timeout = options.timeout ?? 6e4;
+    this.cacheManager = new GitCacheManager({
+      cacheDir: options.cacheDir,
+      ttl: options.cache?.ttl
+    });
+  }
+  /**
+   * Fetch the content of a file from the registry.
+   *
+   * @param path - Path to the file (may include version tag)
+   * @returns File content as string
+   * @throws FileNotFoundError if the file doesn't exist
+   * @throws GitCloneError if cloning fails
+   * @throws GitRefNotFoundError if the ref doesn't exist
+   */
+  async fetch(path) {
+    const { path: basePath, version } = parseVersionedPath(path);
+    const ref = version ?? this.defaultRef;
+    const repoPath = await this.ensureCloned(ref);
+    const filePath = this.resolveFilePath(repoPath, basePath);
+    if (!existsSync5(filePath)) {
+      throw new FileNotFoundError(path);
+    }
+    return fs3.readFile(filePath, "utf-8");
+  }
+  /**
+   * Check if a file exists in the registry.
+   *
+   * @param path - Path to check (may include version tag)
+   * @returns True if the file exists
+   */
+  async exists(path) {
+    try {
+      const { path: basePath, version } = parseVersionedPath(path);
+      const ref = version ?? this.defaultRef;
+      const repoPath = await this.ensureCloned(ref);
+      const filePath = this.resolveFilePath(repoPath, basePath);
+      return existsSync5(filePath);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * List files in a directory.
+   *
+   * @param path - Directory path (may include version tag)
+   * @returns Array of file/directory names
+   */
+  async list(path) {
+    try {
+      const { path: basePath, version } = parseVersionedPath(path);
+      const ref = version ?? this.defaultRef;
+      const repoPath = await this.ensureCloned(ref);
+      const dirPath = this.resolveDirectoryPath(repoPath, basePath);
+      if (!existsSync5(dirPath)) {
+        return [];
+      }
+      const entries = await fs3.readdir(dirPath, { withFileTypes: true });
+      return entries.map((e) => e.isDirectory() ? `${e.name}/` : e.name);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Force refresh the cache for a specific ref.
+   *
+   * @param ref - Git ref to refresh (defaults to defaultRef)
+   */
+  async refresh(ref) {
+    const targetRef = ref ?? this.defaultRef;
+    await this.cacheManager.remove(this.url, targetRef);
+    await this.ensureCloned(targetRef);
+  }
+  /**
+   * Get the current commit hash for a ref.
+   *
+   * @param ref - Git ref (defaults to defaultRef)
+   * @returns Commit hash
+   */
+  async getCommitHash(ref) {
+    const targetRef = ref ?? this.defaultRef;
+    const repoPath = await this.ensureCloned(targetRef);
+    const git = this.createGit(repoPath);
+    const result = await git.revparse(["HEAD"]);
+    return result.trim();
+  }
+  /**
+   * Ensure the repository is cloned and at the correct ref.
+   */
+  async ensureCloned(ref) {
+    if (this.cacheEnabled) {
+      const entry = await this.cacheManager.get(this.url, ref);
+      if (entry && !entry.isStale) {
+        return entry.path;
+      }
+      if (entry) {
+        try {
+          await this.fetchUpdates(entry.path, ref);
+          const commitHash2 = await this.getCurrentCommit(entry.path);
+          await this.cacheManager.touch(this.url, ref, commitHash2);
+          return entry.path;
+        } catch {
+          await this.cacheManager.remove(this.url, ref);
+        }
+      }
+    }
+    const cachePath = this.cacheManager.getCachePath(this.url, ref);
+    await this.clone(cachePath, ref);
+    const commitHash = await this.getCurrentCommit(cachePath);
+    await this.cacheManager.set(this.url, ref, commitHash);
+    return cachePath;
+  }
+  /**
+   * Clone the repository to the specified path.
+   */
+  async clone(targetPath, ref) {
+    if (existsSync5(targetPath)) {
+      await fs3.rm(targetPath, { recursive: true, force: true });
+    }
+    await fs3.mkdir(targetPath, { recursive: true });
+    const cloneUrl = this.getAuthenticatedUrl();
+    const git = this.createGit();
+    try {
+      await git.clone(cloneUrl, targetPath, ["--depth=1", `--branch=${ref}`, "--single-branch"]);
+    } catch (err) {
+      const error = err;
+      if (this.isAuthError(error)) {
+        throw new GitAuthError(`Authentication failed for ${this.url}`, this.url, error);
+      }
+      if (this.isRefError(error)) {
+        try {
+          await git.clone(cloneUrl, targetPath, ["--depth=1"]);
+          const repoGit = this.createGit(targetPath);
+          await repoGit.fetch(["origin", ref, "--depth=1"]);
+          await repoGit.checkout(ref);
+        } catch (fetchErr) {
+          const fetchError = fetchErr;
+          if (this.isRefError(fetchError)) {
+            throw new GitRefNotFoundError(ref, this.url);
+          }
+          throw new GitCloneError(
+            `Failed to clone repository: ${fetchError.message}`,
+            this.url,
+            fetchError
+          );
+        }
+        return;
+      }
+      throw new GitCloneError(`Failed to clone repository: ${error.message}`, this.url, error);
+    }
+  }
+  /**
+   * Fetch updates for an existing clone.
+   */
+  async fetchUpdates(repoPath, ref) {
+    const git = this.createGit(repoPath);
+    try {
+      await git.fetch(["origin", ref, "--depth=1"]);
+      await git.checkout(ref);
+      await git.reset(["--hard", `origin/${ref}`]);
+    } catch (err) {
+      const error = err;
+      if (this.isRefError(error)) {
+        try {
+          await git.fetch(["origin", "--tags", "--depth=1"]);
+          await git.checkout(ref);
+          return;
+        } catch {
+          throw new GitRefNotFoundError(ref, this.url);
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get the current commit hash of a repository.
+   */
+  async getCurrentCommit(repoPath) {
+    const git = this.createGit(repoPath);
+    const result = await git.revparse(["HEAD"]);
+    return result.trim();
+  }
+  /**
+   * Build the authenticated URL for cloning.
+   */
+  getAuthenticatedUrl() {
+    if (!this.auth) {
+      return this.url;
+    }
+    if (this.auth.type === "token") {
+      const token = this.resolveToken();
+      if (token) {
+        return buildAuthenticatedUrl(this.url, token);
+      }
+    }
+    return this.url;
+  }
+  /**
+   * Resolve the authentication token.
+   */
+  resolveToken() {
+    if (this.auth?.token) {
+      return this.auth.token;
+    }
+    if (this.auth?.tokenEnvVar) {
+      return process.env[this.auth.tokenEnvVar];
+    }
+    return void 0;
+  }
+  /**
+   * Create a simple-git instance.
+   */
+  createGit(baseDir) {
+    const options = {
+      timeout: {
+        block: this.timeout
+      }
+    };
+    if (baseDir) {
+      options.baseDir = baseDir;
+    }
+    const git = simpleGit(options);
+    if (this.auth?.type === "ssh" && this.auth.sshKeyPath) {
+      const parsed = parseGitUrl(this.originalUrl);
+      if (parsed?.protocol === "ssh") {
+        git.env("GIT_SSH_COMMAND", `ssh -i ${this.auth.sshKeyPath} -o StrictHostKeyChecking=no`);
+      }
+    }
+    return git;
+  }
+  /**
+   * Resolve a file path within the repository.
+   *
+   * Note: The @ prefix is preserved as it's part of the directory name
+   * (e.g., @core/base.prs lives in a directory literally named "@core")
+   */
+  resolveFilePath(repoPath, relativePath) {
+    let cleanPath = relativePath;
+    if (!cleanPath.endsWith(".prs") && !cleanPath.endsWith("/")) {
+      cleanPath += ".prs";
+    }
+    if (this.subPath) {
+      return join5(repoPath, this.subPath, cleanPath);
+    }
+    return join5(repoPath, cleanPath);
+  }
+  /**
+   * Resolve a directory path within the repository.
+   *
+   * Note: The @ prefix is preserved as it's part of the directory name
+   * (e.g., @core lives in a directory literally named "@core")
+   */
+  resolveDirectoryPath(repoPath, relativePath) {
+    if (this.subPath) {
+      return join5(repoPath, this.subPath, relativePath);
+    }
+    return join5(repoPath, relativePath);
+  }
+  /**
+   * Check if an error is an authentication error.
+   */
+  isAuthError(error) {
+    const message = error.message.toLowerCase();
+    return message.includes("authentication") || message.includes("permission denied") || message.includes("could not read from remote") || message.includes("invalid credentials") || message.includes("401") || message.includes("403");
+  }
+  /**
+   * Check if an error is a ref not found error.
+   */
+  isRefError(error) {
+    const message = error.message.toLowerCase();
+    return message.includes("could not find remote branch") || message.includes("couldn't find remote ref") || message.includes("pathspec") || message.includes("did not match any") || message.includes("not found in upstream");
+  }
+};
+function createGitRegistry(options) {
+  return new GitRegistry(options);
+}
+
 // packages/validator/src/rules/required-meta.ts
 var requiredMetaId = {
   id: "PS001",
@@ -15501,6 +16558,11 @@ var Compiler = class _Compiler {
         const formatOptions = this.getFormatOptionsForTarget(formatter.name, config);
         const output = formatter.format(resolved.ast, formatOptions);
         outputs.set(output.path, output);
+        if (output.additionalFiles) {
+          for (const additionalFile of output.additionalFiles) {
+            outputs.set(additionalFile.path, additionalFile);
+          }
+        }
       } catch (err) {
         formatErrors.push({
           name: "FormatterError",
@@ -15793,7 +16855,7 @@ async function compileCommand(options) {
       customConventions: config.customConventions
     });
     const entryPath = resolve2("./.promptscript/project.prs");
-    if (!existsSync3(entryPath)) {
+    if (!existsSync6(entryPath)) {
       spinner.fail("Entry file not found");
       ConsoleOutput.error(`File not found: ${entryPath}`);
       ConsoleOutput.muted("Run: prs init");
@@ -15858,7 +16920,7 @@ function watchForChanges(dir, callback) {
 
 // packages/cli/src/commands/validate.ts
 import { resolve as resolve3 } from "path";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 function printValidationErrors(errors) {
   if (errors.length === 0) return;
   console.log(`Errors (${errors.length}):`);
@@ -15949,7 +17011,7 @@ async function validateCommand(options) {
       // No formatters needed for validation only
     });
     const entryPath = resolve3("./.promptscript/project.prs");
-    if (!existsSync4(entryPath)) {
+    if (!existsSync7(entryPath)) {
       handleEntryNotFound(entryPath, isJsonFormat, spinner);
     }
     const result = await compiler.compile(entryPath);
@@ -15988,37 +17050,33 @@ function outputJsonResult(result) {
 }
 
 // packages/cli/src/commands/pull.ts
-import { mkdir as mkdir3, writeFile as writeFile3, readFile as readFile4 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
 import { resolve as resolve4, dirname as dirname4 } from "path";
 async function pullCommand(options) {
   const spinner = createSpinner("Loading configuration...").start();
   try {
     const config = await loadConfig();
-    if (config.registry?.url) {
-      spinner.fail("Remote registry not yet supported");
-      ConsoleOutput.error("Remote registry support coming soon");
-      ConsoleOutput.muted("For now, use a local registry path in your config.");
-      process.exit(1);
-    }
     if (!config.inherit) {
       spinner.warn("No inheritance configured");
       ConsoleOutput.muted('Add "inherit" to your config to pull from registry');
       return;
     }
     spinner.text = `Pulling ${config.inherit}...`;
-    const registryPath = config.registry?.path ?? "./registry";
+    const registry = await createRegistry(config, options, spinner);
     const inheritPath = parseInheritPath(config.inherit);
-    const sourcePath = resolve4(registryPath, inheritPath);
-    if (!existsSync5(sourcePath)) {
+    spinner.text = `Checking ${inheritPath}...`;
+    const exists = await registry.exists(inheritPath);
+    if (!exists) {
       spinner.fail("Inheritance source not found");
-      ConsoleOutput.error(`Not found: ${sourcePath}`);
-      ConsoleOutput.muted("Make sure the registry path is correct and the file exists");
+      ConsoleOutput.error(`Not found in registry: ${config.inherit}`);
+      ConsoleOutput.muted("Make sure the registry is configured correctly and the file exists");
       process.exit(1);
     }
-    const content = await readFile4(sourcePath, "utf-8");
+    spinner.text = `Fetching ${inheritPath}...`;
+    const content = await registry.fetch(inheritPath);
     const destPath = resolve4("./.promptscript/.inherited", inheritPath);
-    if (existsSync5(destPath) && !options.force && !options.dryRun) {
+    if (existsSync8(destPath) && !options.force && !options.dryRun) {
       spinner.warn("File already exists (use --force to overwrite)");
       ConsoleOutput.muted(destPath);
       return;
@@ -16026,9 +17084,9 @@ async function pullCommand(options) {
     if (options.dryRun) {
       spinner.succeed("Dry run completed");
       ConsoleOutput.newline();
-      ConsoleOutput.dryRun(`Would copy: ${sourcePath}`);
+      ConsoleOutput.dryRun(`Would fetch: ${config.inherit}`);
       ConsoleOutput.dryRun(`       to: ${destPath}`);
-      if (existsSync5(destPath)) {
+      if (existsSync8(destPath)) {
         ConsoleOutput.dryRun("(would overwrite existing file)");
       }
       return;
@@ -16038,23 +17096,97 @@ async function pullCommand(options) {
     spinner.succeed("Pulled from registry");
     ConsoleOutput.success(destPath);
   } catch (error) {
-    spinner.fail("Error");
-    ConsoleOutput.error(error.message);
+    handlePullError(error, spinner);
     process.exit(1);
   }
 }
+async function createRegistry(config, options, spinner) {
+  const gitRef = options.commit ?? options.tag ?? options.branch;
+  if (config.registry?.git) {
+    const gitConfig = config.registry.git;
+    spinner.text = `Connecting to Git registry: ${gitConfig.url}...`;
+    return createGitRegistry({
+      url: gitConfig.url,
+      ref: gitRef ?? gitConfig.ref,
+      path: gitConfig.path,
+      auth: gitConfig.auth,
+      cache: {
+        enabled: !options.refresh && (config.registry.cache?.enabled ?? true),
+        ttl: config.registry.cache?.ttl
+      }
+    });
+  }
+  if (config.registry?.url) {
+    spinner.text = `Connecting to HTTP registry: ${config.registry.url}...`;
+    const httpAuth = config.registry.auth;
+    let token;
+    if (httpAuth) {
+      token = httpAuth.token ?? (httpAuth.tokenEnvVar ? process.env[httpAuth.tokenEnvVar] : void 0);
+    }
+    return createHttpRegistry({
+      baseUrl: config.registry.url,
+      auth: httpAuth && token ? { type: httpAuth.type, token } : void 0,
+      cache: {
+        enabled: config.registry.cache?.enabled ?? true,
+        ttl: config.registry.cache?.ttl ?? 3e5
+      }
+    });
+  }
+  const registryPath = config.registry?.path ?? "./registry";
+  spinner.text = `Using local registry: ${registryPath}...`;
+  if (!existsSync8(registryPath)) {
+    throw new Error(`Local registry path not found: ${registryPath}`);
+  }
+  return createFileSystemRegistry(resolve4(registryPath));
+}
 function parseInheritPath(inheritPath) {
-  let path = inheritPath.startsWith("@") ? inheritPath.slice(1) : inheritPath;
+  const versionIndex = inheritPath.lastIndexOf("@");
+  const atIndex = inheritPath.indexOf("@");
+  let pathWithoutVersion = inheritPath;
+  if (versionIndex > atIndex && versionIndex !== atIndex) {
+    pathWithoutVersion = inheritPath.slice(0, versionIndex);
+  }
+  let path = pathWithoutVersion.startsWith("@") ? pathWithoutVersion.slice(1) : pathWithoutVersion;
   if (!path.endsWith(".prs")) {
     path += ".prs";
   }
   return path;
 }
+function handlePullError(error, spinner) {
+  if (error instanceof GitAuthError) {
+    spinner.fail("Git authentication failed");
+    ConsoleOutput.error(error.message);
+    ConsoleOutput.muted("Check your authentication configuration:");
+    ConsoleOutput.muted("  - For token auth: ensure GITHUB_TOKEN or tokenEnvVar is set");
+    ConsoleOutput.muted("  - For SSH auth: ensure SSH key is configured and accessible");
+    return;
+  }
+  if (error instanceof GitRefNotFoundError) {
+    spinner.fail("Git ref not found");
+    ConsoleOutput.error(error.message);
+    ConsoleOutput.muted("Available options:");
+    ConsoleOutput.muted("  - Use --branch <name> to specify a branch");
+    ConsoleOutput.muted("  - Use --tag <name> to specify a tag");
+    ConsoleOutput.muted("  - Use --commit <hash> to specify a commit");
+    return;
+  }
+  if (error instanceof GitCloneError) {
+    spinner.fail("Git clone failed");
+    ConsoleOutput.error(error.message);
+    ConsoleOutput.muted("Possible causes:");
+    ConsoleOutput.muted("  - Network connectivity issues");
+    ConsoleOutput.muted("  - Invalid repository URL");
+    ConsoleOutput.muted("  - Missing authentication for private repository");
+    return;
+  }
+  spinner.fail("Error");
+  ConsoleOutput.error(error.message);
+}
 
 // packages/cli/src/commands/diff.ts
 import { resolve as resolve5 } from "path";
-import { readFile as readFile5 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+import { existsSync as existsSync9 } from "fs";
 
 // packages/cli/src/output/pager.ts
 import { spawn } from "child_process";
@@ -16170,14 +17302,14 @@ function printNewFilePreview(content, showFull, pager) {
 async function compareOutput(_name, output, _config, showFull, pager) {
   const outputPath = resolve5(output.path);
   const newContent = output.content;
-  if (!existsSync6(outputPath)) {
+  if (!existsSync9(outputPath)) {
     pager.write(chalk2.green(`+ ${outputPath} (new file)`));
     pager.write("");
     printNewFilePreview(newContent, showFull, pager);
     pager.write("");
     return true;
   }
-  const existingContent = await readFile5(outputPath, "utf-8");
+  const existingContent = await readFile4(outputPath, "utf-8");
   if (existingContent === newContent) {
     pager.write(chalk2.gray(`  ${outputPath} (no changes)`));
     return false;
@@ -16207,7 +17339,7 @@ async function diffCommand(options) {
       customConventions: config.customConventions
     });
     const entryPath = resolve5("./.promptscript/project.prs");
-    if (!existsSync6(entryPath)) {
+    if (!existsSync9(entryPath)) {
       spinner.fail("Entry file not found");
       ConsoleOutput.error(`File not found: ${entryPath}`);
       ConsoleOutput.muted("Run: prs init");
@@ -16273,7 +17405,7 @@ function printSimpleDiff(existingLines, newLines, showFull, pager) {
 }
 
 // packages/cli/src/commands/check.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { resolve as resolve6 } from "path";
 async function checkCommand(_options) {
   const spinner = createSpinner("Checking project health...").start();
@@ -16336,7 +17468,7 @@ async function checkCommand(_options) {
       });
     }
     const entryPath = config.input?.entry ?? ".promptscript/project.prs";
-    if (existsSync7(entryPath)) {
+    if (existsSync10(entryPath)) {
       results.push({
         name: "Entry file",
         status: "ok",
@@ -16352,7 +17484,7 @@ async function checkCommand(_options) {
     }
     if (config.registry?.path) {
       const registryPath = resolve6(config.registry.path);
-      if (existsSync7(registryPath)) {
+      if (existsSync10(registryPath)) {
         results.push({
           name: "Registry path",
           status: "ok",
@@ -16451,7 +17583,7 @@ program.name("prs").description("PromptScript CLI - Standardize AI instructions"
 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").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").action(compileCommand);
 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").action(pullCommand);
+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);
 function run(args = process.argv) {