@packmind/cli 0.13.1 → 0.14.1

package/main.cjs

@@ -371,32 +371,32 @@ var init_supports_color = __esm({
 });
 
 // node_modules/chalk/source/utilities.js
-function stringReplaceAll(string6, substring, replacer) {
-  let index = string6.indexOf(substring);
+function stringReplaceAll(string8, substring, replacer) {
+  let index = string8.indexOf(substring);
   if (index === -1) {
-    return string6;
+    return string8;
   }
   const substringLength = substring.length;
   let endIndex = 0;
   let returnValue = "";
   do {
-    returnValue += string6.slice(endIndex, index) + substring + replacer;
+    returnValue += string8.slice(endIndex, index) + substring + replacer;
     endIndex = index + substringLength;
-    index = string6.indexOf(substring, endIndex);
+    index = string8.indexOf(substring, endIndex);
   } while (index !== -1);
-  returnValue += string6.slice(endIndex);
+  returnValue += string8.slice(endIndex);
   return returnValue;
 }
-function stringEncaseCRLFWithFirstIndex(string6, prefix, postfix, index) {
+function stringEncaseCRLFWithFirstIndex(string8, prefix, postfix, index) {
   let endIndex = 0;
   let returnValue = "";
   do {
-    const gotCR = string6[index - 1] === "\r";
-    returnValue += string6.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    const gotCR = string8[index - 1] === "\r";
+    returnValue += string8.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
     endIndex = index + 1;
-    index = string6.indexOf("\n", endIndex);
+    index = string8.indexOf("\n", endIndex);
   } while (index !== -1);
-  returnValue += string6.slice(endIndex);
+  returnValue += string8.slice(endIndex);
   return returnValue;
 }
 var init_utilities = __esm({
@@ -555,26 +555,26 @@ var init_source = __esm({
       builder[IS_EMPTY] = _isEmpty;
       return builder;
     };
-    applyStyle = (self, string6) => {
-      if (self.level <= 0 || !string6) {
-        return self[IS_EMPTY] ? "" : string6;
+    applyStyle = (self, string8) => {
+      if (self.level <= 0 || !string8) {
+        return self[IS_EMPTY] ? "" : string8;
       }
       let styler = self[STYLER];
       if (styler === void 0) {
-        return string6;
+        return string8;
       }
       const { openAll, closeAll } = styler;
-      if (string6.includes("\x1B")) {
+      if (string8.includes("\x1B")) {
         while (styler !== void 0) {
-          string6 = stringReplaceAll(string6, styler.close, styler.open);
+          string8 = stringReplaceAll(string8, styler.close, styler.open);
           styler = styler.parent;
         }
       }
-      const lfIndex = string6.indexOf("\n");
+      const lfIndex = string8.indexOf("\n");
       if (lfIndex !== -1) {
-        string6 = stringEncaseCRLFWithFirstIndex(string6, closeAll, openAll, lfIndex);
+        string8 = stringEncaseCRLFWithFirstIndex(string8, closeAll, openAll, lfIndex);
       }
-      return openAll + string6 + closeAll;
+      return openAll + string8 + closeAll;
     };
     Object.defineProperties(createChalk.prototype, styles2);
     chalk = createChalk();
@@ -1255,7 +1255,7 @@ var require_positional = __commonJS({
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.positional = positional3;
+    exports2.positional = positional5;
     var chalk_1 = __importDefault((init_source(), __toCommonJS(source_exports)));
     var Result = __importStar(require_Result());
     var types_1 = require_types();
@@ -1295,8 +1295,8 @@ var require_positional = __commonJS({
           var _a2;
           const positionals = nodes.filter((node) => node.type === "positionalArgument" && !visitedNodes.has(node));
           const defaultValueFn = (_a2 = config.defaultValue) !== null && _a2 !== void 0 ? _a2 : config.type.defaultValue;
-          const positional4 = positionals[0];
-          if (!positional4) {
+          const positional6 = positionals[0];
+          if (!positional6) {
             if (defaultValueFn) {
               return Result.ok(defaultValueFn());
             }
@@ -1309,13 +1309,13 @@ var require_positional = __commonJS({
               ]
             });
           }
-          visitedNodes.add(positional4);
-          const decoded = await Result.safeAsync(config.type.from(positional4.raw));
+          visitedNodes.add(positional6);
+          const decoded = await Result.safeAsync(config.type.from(positional6.raw));
           if (Result.isErr(decoded)) {
             return Result.err({
               errors: [
                 {
-                  nodes: [positional4],
+                  nodes: [positional6],
                   message: decoded.error.message
                 }
               ]
@@ -1325,7 +1325,7 @@ var require_positional = __commonJS({
         }
       };
     }
-    function positional3(config) {
+    function positional5(config) {
       return fullPositional({
         type: types_1.string,
         ...config
@@ -1379,13 +1379,13 @@ var require_subcommands = __commonJS({
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.subcommands = subcommands3;
+    exports2.subcommands = subcommands5;
     var chalk_1 = __importDefault((init_source(), __toCommonJS(source_exports)));
     var didyoumean_1 = __importDefault(require_didYouMean_1_2_1());
     var Result = __importStar(require_Result());
     var circuitbreaker_1 = require_circuitbreaker();
     var positional_1 = require_positional();
-    function subcommands3(config) {
+    function subcommands5(config) {
       const circuitbreaker = (0, circuitbreaker_1.createCircuitBreaker)(!!config.version);
       const type = {
         async from(str) {
@@ -1578,11 +1578,11 @@ var strip_ansi_exports = {};
 __export(strip_ansi_exports, {
   default: () => stripAnsi
 });
-function stripAnsi(string6) {
-  if (typeof string6 !== "string") {
-    throw new TypeError(`Expected a \`string\`, got \`${typeof string6}\``);
+function stripAnsi(string8) {
+  if (typeof string8 !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string8}\``);
   }
-  return string6.replace(regex, "");
+  return string8.replace(regex, "");
 }
 var regex;
 var init_strip_ansi = __esm({
@@ -1698,12 +1698,12 @@ var require_command = __commonJS({
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.command = command9;
+    exports2.command = command12;
     var chalk_1 = __importDefault((init_source(), __toCommonJS(source_exports)));
     var Result = __importStar(require_Result());
     var circuitbreaker_1 = require_circuitbreaker();
     var utils_1 = require_utils();
-    function command9(config) {
+    function command12(config) {
       const argEntries = (0, utils_1.entries)(config.args);
       const circuitbreaker = (0, circuitbreaker_1.createCircuitBreaker)(!!config.version);
       return {
@@ -3084,8 +3084,8 @@ var require_tokenizer = __commonJS({
         tokens.push(token);
         overallIndex += token.raw.length;
       };
-      for (const [stringIndex, string6] of (0, utils_1.enumerate)(strings)) {
-        const chars = [...string6];
+      for (const [stringIndex, string8] of (0, utils_1.enumerate)(strings)) {
+        const chars = [...string8];
         for (let i = 0; i < chars.length; i++) {
           if (chars[i] === "-" && chars[i + 1] === "-") {
             push({ type: "longPrefix", raw: "--", index: overallIndex });
@@ -3241,14 +3241,14 @@ var require_restPositionals = __commonJS({
           const positionals = nodes.filter((node) => node.type === "positionalArgument" && !visitedNodes.has(node));
           const results = [];
           const errors = [];
-          for (const positional3 of positionals) {
-            visitedNodes.add(positional3);
-            const decoded = await Result.safeAsync(config.type.from(positional3.raw));
+          for (const positional5 of positionals) {
+            visitedNodes.add(positional5);
+            const decoded = await Result.safeAsync(config.type.from(positional5.raw));
             if (Result.isOk(decoded)) {
               results.push(decoded.value);
             } else {
               errors.push({
-                nodes: [positional3],
+                nodes: [positional5],
                 message: decoded.error.message
               });
             }
@@ -3852,7 +3852,7 @@ var require_package = __commonJS({
   "apps/cli/package.json"(exports2, module2) {
     module2.exports = {
       name: "@packmind/cli",
-      version: "0.13.1",
+      version: "0.14.1",
       description: "A command-line interface for Packmind linting and code quality checks",
       private: false,
       bin: {
@@ -3887,14 +3887,15 @@ var require_package = __commonJS({
       },
       dependencies: {
         "@types/inquirer": "^9.0.9",
-        inquirer: "^13.0.2"
+        inquirer: "^13.0.2",
+        zod: "^4.3.5"
       }
     };
   }
 });
 
 // apps/cli/src/main.ts
-var import_cmd_ts10 = __toESM(require_cjs());
+var import_cmd_ts15 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/LinterCommand.ts
 var import_cmd_ts = __toESM(require_cjs());
@@ -4048,6 +4049,13 @@ var AnonymousTrialAccountActivatedEvent = class extends UserEvent {
   }
 };
 
+// packages/types/src/accounts/events/OrganizationCreatedEvent.ts
+var OrganizationCreatedEvent = class extends UserEvent {
+  static {
+    this.eventName = "accounts.organization.created";
+  }
+};
+
 // packages/types/src/accounts/TrialActivationToken.ts
 var createTrialActivationTokenId = brandedIdFactory();
 var createTrialActivationToken = brandedIdFactory();
@@ -4735,6 +4743,17 @@ function createUserContextChangeEvent(userId, organizationId, changeType, role)
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
+function createDistributionStatusChangeEvent(distributionId, status, organizationId) {
+  return {
+    type: "DISTRIBUTION_STATUS_CHANGE",
+    data: {
+      distributionId,
+      status,
+      organizationId
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
 
 // apps/cli/src/application/useCases/ExecuteSingleFileAstUseCase.ts
 var ExecuteSingleFileAstUseCase = class _ExecuteSingleFileAstUseCase {
@@ -4747,8 +4766,8 @@ var ExecuteSingleFileAstUseCase = class _ExecuteSingleFileAstUseCase {
   static {
     this.fallbackRuleContent = "adhoc-rule";
   }
-  async execute(command9) {
-    const { program, fileContent, language } = command9;
+  async execute(command12) {
+    const { program, fileContent, language } = command12;
     const result = await this.linterExecutionUseCase.execute({
       filePath: "cli-single-file",
       fileContent,
@@ -4798,30 +4817,30 @@ var GitService = class {
     this.gitRunner = gitRunner;
     this.logger = logger2;
   }
-  getGitRepositoryRoot(path12) {
+  getGitRepositoryRoot(path13) {
     try {
       const { stdout } = this.gitRunner("rev-parse --show-toplevel", {
-        cwd: path12
+        cwd: path13
       });
       const gitRoot = stdout.trim();
       this.logger.debug("Resolved git repository root", {
-        inputPath: path12,
+        inputPath: path13,
         gitRoot
       });
       return gitRoot;
     } catch (error) {
       if (error instanceof Error) {
         throw new Error(
-          `Failed to get Git repository root. The path '${path12}' does not appear to be inside a Git repository.
+          `Failed to get Git repository root. The path '${path13}' does not appear to be inside a Git repository.
 ${error.message}`
         );
       }
       throw new Error("Failed to get Git repository root: Unknown error");
     }
   }
-  tryGetGitRepositoryRoot(path12) {
+  tryGetGitRepositoryRoot(path13) {
     try {
-      return this.getGitRepositoryRoot(path12);
+      return this.getGitRepositoryRoot(path13);
     } catch {
       return null;
     }
@@ -5128,8 +5147,8 @@ var GetGitRemoteUrlUseCase = class {
   constructor(gitRemoteUrlService = new GitService()) {
     this.gitRemoteUrlService = gitRemoteUrlService;
   }
-  async execute(command9) {
-    const { path: repoPath, origin: origin11 } = command9;
+  async execute(command12) {
+    const { path: repoPath, origin: origin11 } = command12;
     return this.gitRemoteUrlService.getGitRemoteUrl(repoPath, origin11);
   }
 };
@@ -5137,6 +5156,42 @@ var GetGitRemoteUrlUseCase = class {
 // apps/cli/src/application/services/ListFiles.ts
 var fs = __toESM(require("fs/promises"));
 var path2 = __toESM(require("path"));
+
+// apps/cli/src/infra/utils/consoleLogger.ts
+init_source();
+var CLI_PREFIX = "packmind-cli";
+function logConsole(message, logger2 = console) {
+  logger2.log(message);
+}
+function logWarningConsole(message, logger2 = console) {
+  logger2.warn(source_default.bgYellow.bold(CLI_PREFIX), source_default.yellow(message));
+}
+function logInfoConsole(message, logger2 = console) {
+  logger2.log(source_default.bgBlue.bold(CLI_PREFIX), source_default.blue(message));
+}
+function logErrorConsole(message, logger2 = console) {
+  logger2.error(source_default.bgRed.bold(CLI_PREFIX), source_default.red(message));
+}
+function logSuccessConsole(message, logger2 = console) {
+  logger2.log(source_default.bgGreen.bold(CLI_PREFIX), source_default.green.bold(message));
+}
+function formatSlug(text) {
+  return source_default.blue.bold(text);
+}
+function formatLabel(text) {
+  return source_default.dim(text);
+}
+function formatError(text) {
+  return source_default.red(text);
+}
+function formatBold(text) {
+  return source_default.bold(text);
+}
+function formatFilePath(text) {
+  return source_default.underline.gray(text);
+}
+
+// apps/cli/src/application/services/ListFiles.ts
 var ListFiles = class {
   async listFilesInDirectory(directoryPath, extensions, excludes = [], skipHidden = true) {
     const results = [];
@@ -5184,7 +5239,7 @@ var ListFiles = class {
         }
       }
     } catch (error) {
-      console.error(`Error reading directory ${directoryPath}:`, error);
+      logErrorConsole(`Error reading directory ${directoryPath}: ${error}`);
     }
   }
   shouldExcludePath(filePath, excludes) {
@@ -5218,7 +5273,7 @@ var ListFiles = class {
     try {
       return await fs.readFile(filePath, "utf-8");
     } catch (error) {
-      console.error(`Error reading file ${filePath}:`, error);
+      logErrorConsole(`Error reading file ${filePath}: ${error}`);
       throw error;
     }
   }
@@ -5229,8 +5284,8 @@ var ListFilesInDirectoryUseCase = class {
   constructor(listFiles = new ListFiles()) {
     this.listFiles = listFiles;
   }
-  async execute(command9) {
-    const { path: directoryPath, extensions, excludes = [] } = command9;
+  async execute(command12) {
+    const { path: directoryPath, extensions, excludes = [] } = command12;
     const files = await this.listFiles.listFilesInDirectory(
       directoryPath,
       extensions,
@@ -5245,7 +5300,7 @@ var ListFilesInDirectoryUseCase = class {
           content
         });
       } catch (error) {
-        console.error(`Error reading file ${file.path}:`, error);
+        logErrorConsole(`Error reading file ${file.path}: ${error}`);
       }
     }
     return filesWithContent;
@@ -5263,6 +5318,23 @@ var LintFilesInDirectoryUseCase = class {
     this.repositories = repositories;
     this.logger = logger2;
   }
+  /**
+   * Parses a scope string from the API into an array of patterns.
+   * Handles comma-separated patterns and various edge cases.
+   *
+   * @param scope - The scope string from API (can be null, empty, or comma-separated)
+   * @returns Array of scope patterns, or empty array if no valid scope
+   */
+  parseScopeString(scope) {
+    if (!scope) {
+      return [];
+    }
+    const trimmedScope = scope.trim();
+    if (trimmedScope === "") {
+      return [];
+    }
+    return trimmedScope.split(",").map((pattern) => pattern.trim()).filter((pattern) => pattern.length > 0);
+  }
   fileMatchesScope(filePath, scopePatterns) {
     if (!scopePatterns || scopePatterns.length === 0) {
       return true;
@@ -5315,7 +5387,7 @@ var LintFilesInDirectoryUseCase = class {
     }
     return pattern;
   }
-  async execute(command9) {
+  async execute(command12) {
     const {
       path: userPath,
       draftMode,
@@ -5323,7 +5395,7 @@ var LintFilesInDirectoryUseCase = class {
       ruleId,
       language,
       diffMode
-    } = command9;
+    } = command12;
     this.logger.debug(
       `Starting linting: path="${userPath}", draftMode=${!!draftMode}, standardSlug="${standardSlug || "N/A"}", ruleId="${ruleId || "N/A"}", language="${language || "N/A"}", diffMode="${diffMode ?? "none"}"`
     );
@@ -5432,7 +5504,7 @@ var LintFilesInDirectoryUseCase = class {
               {
                 name: standardSlug,
                 slug: standardSlug,
-                scope: draftProgramsResult.scope ? [draftProgramsResult.scope] : [],
+                scope: this.parseScopeString(draftProgramsResult.scope),
                 rules: [
                   {
                     content: draftProgramsResult.ruleContent || "Draft Rule",
@@ -5470,7 +5542,7 @@ var LintFilesInDirectoryUseCase = class {
               {
                 name: standardSlug,
                 slug: standardSlug,
-                scope: activeProgramsResult.scope ? [activeProgramsResult.scope] : [],
+                scope: this.parseScopeString(activeProgramsResult.scope),
                 rules: [
                   {
                     content: activeProgramsResult.ruleContent || "Active Rule",
@@ -5544,7 +5616,7 @@ var LintFilesInDirectoryUseCase = class {
                   activeProgram.language
                 );
                 if (!programLanguage) {
-                  console.error(
+                  logErrorConsole(
                     `Unsupported language "${activeProgram.language}" for file ${file.path}`
                   );
                   continue;
@@ -5562,7 +5634,7 @@ var LintFilesInDirectoryUseCase = class {
                 });
                 programsByLanguage.set(programLanguage, programsForLanguage);
               } catch (error) {
-                console.error(
+                logErrorConsole(
                   `Error preparing program for file ${file.path}: ${error}`
                 );
               }
@@ -5585,13 +5657,13 @@ var LintFilesInDirectoryUseCase = class {
               });
               fileViolations.push(...result);
             } catch (error) {
-              console.error(
+              logErrorConsole(
                 `Error executing programs for file ${file.path} (${language2}): ${error}`
               );
             }
           }
         } catch (error) {
-          console.error(
+          logErrorConsole(
             `Error reading file content for ${file.path}: ${error}`
           );
         }
@@ -5642,8 +5714,8 @@ var LintFilesInDirectoryUseCase = class {
       return null;
     }
   }
-  async executeProgramsForFile(command9) {
-    const result = await this.services.linterExecutionUseCase.execute(command9);
+  async executeProgramsForFile(command12) {
+    const result = await this.services.linterExecutionUseCase.execute(command12);
     return result.violations;
   }
   extractExtensionFromFile(filePath) {
@@ -5700,8 +5772,8 @@ var LintFilesLocallyUseCase = class {
     }
     return pattern;
   }
-  async execute(command9) {
-    const { path: userPath, diffMode } = command9;
+  async execute(command12) {
+    const { path: userPath, diffMode } = command12;
     this.logger.debug(
       `Starting local linting: path="${userPath}", diffMode="${diffMode ?? "none"}"`
     );
@@ -5836,7 +5908,7 @@ var LintFilesLocallyUseCase = class {
                   });
                   programsByLanguage.set(programLanguage, programsForLanguage);
                 } catch (error) {
-                  console.error(
+                  logErrorConsole(
                     `Error preparing program for file ${file.path}: ${error}`
                   );
                 }
@@ -5860,13 +5932,13 @@ var LintFilesLocallyUseCase = class {
               });
               fileViolations.push(...result);
             } catch (error) {
-              console.error(
+              logErrorConsole(
                 `Error executing programs for file ${file.path} (${language}): ${error}`
               );
             }
           }
         } catch (error) {
-          console.error(
+          logErrorConsole(
             `Error reading file content for ${file.path}: ${error}`
           );
         }
@@ -5943,8 +6015,8 @@ var LintFilesLocallyUseCase = class {
       return null;
     }
   }
-  async executeProgramsForFile(command9) {
-    const result = await this.services.linterExecutionUseCase.execute(command9);
+  async executeProgramsForFile(command12) {
+    const result = await this.services.linterExecutionUseCase.execute(command12);
     return result.violations;
   }
   extractExtensionFromFile(filePath) {
@@ -6110,6 +6182,93 @@ var NotLoggedInError = class extends Error {
   }
 };
 
+// apps/cli/src/infra/http/PackmindHttpClient.ts
+var PackmindHttpClient = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  getAuthContext() {
+    if (!this.apiKey) {
+      throw new NotLoggedInError();
+    }
+    let decoded;
+    try {
+      const decodedString = Buffer.from(this.apiKey, "base64").toString(
+        "utf-8"
+      );
+      decoded = JSON.parse(decodedString);
+    } catch {
+      throw new Error("Invalid API key");
+    }
+    const jwtPayload = this.decodeJwt(decoded.jwt);
+    const organizationId = jwtPayload?.organization?.id;
+    if (!organizationId) {
+      throw new Error("Invalid API key: missing organizationId");
+    }
+    return {
+      host: decoded.host,
+      jwt: decoded.jwt,
+      organizationId
+    };
+  }
+  decodeJwt(jwt) {
+    try {
+      const parts = jwt.split(".");
+      if (parts.length !== 3) {
+        return null;
+      }
+      const payloadBase64 = parts[1];
+      const payloadString = Buffer.from(payloadBase64, "base64").toString(
+        "utf-8"
+      );
+      return JSON.parse(payloadString);
+    } catch {
+      return null;
+    }
+  }
+  async request(path13, options = {}) {
+    const { host } = this.getAuthContext();
+    const { method = "GET", body } = options;
+    const url = `${host}${path13}`;
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        ...body ? { body: JSON.stringify(body) } : {}
+      });
+      if (!response.ok) {
+        let errorMsg = `API request failed: ${response.status} ${response.statusText}`;
+        try {
+          const errorBody = await response.json();
+          if (errorBody?.message) {
+            errorMsg = errorBody.message;
+          }
+        } catch {
+        }
+        const error = new Error(errorMsg);
+        error.statusCode = response.status;
+        throw error;
+      }
+      return response.json();
+    } catch (error) {
+      const err = error;
+      if (err.statusCode) throw error;
+      const code = err?.code || err?.cause?.code;
+      if (code === "ECONNREFUSED" || code === "ENOTFOUND" || err?.name === "FetchError" || typeof err?.message === "string" && (err.message.includes("Failed to fetch") || err.message.includes("network") || err.message.includes("NetworkError"))) {
+        throw new Error(
+          `Packmind server is not accessible at ${host}. Please check your network connection or the server URL.`
+        );
+      }
+      throw new Error(
+        `Request failed: ${err?.message || JSON.stringify(error)}`
+      );
+    }
+  }
+};
+
 // apps/cli/src/infra/repositories/PackmindGateway.ts
 function decodeJwt(jwt) {
   try {
@@ -6166,7 +6325,7 @@ function decodeApiKey(apiKey) {
 var PackmindGateway = class {
   constructor(apiKey) {
     this.apiKey = apiKey;
-    this.getPullData = async (command9) => {
+    this.getPullData = async (command12) => {
       const decodedApiKey = decodeApiKey(this.apiKey);
       if (!decodedApiKey.isValid) {
         if (decodedApiKey.error === "NOT_LOGGED_IN") {
@@ -6181,16 +6340,25 @@ var PackmindGateway = class {
       }
       const organizationId = jwtPayload.organization.id;
       const queryParams = new URLSearchParams();
-      if (command9.packagesSlugs && command9.packagesSlugs.length > 0) {
-        command9.packagesSlugs.forEach((slug) => {
+      if (command12.packagesSlugs && command12.packagesSlugs.length > 0) {
+        command12.packagesSlugs.forEach((slug) => {
           queryParams.append("packageSlug", slug);
         });
       }
-      if (command9.previousPackagesSlugs && command9.previousPackagesSlugs.length > 0) {
-        command9.previousPackagesSlugs.forEach((slug) => {
+      if (command12.previousPackagesSlugs && command12.previousPackagesSlugs.length > 0) {
+        command12.previousPackagesSlugs.forEach((slug) => {
           queryParams.append("previousPackageSlug", slug);
         });
       }
+      if (command12.gitRemoteUrl) {
+        queryParams.append("gitRemoteUrl", command12.gitRemoteUrl);
+      }
+      if (command12.gitBranch) {
+        queryParams.append("gitBranch", command12.gitBranch);
+      }
+      if (command12.relativePath) {
+        queryParams.append("relativePath", command12.relativePath);
+      }
       const url = `${host}/api/v0/organizations/${organizationId}/pull?${queryParams.toString()}`;
       try {
         const response = await fetch(url, {
@@ -6727,7 +6895,7 @@ var PackmindGateway = class {
         );
       }
     };
-    this.uploadSkill = async (command9) => {
+    this.uploadSkill = async (command12) => {
       const decodedApiKey = decodeApiKey(this.apiKey);
       if (!decodedApiKey.isValid) {
         if (decodedApiKey.error === "NOT_LOGGED_IN") {
@@ -6755,7 +6923,7 @@ var PackmindGateway = class {
       }
       const space = await spaceResponse.json();
       const spaceId = space.id;
-      const files = await readSkillDirectory(command9.skillPath);
+      const files = await readSkillDirectory(command12.skillPath);
       if (!files.find((f) => f.relativePath === "SKILL.md")) {
         throw new Error("SKILL.md not found in skill directory");
       }
@@ -6825,6 +6993,96 @@ var PackmindGateway = class {
         );
       }
     };
+    this.getDefaultSkills = async () => {
+      const decodedApiKey = decodeApiKey(this.apiKey);
+      if (!decodedApiKey.isValid) {
+        if (decodedApiKey.error === "NOT_LOGGED_IN") {
+          throw new NotLoggedInError();
+        }
+        throw new Error(`Invalid API key: ${decodedApiKey.error}`);
+      }
+      const { host, jwt } = decodedApiKey.payload;
+      const jwtPayload = decodeJwt(jwt);
+      if (!jwtPayload?.organization?.id) {
+        throw new Error("Invalid API key: missing organizationId in JWT");
+      }
+      const organizationId = jwtPayload.organization.id;
+      const url = `${host}/api/v0/organizations/${organizationId}/skills/default`;
+      try {
+        const response = await fetch(url, {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`
+          }
+        });
+        if (!response.ok) {
+          let errorMsg = `API request failed: ${response.status} ${response.statusText}`;
+          try {
+            const errorBody = await response.json();
+            if (errorBody?.message) {
+              errorMsg = errorBody.message;
+            }
+          } catch {
+          }
+          throw new Error(errorMsg);
+        }
+        const result = await response.json();
+        return result;
+      } catch (error) {
+        const err = error;
+        const code = err?.code || err?.cause?.code;
+        if (code === "ECONNREFUSED" || code === "ENOTFOUND" || err?.name === "FetchError" || typeof err?.message === "string" && (err.message.includes("Failed to fetch") || err.message.includes("network") || err.message.includes("NetworkError"))) {
+          throw new Error(
+            `Packmind server is not accessible at ${host}. Please check your network connection or the server URL.`
+          );
+        }
+        throw new Error(
+          `Failed to get default skills: Error: ${err?.message || JSON.stringify(error)}`
+        );
+      }
+    };
+    this.getGlobalSpace = async () => {
+      const { organizationId } = this.httpClient.getAuthContext();
+      return this.httpClient.request(
+        `/api/v0/organizations/${organizationId}/spaces/global`
+      );
+    };
+    this.createStandardInSpace = async (spaceId, data) => {
+      const { organizationId } = this.httpClient.getAuthContext();
+      return this.httpClient.request(
+        `/api/v0/organizations/${organizationId}/spaces/${spaceId}/standards`,
+        { method: "POST", body: data }
+      );
+    };
+    this.getRulesForStandard = async (spaceId, standardId) => {
+      const { organizationId } = this.httpClient.getAuthContext();
+      return this.httpClient.request(
+        `/api/v0/organizations/${organizationId}/spaces/${spaceId}/standards/${standardId}/rules`
+      );
+    };
+    this.addExampleToRule = async (spaceId, standardId, ruleId, example) => {
+      const { organizationId } = this.httpClient.getAuthContext();
+      await this.httpClient.request(
+        `/api/v0/organizations/${organizationId}/spaces/${spaceId}/standards/${standardId}/rules/${ruleId}/examples`,
+        {
+          method: "POST",
+          body: {
+            lang: example.language,
+            positive: example.positive,
+            negative: example.negative
+          }
+        }
+      );
+    };
+    this.createCommand = async (spaceId, data) => {
+      const { organizationId } = this.httpClient.getAuthContext();
+      return this.httpClient.request(
+        `/api/v0/organizations/${organizationId}/spaces/${spaceId}/recipes`,
+        { method: "POST", body: data }
+      );
+    };
+    this.httpClient = new PackmindHttpClient(apiKey);
   }
 };
 
@@ -8568,8 +8826,8 @@ var ExecuteLinterProgramsUseCase = class {
     this.linterAstAdapter = linterAstAdapter;
     this.logger = logger2;
   }
-  async execute(command9) {
-    const { filePath, fileContent, language, programs } = command9;
+  async execute(command12) {
+    const { filePath, fileContent, language, programs } = command12;
     if (programs.length === 0) {
       return {
         file: filePath,
@@ -9573,6 +9831,51 @@ var SSEEventPublisher = class _SSEEventPublisher {
       throw error;
     }
   }
+  /**
+   * Publish a distribution status change event for cache invalidation
+   * This triggers React Query to refetch the distribution data when status changes
+   */
+  static async publishDistributionStatusChangeEvent(distributionId, status, organizationId) {
+    _SSEEventPublisher.logger.info(
+      "Publishing distribution status change event",
+      {
+        distributionId,
+        status,
+        organizationId
+      }
+    );
+    try {
+      const event = createDistributionStatusChangeEvent(
+        distributionId,
+        status,
+        organizationId
+      );
+      await _SSEEventPublisher.publishEvent(
+        "DISTRIBUTION_STATUS_CHANGE",
+        [organizationId],
+        event
+      );
+      _SSEEventPublisher.logger.debug(
+        "Successfully published distribution status change event",
+        {
+          distributionId,
+          status,
+          organizationId
+        }
+      );
+    } catch (error) {
+      _SSEEventPublisher.logger.error(
+        "Failed to publish distribution status change event",
+        {
+          distributionId,
+          status,
+          organizationId,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      );
+      throw error;
+    }
+  }
   /**
    * Generic method to publish any SSE event type to Redis pub/sub
    */
@@ -9657,6 +9960,11 @@ ${sectionBlock}
   return result;
 }
 
+// packages/node-utils/src/text/urlUtils.ts
+function removeTrailingSlash(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+
 // apps/cli/src/application/useCases/InstallPackagesUseCase.ts
 var fs5 = __toESM(require("fs/promises"));
 var path6 = __toESM(require("path"));
@@ -9664,8 +9972,8 @@ var InstallPackagesUseCase = class {
   constructor(packmindGateway) {
     this.packmindGateway = packmindGateway;
   }
-  async execute(command9) {
-    const baseDirectory = command9.baseDirectory || process.cwd();
+  async execute(command12) {
+    const baseDirectory = command12.baseDirectory || process.cwd();
     const result = {
       filesCreated: 0,
       filesUpdated: 0,
@@ -9673,11 +9981,15 @@ var InstallPackagesUseCase = class {
       errors: [],
       recipesCount: 0,
       standardsCount: 0,
-      skillsCount: 0
+      skillsCount: 0,
+      skillDirectoriesDeleted: 0
     };
     const response = await this.packmindGateway.getPullData({
-      packagesSlugs: command9.packagesSlugs,
-      previousPackagesSlugs: command9.previousPackagesSlugs
+      packagesSlugs: command12.packagesSlugs,
+      previousPackagesSlugs: command12.previousPackagesSlugs,
+      gitRemoteUrl: command12.gitRemoteUrl,
+      gitBranch: command12.gitBranch,
+      relativePath: command12.relativePath
     });
     const uniqueFilesMap = /* @__PURE__ */ new Map();
     for (const file of response.fileUpdates.createOrUpdate) {
@@ -9694,6 +10006,10 @@ var InstallPackagesUseCase = class {
       }
     }
     try {
+      result.skillDirectoriesDeleted = await this.deleteSkillFolders(
+        baseDirectory,
+        response.skillFolders
+      );
       for (const file of uniqueFiles) {
         try {
           await this.createOrUpdateFile(baseDirectory, file, result);
@@ -9871,6 +10187,98 @@ ${endMarker}`;
   escapeRegex(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   }
+  /**
+   * Deletes all skill folders before recreating them with fresh content.
+   * Returns the count of files that were actually deleted.
+   */
+  async deleteSkillFolders(baseDirectory, folders) {
+    let deletedFilesCount = 0;
+    for (const folder of folders) {
+      const fullPath = path6.join(baseDirectory, folder);
+      try {
+        await fs5.access(fullPath);
+        const fileCount = await this.countFilesInDirectory(fullPath);
+        await fs5.rm(fullPath, { recursive: true, force: true });
+        deletedFilesCount += fileCount;
+      } catch {
+      }
+    }
+    return deletedFilesCount;
+  }
+  /**
+   * Recursively counts all files in a directory.
+   */
+  async countFilesInDirectory(dirPath) {
+    let count = 0;
+    const entries = await fs5.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryPath = path6.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        count += await this.countFilesInDirectory(entryPath);
+      } else {
+        count++;
+      }
+    }
+    return count;
+  }
+};
+
+// apps/cli/src/application/useCases/InstallDefaultSkillsUseCase.ts
+var fs6 = __toESM(require("fs/promises"));
+var path7 = __toESM(require("path"));
+var InstallDefaultSkillsUseCase = class {
+  constructor(packmindGateway) {
+    this.packmindGateway = packmindGateway;
+  }
+  async execute(command12) {
+    const baseDirectory = command12.baseDirectory || process.cwd();
+    const result = {
+      filesCreated: 0,
+      filesUpdated: 0,
+      errors: []
+    };
+    const response = await this.packmindGateway.getDefaultSkills({});
+    try {
+      for (const file of response.fileUpdates.createOrUpdate) {
+        try {
+          await this.createOrUpdateFile(baseDirectory, file, result);
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          result.errors.push(
+            `Failed to create/update ${file.path}: ${errorMsg}`
+          );
+        }
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      result.errors.push(`Failed to install default skills: ${errorMsg}`);
+    }
+    return result;
+  }
+  async createOrUpdateFile(baseDirectory, file, result) {
+    const fullPath = path7.join(baseDirectory, file.path);
+    const directory = path7.dirname(fullPath);
+    await fs6.mkdir(directory, { recursive: true });
+    const fileExists = await this.fileExists(fullPath);
+    if (fileExists) {
+      const existingContent = await fs6.readFile(fullPath, "utf-8");
+      if (existingContent !== file.content) {
+        await fs6.writeFile(fullPath, file.content, "utf-8");
+        result.filesUpdated++;
+      }
+    } else {
+      await fs6.writeFile(fullPath, file.content, "utf-8");
+      result.filesCreated++;
+    }
+  }
+  async fileExists(filePath) {
+    try {
+      await fs6.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
 };
 
 // apps/cli/src/application/useCases/ListPackagesUseCase.ts
@@ -9888,8 +10296,8 @@ var GetPackageSummaryUseCase = class {
   constructor(gateway) {
     this.gateway = gateway;
   }
-  async execute(command9) {
-    return this.gateway.getPackageSummary(command9);
+  async execute(command12) {
+    return this.gateway.getPackageSummary(command12);
   }
 };
 
@@ -9949,13 +10357,13 @@ var EnvCredentialsProvider = class {
 };
 
 // apps/cli/src/infra/utils/credentials/FileCredentialsProvider.ts
-var fs6 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 var os2 = __toESM(require("os"));
 var CREDENTIALS_DIR = ".packmind";
 var CREDENTIALS_FILE = "credentials.json";
 function getCredentialsPath() {
-  return path7.join(os2.homedir(), CREDENTIALS_DIR, CREDENTIALS_FILE);
+  return path8.join(os2.homedir(), CREDENTIALS_DIR, CREDENTIALS_FILE);
 }
 var FileCredentialsProvider = class {
   getSourceName() {
@@ -9963,11 +10371,11 @@ var FileCredentialsProvider = class {
   }
   hasCredentials() {
     const credentialsPath = getCredentialsPath();
-    if (!fs6.existsSync(credentialsPath)) {
+    if (!fs7.existsSync(credentialsPath)) {
       return false;
     }
     try {
-      const content = fs6.readFileSync(credentialsPath, "utf-8");
+      const content = fs7.readFileSync(credentialsPath, "utf-8");
       const credentials = JSON.parse(content);
       return !!credentials.apiKey;
     } catch {
@@ -9976,11 +10384,11 @@ var FileCredentialsProvider = class {
   }
   loadCredentials() {
     const credentialsPath = getCredentialsPath();
-    if (!fs6.existsSync(credentialsPath)) {
+    if (!fs7.existsSync(credentialsPath)) {
       return null;
     }
     try {
-      const content = fs6.readFileSync(credentialsPath, "utf-8");
+      const content = fs7.readFileSync(credentialsPath, "utf-8");
       const credentials = JSON.parse(content);
       if (!credentials.apiKey) {
         return null;
@@ -10003,13 +10411,13 @@ var FileCredentialsProvider = class {
   }
 };
 function saveCredentials(apiKey) {
-  const credentialsDir = path7.join(os2.homedir(), CREDENTIALS_DIR);
-  if (!fs6.existsSync(credentialsDir)) {
-    fs6.mkdirSync(credentialsDir, { recursive: true, mode: 448 });
+  const credentialsDir = path8.join(os2.homedir(), CREDENTIALS_DIR);
+  if (!fs7.existsSync(credentialsDir)) {
+    fs7.mkdirSync(credentialsDir, { recursive: true, mode: 448 });
   }
   const credentialsPath = getCredentialsPath();
   const credentials = { apiKey };
-  fs6.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), {
+  fs7.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), {
     mode: 384
   });
 }
@@ -10088,7 +10496,8 @@ async function defaultPromptForCode() {
   });
 }
 async function defaultExchangeCodeForApiKey(code, host) {
-  const url = `${host}/api/v0/auth/cli-login-exchange`;
+  const normalizedHost = removeTrailingSlash(host);
+  const url = `${normalizedHost}/api/v0/auth/cli-login-exchange`;
   const response = await fetch(url, {
     method: "POST",
     headers: {
@@ -10167,15 +10576,16 @@ var LoginUseCase = class {
       startCallbackServer: deps?.startCallbackServer ?? defaultStartCallbackServer
     };
   }
-  async execute(command9) {
-    const { host, code: providedCode } = command9;
+  async execute(command12) {
+    const { host, code: providedCode } = command12;
     let code;
     if (providedCode) {
       code = providedCode;
     } else {
       const callbackPromise = this.deps.startCallbackServer();
       const callbackUrl = `http://127.0.0.1:${CALLBACK_PORT}`;
-      const loginUrl = `${host}/cli-login?callback_url=${encodeURIComponent(callbackUrl)}`;
+      const normalizedHost = removeTrailingSlash(host);
+      const loginUrl = `${normalizedHost}/cli-login?callback_url=${encodeURIComponent(callbackUrl)}`;
       try {
         await this.deps.openBrowser(loginUrl);
       } catch {
@@ -10199,14 +10609,14 @@ var LoginUseCase = class {
 };
 
 // apps/cli/src/application/useCases/LogoutUseCase.ts
-var fs7 = __toESM(require("fs"));
+var fs8 = __toESM(require("fs"));
 var ENV_VAR_NAME2 = "PACKMIND_API_KEY_V3";
 var LogoutUseCase = class {
   constructor(deps) {
     this.deps = {
       getCredentialsPath: deps?.getCredentialsPath ?? getCredentialsPath,
-      fileExists: deps?.fileExists ?? ((path12) => fs7.existsSync(path12)),
-      deleteFile: deps?.deleteFile ?? ((path12) => fs7.unlinkSync(path12)),
+      fileExists: deps?.fileExists ?? ((path13) => fs8.existsSync(path13)),
+      deleteFile: deps?.deleteFile ?? ((path13) => fs8.unlinkSync(path13)),
       hasEnvVar: deps?.hasEnvVar ?? (() => !!process.env[ENV_VAR_NAME2])
     };
   }
@@ -10266,8 +10676,8 @@ var SetupMcpUseCase = class {
   constructor(deps) {
     this.deps = deps;
   }
-  async execute(command9) {
-    const { agentTypes } = command9;
+  async execute(command12) {
+    const { agentTypes } = command12;
     const [tokenResult, urlResult] = await Promise.all([
       this.deps.gateway.getMcpToken({}),
       this.deps.gateway.getMcpUrl({})
@@ -10302,8 +10712,8 @@ var SetupMcpUseCase = class {
 };
 
 // apps/cli/src/application/services/McpConfigService.ts
-var fs8 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
 var os3 = __toESM(require("os"));
 var import_child_process2 = require("child_process");
 var McpConfigService = class {
@@ -10338,9 +10748,9 @@ var McpConfigService = class {
     return JSON.stringify(mcpConfig, null, 2);
   }
   installClaudeMcp(config) {
-    const command9 = `claude mcp add --transport http packmind ${config.url} --header "Authorization: Bearer ${config.accessToken}"`;
+    const command12 = `claude mcp add --transport http packmind ${config.url} --header "Authorization: Bearer ${config.accessToken}"`;
     try {
-      (0, import_child_process2.execSync)(command9, { stdio: "pipe" });
+      (0, import_child_process2.execSync)(command12, { stdio: "pipe" });
       return { success: true };
     } catch (error) {
       const execError = error;
@@ -10350,11 +10760,11 @@ var McpConfigService = class {
   }
   installCursorMcp(config) {
     try {
-      const cursorConfigPath = path8.join(os3.homedir(), ".cursor", "mcp.json");
+      const cursorConfigPath = path9.join(os3.homedir(), ".cursor", "mcp.json");
       const cursorConfig = this.buildCursorConfig(config);
       const existingConfig = this.readExistingJsonConfig(cursorConfigPath);
       const mergedConfig = this.mergeConfig(existingConfig, cursorConfig);
-      fs8.writeFileSync(cursorConfigPath, JSON.stringify(mergedConfig, null, 2));
+      fs9.writeFileSync(cursorConfigPath, JSON.stringify(mergedConfig, null, 2));
       return { success: true };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -10363,15 +10773,15 @@ var McpConfigService = class {
   }
   installVSCodeMcp(config) {
     try {
-      const vscodeDir = path8.join(this.projectDir, ".vscode");
-      if (!fs8.existsSync(vscodeDir)) {
-        fs8.mkdirSync(vscodeDir, { recursive: true });
+      const vscodeDir = path9.join(this.projectDir, ".vscode");
+      if (!fs9.existsSync(vscodeDir)) {
+        fs9.mkdirSync(vscodeDir, { recursive: true });
       }
-      const vscodeConfigPath = path8.join(vscodeDir, "mcp.json");
+      const vscodeConfigPath = path9.join(vscodeDir, "mcp.json");
       const vscodeConfig = this.buildVSCodeConfig(config);
       const existingConfig = this.readExistingJsonConfig(vscodeConfigPath);
       const mergedConfig = this.mergeVSCodeConfig(existingConfig, vscodeConfig);
-      fs8.writeFileSync(vscodeConfigPath, JSON.stringify(mergedConfig, null, 2));
+      fs9.writeFileSync(vscodeConfigPath, JSON.stringify(mergedConfig, null, 2));
       return { success: true };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -10380,14 +10790,14 @@ var McpConfigService = class {
   }
   installContinueMcp(config) {
     try {
-      const continueDir = path8.join(this.projectDir, ".continue");
-      const mcpServersDir = path8.join(continueDir, "mcpServers");
-      if (!fs8.existsSync(mcpServersDir)) {
-        fs8.mkdirSync(mcpServersDir, { recursive: true });
+      const continueDir = path9.join(this.projectDir, ".continue");
+      const mcpServersDir = path9.join(continueDir, "mcpServers");
+      if (!fs9.existsSync(mcpServersDir)) {
+        fs9.mkdirSync(mcpServersDir, { recursive: true });
       }
-      const continueConfigPath = path8.join(mcpServersDir, "packmind.yaml");
+      const continueConfigPath = path9.join(mcpServersDir, "packmind.yaml");
       const continueConfig = this.buildContinueYamlConfig(config);
-      fs8.writeFileSync(continueConfigPath, continueConfig);
+      fs9.writeFileSync(continueConfigPath, continueConfig);
       return { success: true };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -10435,8 +10845,8 @@ mcpServers:
   }
   readExistingJsonConfig(filePath) {
     try {
-      if (fs8.existsSync(filePath)) {
-        const content = fs8.readFileSync(filePath, "utf-8");
+      if (fs9.existsSync(filePath)) {
+        const content = fs9.readFileSync(filePath, "utf-8");
         return JSON.parse(content);
       }
     } catch {
@@ -10469,41 +10879,8 @@ mcpServers:
 };
 
 // apps/cli/src/infra/repositories/ConfigFileRepository.ts
-var fs9 = __toESM(require("fs/promises"));
-var path9 = __toESM(require("path"));
-
-// apps/cli/src/infra/utils/consoleLogger.ts
-init_source();
-var CLI_PREFIX = "packmind-cli";
-function logWarningConsole(message) {
-  console.warn(source_default.bgYellow.bold(CLI_PREFIX), source_default.yellow(message));
-}
-function logInfoConsole(message) {
-  console.log(source_default.bgBlue.bold(CLI_PREFIX), source_default.blue(message));
-}
-function logErrorConsole(message) {
-  console.error(source_default.bgRed.bold(CLI_PREFIX), source_default.red(message));
-}
-function logSuccessConsole(message) {
-  console.log(source_default.bgGreen.bold(CLI_PREFIX), source_default.green.bold(message));
-}
-function formatSlug(text) {
-  return source_default.blue.bold(text);
-}
-function formatLabel(text) {
-  return source_default.dim(text);
-}
-function formatError(text) {
-  return source_default.red(text);
-}
-function formatBold(text) {
-  return source_default.bold(text);
-}
-function formatFilePath(text) {
-  return source_default.underline.gray(text);
-}
-
-// apps/cli/src/infra/repositories/ConfigFileRepository.ts
+var fs10 = __toESM(require("fs/promises"));
+var path10 = __toESM(require("path"));
 var ConfigFileRepository = class {
   constructor() {
     this.CONFIG_FILENAME = "packmind.json";
@@ -10518,23 +10895,23 @@ var ConfigFileRepository = class {
     ];
   }
   async writeConfig(baseDirectory, config) {
-    const configPath = path9.join(baseDirectory, this.CONFIG_FILENAME);
+    const configPath = path10.join(baseDirectory, this.CONFIG_FILENAME);
     const configContent = JSON.stringify(config, null, 2) + "\n";
-    await fs9.writeFile(configPath, configContent, "utf-8");
+    await fs10.writeFile(configPath, configContent, "utf-8");
   }
   async configExists(baseDirectory) {
-    const configPath = path9.join(baseDirectory, this.CONFIG_FILENAME);
+    const configPath = path10.join(baseDirectory, this.CONFIG_FILENAME);
     try {
-      await fs9.access(configPath);
+      await fs10.access(configPath);
       return true;
     } catch {
       return false;
     }
   }
   async readConfig(baseDirectory) {
-    const configPath = path9.join(baseDirectory, this.CONFIG_FILENAME);
+    const configPath = path10.join(baseDirectory, this.CONFIG_FILENAME);
     try {
-      const configContent = await fs9.readFile(configPath, "utf-8");
+      const configContent = await fs10.readFile(configPath, "utf-8");
       const config = JSON.parse(configContent);
       if (!config.packages || typeof config.packages !== "object") {
         throw new Error(
@@ -10561,12 +10938,12 @@ var ConfigFileRepository = class {
    * @returns Array of directory paths that contain a packmind.json file
    */
   async findDescendantConfigs(directory) {
-    const normalizedDir = normalizePath(path9.resolve(directory));
+    const normalizedDir = normalizePath(path10.resolve(directory));
     const results = [];
     const searchRecursively = async (currentDir) => {
       let entries;
       try {
-        entries = await fs9.readdir(currentDir, { withFileTypes: true });
+        entries = await fs10.readdir(currentDir, { withFileTypes: true });
       } catch {
         return;
       }
@@ -10577,7 +10954,7 @@ var ConfigFileRepository = class {
         if (this.EXCLUDED_DIRECTORIES.includes(entry.name)) {
           continue;
         }
-        const entryPath = normalizePath(path9.join(currentDir, entry.name));
+        const entryPath = normalizePath(path10.join(currentDir, entry.name));
         const config = await this.readConfig(entryPath);
         if (config) {
           results.push(entryPath);
@@ -10599,21 +10976,21 @@ var ConfigFileRepository = class {
   async readHierarchicalConfig(startDirectory, stopDirectory) {
     const configs = [];
     const configPaths = [];
-    const normalizedStart = normalizePath(path9.resolve(startDirectory));
-    const normalizedStop = stopDirectory ? normalizePath(path9.resolve(stopDirectory)) : null;
+    const normalizedStart = normalizePath(path10.resolve(startDirectory));
+    const normalizedStop = stopDirectory ? normalizePath(path10.resolve(stopDirectory)) : null;
     let currentDir = normalizedStart;
     while (true) {
       const config = await this.readConfig(currentDir);
       if (config) {
         configs.push(config);
         configPaths.push(
-          normalizePath(path9.join(currentDir, this.CONFIG_FILENAME))
+          normalizePath(path10.join(currentDir, this.CONFIG_FILENAME))
         );
       }
       if (normalizedStop !== null && currentDir === normalizedStop) {
         break;
       }
-      const parentDir = normalizePath(path9.dirname(currentDir));
+      const parentDir = normalizePath(path10.dirname(currentDir));
       if (parentDir === currentDir) {
         break;
       }
@@ -10642,8 +11019,8 @@ var ConfigFileRepository = class {
    * @returns All configs found with their target paths
    */
   async findAllConfigsInTree(startDirectory, stopDirectory) {
-    const normalizedStart = normalizePath(path9.resolve(startDirectory));
-    const normalizedStop = stopDirectory ? normalizePath(path9.resolve(stopDirectory)) : null;
+    const normalizedStart = normalizePath(path10.resolve(startDirectory));
+    const normalizedStop = stopDirectory ? normalizePath(path10.resolve(stopDirectory)) : null;
     const basePath = normalizedStop ?? normalizedStart;
     const configsMap = /* @__PURE__ */ new Map();
     let currentDir = normalizedStart;
@@ -10660,7 +11037,7 @@ var ConfigFileRepository = class {
       if (normalizedStop !== null && currentDir === normalizedStop) {
         break;
       }
-      const parentDir = normalizePath(path9.dirname(currentDir));
+      const parentDir = normalizePath(path10.dirname(currentDir));
       if (parentDir === currentDir) {
         break;
       }
@@ -10747,6 +11124,9 @@ var PackmindCliHexaFactory = class {
       installPackages: new InstallPackagesUseCase(
         this.repositories.packmindGateway
       ),
+      installDefaultSkills: new InstallDefaultSkillsUseCase(
+        this.repositories.packmindGateway
+      ),
       listPackages: new ListPackagesUseCase(this.repositories.packmindGateway),
       getPackageBySlug: new GetPackageSummaryUseCase(
         this.repositories.packmindGateway
@@ -10783,29 +11163,29 @@ var PackmindCliHexa = class {
     this.logger.info("Destroying PackmindCliHexa");
     this.logger.info("PackmindCliHexa destroyed");
   }
-  async getGitRemoteUrl(command9) {
-    return this.hexa.useCases.getGitRemoteUrl.execute(command9);
+  async getGitRemoteUrl(command12) {
+    return this.hexa.useCases.getGitRemoteUrl.execute(command12);
   }
-  async executeSingleFileAst(command9) {
-    return this.hexa.useCases.executeSingleFileAst.execute(command9);
+  async executeSingleFileAst(command12) {
+    return this.hexa.useCases.executeSingleFileAst.execute(command12);
   }
-  async listFilesInDirectory(command9) {
-    return this.hexa.useCases.listFilesInDirectoryUseCase.execute(command9);
+  async listFilesInDirectory(command12) {
+    return this.hexa.useCases.listFilesInDirectoryUseCase.execute(command12);
   }
-  async lintFilesInDirectory(command9) {
-    return this.hexa.useCases.lintFilesInDirectory.execute(command9);
+  async lintFilesInDirectory(command12) {
+    return this.hexa.useCases.lintFilesInDirectory.execute(command12);
   }
-  async lintFilesLocally(command9) {
-    return this.hexa.useCases.lintFilesLocally.execute(command9);
+  async lintFilesLocally(command12) {
+    return this.hexa.useCases.lintFilesLocally.execute(command12);
   }
-  async installPackages(command9) {
-    return this.hexa.useCases.installPackages.execute(command9);
+  async installPackages(command12) {
+    return this.hexa.useCases.installPackages.execute(command12);
   }
-  async listPackages(command9) {
-    return this.hexa.useCases.listPackages.execute(command9);
+  async listPackages(command12) {
+    return this.hexa.useCases.listPackages.execute(command12);
   }
-  async getPackageBySlug(command9) {
-    return this.hexa.useCases.getPackageBySlug.execute(command9);
+  async getPackageBySlug(command12) {
+    return this.hexa.useCases.getPackageBySlug.execute(command12);
   }
   async configExists(baseDirectory) {
     return await this.hexa.repositories.configFileRepository.configExists(
@@ -10864,17 +11244,17 @@ var PackmindCliHexa = class {
       directory
     );
   }
-  async login(command9) {
-    return this.hexa.useCases.login.execute(command9);
+  async login(command12) {
+    return this.hexa.useCases.login.execute(command12);
   }
-  async logout(command9) {
-    return this.hexa.useCases.logout.execute(command9);
+  async logout(command12) {
+    return this.hexa.useCases.logout.execute(command12);
   }
-  async whoami(command9) {
-    return this.hexa.useCases.whoami.execute(command9);
+  async whoami(command12) {
+    return this.hexa.useCases.whoami.execute(command12);
   }
-  async setupMcp(command9) {
-    return this.hexa.useCases.setupMcp.execute(command9);
+  async setupMcp(command12) {
+    return this.hexa.useCases.setupMcp.execute(command12);
   }
   getCurrentBranch(repoPath) {
     return this.hexa.services.gitRemoteUrlService.getCurrentBranch(repoPath).branch;
@@ -10882,11 +11262,17 @@ var PackmindCliHexa = class {
   getGitRemoteUrlFromPath(repoPath) {
     return this.hexa.services.gitRemoteUrlService.getGitRemoteUrl(repoPath).gitRemoteUrl;
   }
-  async notifyDistribution(command9) {
-    return this.hexa.repositories.packmindGateway.notifyDistribution(command9);
+  async notifyDistribution(command12) {
+    return this.hexa.repositories.packmindGateway.notifyDistribution(command12);
   }
-  async uploadSkill(command9) {
-    return this.hexa.repositories.packmindGateway.uploadSkill(command9);
+  async uploadSkill(command12) {
+    return this.hexa.repositories.packmindGateway.uploadSkill(command12);
+  }
+  async installDefaultSkills(command12) {
+    return this.hexa.useCases.installDefaultSkills.execute(command12);
+  }
+  getPackmindGateway() {
+    return this.hexa.repositories.packmindGateway;
   }
 };
 
@@ -10899,7 +11285,7 @@ var IDELintLogger = class {
   }
   logViolation(violation) {
     violation.violations.forEach(({ line, character, standard, rule }) => {
-      console.log(
+      logConsole(
         `${violation.file}:${line}:${character}:error:@${standard}/${rule}`
       );
     });
@@ -10925,9 +11311,9 @@ var HumanReadableLogger = class {
     }
   }
   logViolation(violation) {
-    console.log(formatFilePath(violation.file));
+    logConsole(formatFilePath(violation.file));
     violation.violations.forEach(({ line, character, standard, rule }) => {
-      console.log(
+      logConsole(
         formatError(`	${line}:${character}	error	@${standard}/${rule}`)
       );
     });
@@ -10943,7 +11329,7 @@ function isNotLoggedInError(error) {
 }
 async function lintHandler(args2, deps) {
   const {
-    path: path12,
+    path: path13,
     draft,
     rule,
     language,
@@ -10963,7 +11349,7 @@ async function lintHandler(args2, deps) {
     throw new Error("option --rule is required to use --draft mode");
   }
   const startedAt = Date.now();
-  const targetPath = path12 ?? ".";
+  const targetPath = path13 ?? ".";
   const hasArguments = !!(draft || rule || language);
   const absolutePath = resolvePath(targetPath);
   if (diff) {
@@ -11220,8 +11606,8 @@ function extractWasmFiles() {
 
 // apps/cli/src/main.ts
 var import_dotenv = require("dotenv");
-var fs12 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
 
 // apps/cli/src/infra/commands/InstallCommand.ts
 var import_cmd_ts2 = __toESM(require_cjs());
@@ -11255,6 +11641,31 @@ async function notifyDistributionIfInGitRepo(params) {
     return false;
   }
 }
+async function installDefaultSkillsIfAtGitRoot(params) {
+  const { packmindCliHexa, cwd, log } = params;
+  const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(cwd);
+  if (!gitRoot || cwd !== gitRoot) {
+    return;
+  }
+  try {
+    log("\nInstalling default skills...");
+    const skillsResult = await packmindCliHexa.installDefaultSkills({});
+    if (skillsResult.errors.length > 0) {
+      skillsResult.errors.forEach((err) => {
+        log(`   Warning: ${err}`);
+      });
+    }
+    const totalSkillFiles = skillsResult.filesCreated + skillsResult.filesUpdated;
+    if (totalSkillFiles > 0) {
+      log(
+        `Default skills: added ${skillsResult.filesCreated} files, changed ${skillsResult.filesUpdated} files`
+      );
+    } else if (skillsResult.errors.length === 0) {
+      log("Default skills are already up to date");
+    }
+  } catch {
+  }
+}
 async function listPackagesHandler(_args, deps) {
   const { packmindCliHexa, exit, log, error } = deps;
   try {
@@ -11472,8 +11883,9 @@ async function executeInstallForDirectory(directory, deps) {
         errorMessage: result.errors.join(", ")
       };
     }
+    const skillDirsDeleted = result.skillDirectoriesDeleted || 0;
     let notificationSent = false;
-    if (result.filesCreated > 0 || result.filesUpdated > 0 || result.filesDeleted > 0) {
+    if (result.filesCreated > 0 || result.filesUpdated > 0 || result.filesDeleted > 0 || skillDirsDeleted > 0) {
       notificationSent = await notifyDistributionIfInGitRepo({
         packmindCliHexa,
         cwd: directory,
@@ -11486,7 +11898,7 @@ async function executeInstallForDirectory(directory, deps) {
       success: true,
       filesCreated: result.filesCreated,
       filesUpdated: result.filesUpdated,
-      filesDeleted: result.filesDeleted,
+      filesDeleted: result.filesDeleted + skillDirsDeleted,
       notificationSent
     };
   } catch (err) {
@@ -11561,11 +11973,32 @@ async function installPackagesHandler(args2, deps) {
     log(
       `Fetching ${packageCount} ${packageWord}: ${allPackages.join(", ")}...`
     );
+    let gitRemoteUrl;
+    let gitBranch;
+    let relativePath;
+    const gitRoot = await packmindCliHexa.tryGetGitRepositoryRoot(cwd);
+    if (gitRoot) {
+      try {
+        gitRemoteUrl = packmindCliHexa.getGitRemoteUrlFromPath(gitRoot);
+        gitBranch = packmindCliHexa.getCurrentBranch(gitRoot);
+        relativePath = cwd.startsWith(gitRoot) ? cwd.slice(gitRoot.length) : "/";
+        if (!relativePath.startsWith("/")) {
+          relativePath = "/" + relativePath;
+        }
+        if (!relativePath.endsWith("/")) {
+          relativePath = relativePath + "/";
+        }
+      } catch {
+      }
+    }
     const result = await packmindCliHexa.installPackages({
       baseDirectory: cwd,
       packagesSlugs: allPackages,
-      previousPackagesSlugs: configPackages
+      previousPackagesSlugs: configPackages,
       // Pass previous config for change detection
+      gitRemoteUrl,
+      gitBranch,
+      relativePath
     });
     const parts = [];
     if (result.recipesCount > 0) parts.push(`${result.recipesCount} commands`);
@@ -11573,9 +12006,11 @@ async function installPackagesHandler(args2, deps) {
       parts.push(`${result.standardsCount} standards`);
     if (result.skillsCount > 0) parts.push(`${result.skillsCount} skills`);
     log(`Installing ${parts.join(", ") || "artifacts"}...`);
+    const skillDirsDeleted = result.skillDirectoriesDeleted || 0;
+    const totalDeleted = result.filesDeleted + skillDirsDeleted;
     log(
       `
-added ${result.filesCreated} files, changed ${result.filesUpdated} files, removed ${result.filesDeleted} files`
+added ${result.filesCreated} files, changed ${result.filesUpdated} files, removed ${totalDeleted} files`
     );
     if (result.errors.length > 0) {
       log("\n\u26A0\uFE0F  Errors encountered:");
@@ -11586,12 +12021,12 @@ added ${result.filesCreated} files, changed ${result.filesUpdated} files, remove
       return {
         filesCreated: result.filesCreated,
         filesUpdated: result.filesUpdated,
-        filesDeleted: result.filesDeleted,
+        filesDeleted: totalDeleted,
         notificationSent: false
       };
     }
     let notificationSent = false;
-    if (result.filesCreated > 0 || result.filesUpdated > 0 || result.filesDeleted > 0) {
+    if (result.filesCreated > 0 || result.filesUpdated > 0 || result.filesDeleted > 0 || skillDirsDeleted > 0) {
       notificationSent = await notifyDistributionIfInGitRepo({
         packmindCliHexa,
         cwd,
@@ -11599,10 +12034,11 @@ added ${result.filesCreated} files, changed ${result.filesUpdated} files, remove
         log
       });
     }
+    await installDefaultSkillsIfAtGitRoot({ packmindCliHexa, cwd, log });
     return {
       filesCreated: result.filesCreated,
       filesUpdated: result.filesUpdated,
-      filesDeleted: result.filesDeleted,
+      filesDeleted: totalDeleted,
       notificationSent
     };
   } catch (err) {
@@ -12050,10 +12486,11 @@ var loginCommand = (0, import_cmd_ts4.command)({
     const packmindCliHexa = new PackmindCliHexa(packmindLogger);
     try {
       if (!code) {
-        console.log("\nOpening browser for authentication...");
-        console.log(
+        logConsole("\nOpening browser for authentication...");
+        const normalizedHost = removeTrailingSlash(host);
+        logConsole(
           `
-If the browser doesn't open, visit: ${host}/cli-login?callback_url=${encodeURIComponent("http://127.0.0.1:19284")}
+If the browser doesn't open, visit: ${normalizedHost}/cli-login?callback_url=${encodeURIComponent("http://127.0.0.1:19284")}
 `
         );
         logInfoConsole("Waiting for browser authentication...");
@@ -12061,9 +12498,9 @@ If the browser doesn't open, visit: ${host}/cli-login?callback_url=${encodeURICo
       logInfoConsole("Exchanging code for API key...");
       const result = await packmindCliHexa.login({ host, code });
       logSuccessConsole("Login successful!");
-      console.log(`
+      logConsole(`
 Credentials saved to: ${result.credentialsPath}`);
-      console.log(
+      logConsole(
         "\nYou can now use packmind-cli commands with your authenticated account."
       );
     } catch (error) {
@@ -12094,20 +12531,20 @@ var logoutCommand = (0, import_cmd_ts5.command)({
       }
       if (result.hadCredentialsFile) {
         logSuccessConsole("Logged out successfully.");
-        console.log(`Removed credentials from: ${result.credentialsPath}`);
+        logConsole(`Removed credentials from: ${result.credentialsPath}`);
       }
       if (result.hasEnvVar) {
         if (!result.hadCredentialsFile) {
           logInfoConsole("No stored credentials file found.");
         }
-        console.log(
+        logConsole(
           "\nNote: PACKMIND_API_KEY_V3 environment variable is still set."
         );
-        console.log("To fully log out, run: unset PACKMIND_API_KEY_V3");
+        logConsole("To fully log out, run: unset PACKMIND_API_KEY_V3");
       }
     } catch (error) {
       logErrorConsole("Failed to remove credentials file.");
-      console.log(
+      logConsole(
         `Error: ${error instanceof Error ? error.message : String(error)}`
       );
       process.exit(1);
@@ -12136,20 +12573,20 @@ function formatExpiresAt(expiresAt) {
   return "Expires soon";
 }
 function displayAuthInfo(result) {
-  console.log(`
+  logConsole(`
 Host: ${result.host}`);
   if (result.organizationName) {
-    console.log(`Organization: ${result.organizationName}`);
+    logConsole(`Organization: ${result.organizationName}`);
   }
   if (result.userName) {
-    console.log(`User: ${result.userName}`);
+    logConsole(`User: ${result.userName}`);
   }
   if (result.expiresAt) {
-    console.log(formatExpiresAt(result.expiresAt));
+    logConsole(formatExpiresAt(result.expiresAt));
   }
   logInfoConsole(`Source: ${result.source}`);
   if (result.isExpired) {
-    console.log("\nRun `packmind-cli login` to re-authenticate.");
+    logConsole("\nRun `packmind-cli login` to re-authenticate.");
   }
 }
 var whoamiCommand = (0, import_cmd_ts6.command)({
@@ -12162,14 +12599,14 @@ var whoamiCommand = (0, import_cmd_ts6.command)({
     const result = await packmindCliHexa.whoami({});
     if (!result.isAuthenticated) {
       logErrorConsole("Not authenticated");
-      console.log(
+      logConsole(
         `
 No credentials found. Run \`packmind-cli login\` to authenticate.`
       );
-      console.log(`
+      logConsole(`
 Credentials are loaded from (in order of priority):`);
-      console.log(`  1. PACKMIND_API_KEY_V3 environment variable`);
-      console.log(`  2. ${result.credentialsPath}`);
+      logConsole(`  1. PACKMIND_API_KEY_V3 environment variable`);
+      logConsole(`  2. ${result.credentialsPath}`);
       process.exit(1);
     }
     if (result.isExpired) {
@@ -12186,13 +12623,13 @@ Credentials are loaded from (in order of priority):`);
 
 // apps/cli/src/infra/commands/SetupMcpCommand.ts
 var import_cmd_ts7 = __toESM(require_cjs());
-var fs11 = __toESM(require("fs"));
+var fs12 = __toESM(require("fs"));
 var readline2 = __toESM(require("readline"));
 var inquirer = __toESM(require("inquirer"));
 
 // apps/cli/src/application/services/AgentDetectionService.ts
-var fs10 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
 var os4 = __toESM(require("os"));
 var import_child_process3 = require("child_process");
 var AgentDetectionService = class {
@@ -12219,21 +12656,21 @@ var AgentDetectionService = class {
     return this.isCommandAvailable("claude");
   }
   isCursorAvailable() {
-    const cursorConfigDir = path10.join(os4.homedir(), ".cursor");
-    return fs10.existsSync(cursorConfigDir);
+    const cursorConfigDir = path11.join(os4.homedir(), ".cursor");
+    return fs11.existsSync(cursorConfigDir);
   }
   isVSCodeAvailable() {
-    const vscodeDir = path10.join(this.projectDir, ".vscode");
-    return fs10.existsSync(vscodeDir);
+    const vscodeDir = path11.join(this.projectDir, ".vscode");
+    return fs11.existsSync(vscodeDir);
   }
   isContinueAvailable() {
-    const continueDir = path10.join(this.projectDir, ".continue");
-    return fs10.existsSync(continueDir);
+    const continueDir = path11.join(this.projectDir, ".continue");
+    return fs11.existsSync(continueDir);
   }
-  isCommandAvailable(command9) {
+  isCommandAvailable(command12) {
     try {
       const whichCommand = process.platform === "win32" ? "where" : "which";
-      (0, import_child_process3.execSync)(`${whichCommand} ${command9}`, { stdio: "pipe" });
+      (0, import_child_process3.execSync)(`${whichCommand} ${command12}`, { stdio: "pipe" });
       return true;
     } catch {
       return false;
@@ -12267,8 +12704,8 @@ var ALL_AGENTS2 = [
   { type: "continue", name: "Continue.dev" }
 ];
 async function promptAgentsWithReadline(choices) {
-  const input = fs11.createReadStream("/dev/tty");
-  const output = fs11.createWriteStream("/dev/tty");
+  const input = fs12.createReadStream("/dev/tty");
+  const output = fs12.createWriteStream("/dev/tty");
   const rl = readline2.createInterface({
     input,
     output
@@ -12313,18 +12750,18 @@ var setupMcpCommand = (0, import_cmd_ts7.command)({
     const credentials = loadCredentials();
     if (!credentials) {
       logErrorConsole("Not authenticated");
-      console.log("\nNo credentials found. You can authenticate by either:");
-      console.log("  1. Running `packmind-cli login`");
-      console.log("  2. Setting PACKMIND_API_KEY_V3 environment variable");
-      console.log(`
+      logConsole("\nNo credentials found. You can authenticate by either:");
+      logConsole("  1. Running `packmind-cli login`");
+      logConsole("  2. Setting PACKMIND_API_KEY_V3 environment variable");
+      logConsole(`
 Credentials are loaded from (in order of priority):`);
-      console.log(`  1. PACKMIND_API_KEY_V3 environment variable`);
-      console.log(`  2. ${getCredentialsPath()}`);
+      logConsole(`  1. PACKMIND_API_KEY_V3 environment variable`);
+      logConsole(`  2. ${getCredentialsPath()}`);
       process.exit(1);
     }
     if (credentials.isExpired) {
       logErrorConsole("Credentials expired");
-      console.log("\nRun `packmind-cli login` to re-authenticate.");
+      logConsole("\nRun `packmind-cli login` to re-authenticate.");
       process.exit(1);
     }
     const agentDetectionService = new AgentDetectionService();
@@ -12332,16 +12769,16 @@ Credentials are loaded from (in order of priority):`);
     if (targets.length > 0) {
       selectedAgents = targets.map((t) => agentArgToType[t]);
     } else {
-      console.log("\nDetecting installed AI agents...\n");
+      logConsole("\nDetecting installed AI agents...\n");
       const detectedAgents = agentDetectionService.detectAgents();
       if (detectedAgents.length > 0) {
-        console.log("Found agents:");
+        logConsole("Found agents:");
         detectedAgents.forEach((detectedAgent) => {
-          console.log(`  - ${detectedAgent.name}`);
+          logConsole(`  - ${detectedAgent.name}`);
         });
-        console.log("");
+        logConsole("");
       } else {
-        console.log("No supported agents detected.\n");
+        logConsole("No supported agents detected.\n");
       }
       const detectedTypes = new Set(detectedAgents.map((a) => a.type));
       const choices = ALL_AGENTS2.map((agentInfo) => ({
@@ -12365,12 +12802,12 @@ Credentials are loaded from (in order of priority):`);
         promptedAgents = result2.selectedAgents;
       }
       if (promptedAgents.length === 0) {
-        console.log("\nNo agents selected. Exiting.");
+        logConsole("\nNo agents selected. Exiting.");
         process.exit(0);
       }
       selectedAgents = promptedAgents;
     }
-    console.log("\nFetching MCP configuration...\n");
+    logConsole("\nFetching MCP configuration...\n");
     const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
     const packmindCliHexa = new PackmindCliHexa(packmindLogger);
     let result;
@@ -12379,14 +12816,14 @@ Credentials are loaded from (in order of priority):`);
     } catch (error) {
       logErrorConsole("Failed to fetch MCP configuration from server.");
       if (error instanceof Error) {
-        console.log(`  ${error.message}`);
+        logConsole(`  ${error.message}`);
       }
       process.exit(1);
     }
     let successCount = 0;
     const failedAgents = [];
     for (const agentResult of result.results) {
-      console.log(`Installing MCP for ${agentResult.agentName}...`);
+      logConsole(`Installing MCP for ${agentResult.agentName}...`);
       if (agentResult.success) {
         logSuccessConsole(`  ${agentResult.agentName} configured successfully`);
         successCount++;
@@ -12398,27 +12835,27 @@ Credentials are loaded from (in order of priority):`);
         });
       }
     }
-    console.log("");
+    logConsole("");
     if (failedAgents.length > 0) {
       for (const failed of failedAgents) {
         logWarningConsole(`Failed to configure ${failed.name}:`);
-        console.log(`
+        logConsole(`
   Error: ${failed.error}`);
         if (failed.error.includes("ENOENT") || failed.error.includes("not found") || failed.error.includes("command not found")) {
-          console.log(
+          logConsole(
             `
   Hint: Make sure the agent CLI is installed and available in your PATH.`
           );
         }
-        console.log(`
+        logConsole(`
   Manual configuration:`);
-        console.log(result.manualConfigJson);
-        console.log("");
+        logConsole(result.manualConfigJson ?? "undefined");
+        logConsole("");
       }
     }
     if (successCount > 0) {
       const agentWord = successCount === 1 ? "agent" : "agents";
-      console.log(
+      logConsole(
         formatBold(`Done! MCP configured for ${successCount} ${agentWord}.`)
       );
     }
@@ -12429,7 +12866,7 @@ Credentials are loaded from (in order of priority):`);
 });
 
 // apps/cli/src/infra/commands/SkillsCommand.ts
-var import_cmd_ts9 = __toESM(require_cjs());
+var import_cmd_ts10 = __toESM(require_cjs());
 
 // apps/cli/src/infra/commands/skills/AddSkillCommand.ts
 var import_cmd_ts8 = __toESM(require_cjs());
@@ -12479,12 +12916,425 @@ var addSkillCommand = (0, import_cmd_ts8.command)({
   }
 });
 
+// apps/cli/src/infra/commands/skills/InstallDefaultSkillsCommand.ts
+var import_cmd_ts9 = __toESM(require_cjs());
+var installDefaultSkillsCommand = (0, import_cmd_ts9.command)({
+  name: "install-default",
+  description: "Install default Packmind skills for configured coding agents",
+  args: {},
+  handler: async () => {
+    const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
+    const packmindCliHexa = new PackmindCliHexa(packmindLogger);
+    try {
+      logInfoConsole("Installing default skills...");
+      const result = await packmindCliHexa.installDefaultSkills({});
+      if (result.errors.length > 0) {
+        for (const error of result.errors) {
+          logErrorConsole(`Error: ${error}`);
+        }
+        process.exit(1);
+      }
+      const totalFiles = result.filesCreated + result.filesUpdated;
+      if (totalFiles === 0) {
+        logInfoConsole("Default skills are already up to date.");
+      } else {
+        logSuccessConsole("Default skills installed successfully!");
+        if (result.filesCreated > 0) {
+          logInfoConsole(`  Files created: ${result.filesCreated}`);
+        }
+        if (result.filesUpdated > 0) {
+          logInfoConsole(`  Files updated: ${result.filesUpdated}`);
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        logErrorConsole(`Installation failed: ${error.message}`);
+      } else {
+        logErrorConsole(`Installation failed: ${String(error)}`);
+      }
+      process.exit(1);
+    }
+  }
+});
+
 // apps/cli/src/infra/commands/SkillsCommand.ts
-var skillsCommand = (0, import_cmd_ts9.subcommands)({
+var skillsCommand = (0, import_cmd_ts10.subcommands)({
   name: "skills",
   description: "Manage skills in your Packmind organization",
   cmds: {
-    add: addSkillCommand
+    add: addSkillCommand,
+    init: installDefaultSkillsCommand
+  }
+});
+
+// apps/cli/src/infra/commands/StandardsCommand.ts
+var import_cmd_ts12 = __toESM(require_cjs());
+
+// apps/cli/src/infra/commands/CreateStandardCommand.ts
+var import_cmd_ts11 = __toESM(require_cjs());
+
+// apps/cli/src/infra/utils/readPlaybookFile.ts
+var fs13 = __toESM(require("fs/promises"));
+
+// apps/cli/src/domain/entities/PlaybookDTO.ts
+var import_zod = require("zod");
+var playbookRuleExampleSchema = import_zod.z.object({
+  positive: import_zod.z.string().describe("Valid example of the rule"),
+  negative: import_zod.z.string().describe("Invalid example of the rule"),
+  language: import_zod.z.string().describe("Programming language")
+});
+var playbookRuleSchema = import_zod.z.object({
+  content: import_zod.z.string().min(1).describe("Rule description starting with action verb"),
+  examples: playbookRuleExampleSchema.optional()
+});
+var playbookDTOSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1).describe("Standard name"),
+  description: import_zod.z.string().min(1).describe("Standard description"),
+  scope: import_zod.z.string().min(1).describe("Standard scope/context"),
+  rules: import_zod.z.array(playbookRuleSchema).min(1).describe("Array of rules (minimum 1)")
+});
+
+// apps/cli/src/infra/utils/playbookValidator.ts
+function validatePlaybook(data) {
+  const result = playbookDTOSchema.safeParse(data);
+  if (!result.success) {
+    const errorList = result.error.issues;
+    return {
+      isValid: false,
+      errors: errorList.map((e) => `${e.path.join(".")}: ${e.message}`)
+    };
+  }
+  return {
+    isValid: true,
+    data: result.data
+  };
+}
+
+// apps/cli/src/infra/utils/readPlaybookFile.ts
+async function readPlaybookFile(filePath) {
+  try {
+    const content = await fs13.readFile(filePath, "utf-8");
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch (e) {
+      return {
+        isValid: false,
+        errors: [
+          `Invalid JSON: ${e instanceof Error ? e.message : "Unknown error"}`
+        ]
+      };
+    }
+    return validatePlaybook(parsed);
+  } catch (e) {
+    return {
+      isValid: false,
+      errors: [
+        `Failed to read file: ${e instanceof Error ? e.message : "Unknown error"}`
+      ]
+    };
+  }
+}
+
+// apps/cli/src/infra/commands/createStandardHandler.ts
+async function createStandardHandler(filePath, useCase) {
+  const readResult = await readPlaybookFile(filePath);
+  if (!readResult.isValid) {
+    return {
+      success: false,
+      error: `Validation failed: ${readResult.errors?.join(", ")}`
+    };
+  }
+  if (!readResult.data) {
+    return {
+      success: false,
+      error: "Failed to read playbook data"
+    };
+  }
+  try {
+    const result = await useCase.execute(readResult.data);
+    return {
+      success: true,
+      standardId: result.standardId,
+      standardName: result.name
+    };
+  } catch (e) {
+    return {
+      success: false,
+      error: `Error creating standard: ${e instanceof Error ? e.message : "Unknown error"}`
+    };
+  }
+}
+
+// apps/cli/src/application/useCases/CreateStandardFromPlaybookUseCase.ts
+var CreateStandardFromPlaybookUseCase = class {
+  constructor(gateway) {
+    this.gateway = gateway;
+  }
+  async execute(playbook) {
+    const space = await this.gateway.getGlobalSpace();
+    const standard = await this.gateway.createStandardInSpace(space.id, {
+      name: playbook.name,
+      description: playbook.description,
+      scope: playbook.scope,
+      rules: playbook.rules
+    });
+    const rulesWithExamples = playbook.rules.filter((r) => r.examples);
+    if (rulesWithExamples.length > 0) {
+      const createdRules = await this.gateway.getRulesForStandard(
+        space.id,
+        standard.id
+      );
+      for (let i = 0; i < playbook.rules.length; i++) {
+        const rule = playbook.rules[i];
+        if (rule.examples && createdRules[i]) {
+          try {
+            await this.gateway.addExampleToRule(
+              space.id,
+              standard.id,
+              createdRules[i].id,
+              rule.examples
+            );
+          } catch {
+          }
+        }
+      }
+    }
+    return { standardId: standard.id, name: standard.name };
+  }
+};
+
+// apps/cli/src/infra/commands/CreateStandardCommand.ts
+var createStandardCommand = (0, import_cmd_ts11.command)({
+  name: "create",
+  description: "Create a coding standard from a playbook JSON file",
+  args: {
+    file: (0, import_cmd_ts11.positional)({
+      displayName: "file",
+      description: "Path to the playbook JSON file",
+      type: import_cmd_ts11.string
+    })
+  },
+  handler: async ({ file }) => {
+    try {
+      const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
+      const hexa = new PackmindCliHexa(packmindLogger);
+      const gateway = hexa.getPackmindGateway();
+      const useCase = new CreateStandardFromPlaybookUseCase(gateway);
+      const result = await createStandardHandler(file, useCase);
+      if (result.success) {
+        logSuccessConsole(
+          `Standard "${result.standardName}" created successfully (ID: ${result.standardId})`
+        );
+        process.exit(0);
+      } else {
+        logErrorConsole(`Failed to create standard: ${result.error}`);
+        process.exit(1);
+      }
+    } catch (e) {
+      logErrorConsole(
+        `Error: ${e instanceof Error ? e.message : "Unknown error"}`
+      );
+      process.exit(1);
+    }
+  }
+});
+
+// apps/cli/src/infra/commands/StandardsCommand.ts
+var standardsCommand = (0, import_cmd_ts12.subcommands)({
+  name: "standards",
+  description: "Manage coding standards",
+  cmds: {
+    create: createStandardCommand
+  }
+});
+
+// apps/cli/src/infra/commands/CommandsCommand.ts
+var import_cmd_ts14 = __toESM(require_cjs());
+
+// apps/cli/src/infra/commands/CreateCommandCommand.ts
+var import_cmd_ts13 = __toESM(require_cjs());
+
+// apps/cli/src/infra/utils/readCommandPlaybookFile.ts
+var fs14 = __toESM(require("fs/promises"));
+
+// apps/cli/src/domain/entities/CommandPlaybookDTO.ts
+var import_zod2 = require("zod");
+var commandStepSchema = import_zod2.z.object({
+  name: import_zod2.z.string().min(1).describe("Step name/title"),
+  description: import_zod2.z.string().min(1).describe("Step description with implementation details"),
+  codeSnippet: import_zod2.z.string().optional().describe("Optional code snippet demonstrating the step")
+});
+var commandPlaybookDTOSchema = import_zod2.z.object({
+  name: import_zod2.z.string().min(1).describe("Command name"),
+  summary: import_zod2.z.string().min(1).describe("Command summary describing intent and value"),
+  whenToUse: import_zod2.z.array(import_zod2.z.string().min(1)).min(1).describe("Array of scenarios when this command is applicable (minimum 1)"),
+  contextValidationCheckpoints: import_zod2.z.array(import_zod2.z.string().min(1)).min(1).describe(
+    "Array of checkpoints to validate context before implementation (minimum 1)"
+  ),
+  steps: import_zod2.z.array(commandStepSchema).min(1).describe("Array of implementation steps (minimum 1)")
+});
+
+// apps/cli/src/infra/utils/commandPlaybookValidator.ts
+function validateCommandPlaybook(data) {
+  const result = commandPlaybookDTOSchema.safeParse(data);
+  if (!result.success) {
+    const errorList = result.error.issues;
+    return {
+      isValid: false,
+      errors: errorList.map((e) => `${e.path.join(".")}: ${e.message}`)
+    };
+  }
+  return {
+    isValid: true,
+    data: result.data
+  };
+}
+
+// apps/cli/src/infra/utils/readCommandPlaybookFile.ts
+async function readCommandPlaybookFile(filePath) {
+  try {
+    const content = await fs14.readFile(filePath, "utf-8");
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch (e) {
+      return {
+        isValid: false,
+        errors: [
+          `Invalid JSON: ${e instanceof Error ? e.message : "Unknown error"}`
+        ]
+      };
+    }
+    return validateCommandPlaybook(parsed);
+  } catch (e) {
+    return {
+      isValid: false,
+      errors: [
+        `Failed to read file: ${e instanceof Error ? e.message : "Unknown error"}`
+      ]
+    };
+  }
+}
+
+// apps/cli/src/infra/commands/createCommandHandler.ts
+function buildWebappUrl(host, orgSlug, commandId) {
+  return `${host}/org/${orgSlug}/space/global/commands/${commandId}`;
+}
+async function createCommandHandler(filePath, useCase) {
+  const readResult = await readCommandPlaybookFile(filePath);
+  if (!readResult.isValid) {
+    return {
+      success: false,
+      error: `Validation failed: ${readResult.errors?.join(", ")}`
+    };
+  }
+  if (!readResult.data) {
+    return {
+      success: false,
+      error: "Failed to read command playbook data"
+    };
+  }
+  try {
+    const result = await useCase.execute(readResult.data);
+    let webappUrl;
+    const apiKey = loadApiKey();
+    if (apiKey) {
+      const decoded = decodeApiKey2(apiKey);
+      if (decoded?.host && decoded?.jwt?.organization?.slug) {
+        webappUrl = buildWebappUrl(
+          decoded.host,
+          decoded.jwt.organization.slug,
+          result.commandId
+        );
+      }
+    }
+    return {
+      success: true,
+      commandId: result.commandId,
+      commandName: result.name,
+      webappUrl
+    };
+  } catch (e) {
+    return {
+      success: false,
+      error: `Error creating command: ${e instanceof Error ? e.message : "Unknown error"}`
+    };
+  }
+}
+
+// apps/cli/src/application/useCases/CreateCommandFromPlaybookUseCase.ts
+var CreateCommandFromPlaybookUseCase = class {
+  constructor(gateway) {
+    this.gateway = gateway;
+  }
+  async execute(playbook) {
+    const space = await this.gateway.getGlobalSpace();
+    const command12 = await this.gateway.createCommand(space.id, {
+      name: playbook.name,
+      summary: playbook.summary,
+      whenToUse: playbook.whenToUse,
+      contextValidationCheckpoints: playbook.contextValidationCheckpoints,
+      steps: playbook.steps.map((step) => ({
+        name: step.name,
+        description: step.description,
+        codeSnippet: step.codeSnippet
+      }))
+    });
+    return {
+      commandId: command12.id,
+      name: command12.name,
+      slug: command12.slug
+    };
+  }
+};
+
+// apps/cli/src/infra/commands/CreateCommandCommand.ts
+var createCommandCommand = (0, import_cmd_ts13.command)({
+  name: "create",
+  description: "Create a command from a playbook JSON file",
+  args: {
+    file: (0, import_cmd_ts13.positional)({
+      displayName: "file",
+      description: "Path to the command playbook JSON file",
+      type: import_cmd_ts13.string
+    })
+  },
+  handler: async ({ file }) => {
+    try {
+      const packmindLogger = new PackmindLogger("PackmindCLI", "info" /* INFO */);
+      const hexa = new PackmindCliHexa(packmindLogger);
+      const gateway = hexa.getPackmindGateway();
+      const useCase = new CreateCommandFromPlaybookUseCase(gateway);
+      const result = await createCommandHandler(file, useCase);
+      if (result.success) {
+        logSuccessConsole(
+          `Command "${result.commandName}" created successfully (ID: ${result.commandId})`
+        );
+        if (result.webappUrl) {
+          logConsole("");
+          logConsole(`View it in the webapp: ${result.webappUrl}`);
+        }
+        process.exit(0);
+      } else {
+        logErrorConsole(`Failed to create command: ${result.error}`);
+        process.exit(1);
+      }
+    } catch (e) {
+      logErrorConsole(
+        `Error: ${e instanceof Error ? e.message : "Unknown error"}`
+      );
+      process.exit(1);
+    }
+  }
+});
+
+// apps/cli/src/infra/commands/CommandsCommand.ts
+var commandsCommand = (0, import_cmd_ts14.subcommands)({
+  name: "commands",
+  description: "Manage commands",
+  cmds: {
+    create: createCommandCommand
   }
 });
 
@@ -12494,20 +13344,20 @@ function findEnvFile() {
   const currentDir = process.cwd();
   const gitService = new GitService();
   const gitRoot = gitService.getGitRepositoryRootSync(currentDir);
-  const filesystemRoot = path11.parse(currentDir).root;
+  const filesystemRoot = path12.parse(currentDir).root;
   const stopDir = gitRoot ?? filesystemRoot;
   let searchDir = currentDir;
-  let parentDir = path11.dirname(searchDir);
+  let parentDir = path12.dirname(searchDir);
   while (searchDir !== parentDir) {
-    const envPath2 = path11.join(searchDir, ".env");
-    if (fs12.existsSync(envPath2)) {
+    const envPath2 = path12.join(searchDir, ".env");
+    if (fs15.existsSync(envPath2)) {
       return envPath2;
     }
     if (searchDir === stopDir) {
       return null;
     }
     searchDir = parentDir;
-    parentDir = path11.dirname(searchDir);
+    parentDir = path12.dirname(searchDir);
   }
   return null;
 }
@@ -12524,10 +13374,10 @@ if (hasEmbeddedWasmFiles()) {
 }
 var args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-v")) {
-  console.log(`packmind-cli version ${CLI_VERSION}`);
+  logConsole(`packmind-cli version ${CLI_VERSION}`);
   process.exit(0);
 }
-var app = (0, import_cmd_ts10.subcommands)({
+var app = (0, import_cmd_ts15.subcommands)({
   name: "packmind-cli",
   description: "Packmind CLI tool",
   cmds: {
@@ -12540,10 +13390,12 @@ var app = (0, import_cmd_ts10.subcommands)({
     logout: logoutCommand,
     whoami: whoamiCommand,
     "setup-mcp": setupMcpCommand,
-    skills: skillsCommand
+    skills: skillsCommand,
+    standards: standardsCommand,
+    commands: commandsCommand
   }
 });
-(0, import_cmd_ts10.run)(app, args).catch((error) => {
+(0, import_cmd_ts15.run)(app, args).catch((error) => {
   logErrorConsole(error.message);
   process.exit(1);
 });