@powerformer/refly-cli 0.1.15 → 0.1.17

package/dist/index.js

@@ -6,6 +6,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -28,6 +31,510 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../../node_modules/.pnpm/tsup@8.5.1_@swc+core@1.12.14_@swc+helpers@0.5.17__jiti@2.6.1_postcss@8.5.6_tsx@4.20.6_typescript@5.8.3_yaml@2.8.0/node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.5.1_@swc+core@1.12.14_@swc+helpers@0.5.17__jiti@2.6.1_postcss@8.5.6_tsx@4.20.6_typescript@5.8.3_yaml@2.8.0/node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/config/paths.ts
+function getReflyDir() {
+  const dir = path.join(os.homedir(), ".refly");
+  ensureDir(dir);
+  return dir;
+}
+function getClaudeCommandsDir() {
+  return path.join(os.homedir(), ".claude", "commands");
+}
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+}
+function getConfigPath() {
+  return path.join(getReflyDir(), "config.json");
+}
+function getReflySkillsDir() {
+  return path.join(getReflyDir(), "skills");
+}
+function getReflyBaseSkillDir() {
+  return path.join(getReflySkillsDir(), "base");
+}
+function getReflyDomainSkillDir(skillName) {
+  return path.join(getReflySkillsDir(), skillName);
+}
+function getClaudeSkillsDir() {
+  return path.join(os.homedir(), ".claude", "skills");
+}
+function getClaudeSkillSymlinkPath(skillName) {
+  return path.join(getClaudeSkillsDir(), skillName);
+}
+function ensureReflySkillsDir() {
+  const dir = getReflySkillsDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+}
+function ensureClaudeSkillsDir() {
+  const dir = getClaudeSkillsDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 493 });
+  }
+}
+var os, path, fs;
+var init_paths = __esm({
+  "src/config/paths.ts"() {
+    "use strict";
+    init_cjs_shims();
+    os = __toESM(require("os"));
+    path = __toESM(require("path"));
+    fs = __toESM(require("fs"));
+  }
+});
+
+// src/utils/logger.ts
+function redact(message) {
+  let result = message;
+  for (const pattern of SENSITIVE_PATTERNS) {
+    result = result.replace(pattern, "[REDACTED]");
+  }
+  return result;
+}
+var fs3, path3, LOG_FILE, MAX_LOG_SIZE, LOG_LEVELS, SENSITIVE_PATTERNS, Logger, logger;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs3 = __toESM(require("fs"));
+    path3 = __toESM(require("path"));
+    init_paths();
+    LOG_FILE = "cli.log";
+    MAX_LOG_SIZE = 5 * 1024 * 1024;
+    LOG_LEVELS = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    SENSITIVE_PATTERNS = [
+      /Bearer\s+[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+/gi,
+      /[A-Za-z0-9]{32,}/g,
+      // API keys
+      /"(access_?token|refresh_?token|api_?key|secret|password)":\s*"[^"]+"/gi
+    ];
+    Logger = class {
+      level = "info";
+      logToFile = false;
+      setLevel(level) {
+        this.level = level;
+      }
+      enableFileLogging() {
+        this.logToFile = true;
+      }
+      shouldLog(level) {
+        return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+      }
+      formatMessage(level, message) {
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const safeMessage = redact(message);
+        return `[${timestamp}] [${level.toUpperCase()}] ${safeMessage}`;
+      }
+      writeToFile(formatted) {
+        if (!this.logToFile) return;
+        try {
+          const logPath = path3.join(getReflyDir(), LOG_FILE);
+          try {
+            const stats = fs3.statSync(logPath);
+            if (stats.size > MAX_LOG_SIZE) {
+              fs3.renameSync(logPath, `${logPath}.old`);
+            }
+          } catch {
+          }
+          fs3.appendFileSync(logPath, `${formatted}
+`);
+        } catch {
+        }
+      }
+      debug(message, ...args) {
+        if (!this.shouldLog("debug")) return;
+        const formatted = this.formatMessage("debug", this.interpolate(message, args));
+        this.writeToFile(formatted);
+      }
+      info(message, ...args) {
+        if (!this.shouldLog("info")) return;
+        const formatted = this.formatMessage("info", this.interpolate(message, args));
+        this.writeToFile(formatted);
+      }
+      warn(message, ...args) {
+        if (!this.shouldLog("warn")) return;
+        const formatted = this.formatMessage("warn", this.interpolate(message, args));
+        this.writeToFile(formatted);
+      }
+      error(message, ...args) {
+        if (!this.shouldLog("error")) return;
+        const formatted = this.formatMessage("error", this.interpolate(message, args));
+        this.writeToFile(formatted);
+      }
+      interpolate(message, args) {
+        if (args.length === 0) return message;
+        return `${message} ${args.map((a) => JSON.stringify(a)).join(" ")}`;
+      }
+    };
+    logger = new Logger();
+  }
+});
+
+// src/skill/symlink.ts
+var symlink_exports = {};
+__export(symlink_exports, {
+  createReflySkillWithSymlink: () => createReflySkillWithSymlink,
+  createSkillSymlink: () => createSkillSymlink,
+  deleteDomainSkillWithSymlink: () => deleteDomainSkillWithSymlink,
+  generateReflySkillMd: () => generateReflySkillMd,
+  initializeBaseSkillSymlink: () => initializeBaseSkillSymlink,
+  isSkillSymlinkValid: () => isSkillSymlinkValid,
+  listSkillSymlinks: () => listSkillSymlinks,
+  parseReflySkillMd: () => parseReflySkillMd,
+  removeSkillSymlink: () => removeSkillSymlink
+});
+function createSkillSymlink(skillName) {
+  const reflyPath = skillName === "refly" ? getReflyBaseSkillDir() : getReflyDomainSkillDir(skillName);
+  const claudePath = getClaudeSkillSymlinkPath(skillName);
+  try {
+    ensureReflySkillsDir();
+    ensureClaudeSkillsDir();
+    if (!fs5.existsSync(reflyPath)) {
+      return {
+        success: false,
+        skillName,
+        reflyPath,
+        claudePath,
+        error: `Source skill directory does not exist: ${reflyPath}`
+      };
+    }
+    if (fs5.existsSync(claudePath) || fs5.lstatSync(claudePath).isSymbolicLink()) {
+      const stat = fs5.lstatSync(claudePath);
+      if (stat.isSymbolicLink()) {
+        fs5.unlinkSync(claudePath);
+        logger.debug(`Removed existing symlink: ${claudePath}`);
+      } else if (stat.isDirectory()) {
+        logger.warn(`Cannot create symlink: ${claudePath} is a directory, not a symlink`);
+        return {
+          success: false,
+          skillName,
+          reflyPath,
+          claudePath,
+          error: `Target path is a directory, not a symlink: ${claudePath}`
+        };
+      }
+    }
+    fs5.symlinkSync(reflyPath, claudePath, "dir");
+    logger.info(`Created symlink: ${claudePath} -> ${reflyPath}`);
+    return {
+      success: true,
+      skillName,
+      reflyPath,
+      claudePath
+    };
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      try {
+        fs5.symlinkSync(reflyPath, claudePath, "dir");
+        logger.info(`Created symlink: ${claudePath} -> ${reflyPath}`);
+        return {
+          success: true,
+          skillName,
+          reflyPath,
+          claudePath
+        };
+      } catch (innerErr) {
+        return {
+          success: false,
+          skillName,
+          reflyPath,
+          claudePath,
+          error: innerErr.message
+        };
+      }
+    }
+    return {
+      success: false,
+      skillName,
+      reflyPath,
+      claudePath,
+      error: err.message
+    };
+  }
+}
+function removeSkillSymlink(skillName) {
+  const claudePath = getClaudeSkillSymlinkPath(skillName);
+  try {
+    if (!fs5.existsSync(claudePath)) {
+      logger.debug(`Symlink not found: ${claudePath}`);
+      return false;
+    }
+    const stat = fs5.lstatSync(claudePath);
+    if (!stat.isSymbolicLink()) {
+      logger.warn(`Not a symlink: ${claudePath}`);
+      return false;
+    }
+    fs5.unlinkSync(claudePath);
+    logger.info(`Removed symlink: ${claudePath}`);
+    return true;
+  } catch (err) {
+    logger.error(`Failed to remove symlink ${claudePath}:`, err);
+    return false;
+  }
+}
+function isSkillSymlinkValid(skillName) {
+  const claudePath = getClaudeSkillSymlinkPath(skillName);
+  const expectedTarget = skillName === "refly" ? getReflyBaseSkillDir() : getReflyDomainSkillDir(skillName);
+  try {
+    if (!fs5.existsSync(claudePath)) {
+      return { exists: false, isSymlink: false, isValid: false };
+    }
+    const stat = fs5.lstatSync(claudePath);
+    if (!stat.isSymbolicLink()) {
+      return { exists: true, isSymlink: false, isValid: false };
+    }
+    const target = fs5.readlinkSync(claudePath);
+    const resolvedTarget = path5.resolve(path5.dirname(claudePath), target);
+    const isValid2 = resolvedTarget === expectedTarget && fs5.existsSync(resolvedTarget);
+    return {
+      exists: true,
+      isSymlink: true,
+      isValid: isValid2,
+      target: resolvedTarget
+    };
+  } catch {
+    return { exists: false, isSymlink: false, isValid: false };
+  }
+}
+function initializeBaseSkillSymlink() {
+  const baseDir = getReflyBaseSkillDir();
+  ensureDir(baseDir);
+  ensureDir(path5.join(baseDir, "rules"));
+  return createSkillSymlink("refly");
+}
+function createReflySkillWithSymlink(skillName, skillMdContent) {
+  const skillDir = getReflyDomainSkillDir(skillName);
+  try {
+    ensureReflySkillsDir();
+    if (fs5.existsSync(skillDir)) {
+      return {
+        success: false,
+        skillName,
+        reflyPath: skillDir,
+        claudePath: getClaudeSkillSymlinkPath(skillName),
+        error: `Skill directory already exists: ${skillDir}`
+      };
+    }
+    fs5.mkdirSync(skillDir, { recursive: true, mode: 493 });
+    const skillMdPath = path5.join(skillDir, "SKILL.md");
+    fs5.writeFileSync(skillMdPath, skillMdContent, { encoding: "utf-8", mode: 420 });
+    logger.debug(`Created SKILL.md: ${skillMdPath}`);
+    return createSkillSymlink(skillName);
+  } catch (err) {
+    return {
+      success: false,
+      skillName,
+      reflyPath: skillDir,
+      claudePath: getClaudeSkillSymlinkPath(skillName),
+      error: err.message
+    };
+  }
+}
+function deleteDomainSkillWithSymlink(skillName) {
+  const symlinkRemoved = removeSkillSymlink(skillName);
+  const skillDir = getReflyDomainSkillDir(skillName);
+  let directoryRemoved = false;
+  try {
+    if (fs5.existsSync(skillDir)) {
+      fs5.rmSync(skillDir, { recursive: true, force: true });
+      directoryRemoved = true;
+      logger.info(`Removed skill directory: ${skillDir}`);
+    }
+  } catch (err) {
+    logger.error(`Failed to remove skill directory ${skillDir}:`, err);
+  }
+  return { symlinkRemoved, directoryRemoved };
+}
+function listSkillSymlinks() {
+  const claudeSkillsDir = getClaudeSkillsDir();
+  const results = [];
+  if (!fs5.existsSync(claudeSkillsDir)) {
+    return results;
+  }
+  try {
+    const entries = fs5.readdirSync(claudeSkillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path5.join(claudeSkillsDir, entry.name);
+      try {
+        const stat = fs5.lstatSync(fullPath);
+        if (stat.isSymbolicLink()) {
+          const target = fs5.readlinkSync(fullPath);
+          const resolvedTarget = path5.resolve(path5.dirname(fullPath), target);
+          const isValid2 = fs5.existsSync(resolvedTarget);
+          results.push({
+            name: entry.name,
+            claudePath: fullPath,
+            target: resolvedTarget,
+            isValid: isValid2
+          });
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function generateReflySkillMd(options) {
+  const {
+    name,
+    displayName,
+    description,
+    skillId,
+    workflowId,
+    installationId,
+    triggers = [],
+    tags = [],
+    version = "1.0.0",
+    inputSchema,
+    outputSchema
+  } = options;
+  const frontmatterLines = ["---", `name: ${name}`];
+  frontmatterLines.push(`description: ${description}`);
+  if (tags.length > 0) {
+    frontmatterLines.push("tags:");
+    frontmatterLines.push(...tags.map((t) => `  - ${t}`));
+  }
+  frontmatterLines.push(`version: ${version}`);
+  frontmatterLines.push(`skillId: ${skillId}`);
+  frontmatterLines.push(`workflowId: ${workflowId}`);
+  if (installationId) {
+    frontmatterLines.push(`installationId: ${installationId}`);
+  }
+  if (triggers.length > 0) {
+    frontmatterLines.push("triggers:");
+    frontmatterLines.push(...triggers.map((t) => `  - ${t}`));
+  }
+  frontmatterLines.push("---");
+  const title = displayName || name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+  const inputExample = inputSchema ? JSON.stringify(inputSchema, null, 2) : `{
+  "query": "your input here"
+}`;
+  const runCommand = installationId ? `refly skill run ${installationId} --input '${inputSchema ? JSON.stringify(inputSchema) : "{}"}'` : `refly workflow run ${workflowId} --input '${inputSchema ? JSON.stringify(inputSchema) : "{}"}'`;
+  const outputSection = outputSchema ? `The skill returns:
+
+\`\`\`json
+${JSON.stringify(outputSchema, null, 2)}
+\`\`\`` : "The skill returns the workflow execution result.";
+  const content = `
+
+# ${title}
+
+${description}
+
+## Usage
+
+This skill is executed via Refly CLI:
+
+\`\`\`bash
+${runCommand}
+\`\`\`
+
+## Input
+
+Provide input as JSON:
+
+\`\`\`json
+${inputExample}
+\`\`\`
+
+## Output
+
+${outputSection}
+
+## Rules
+
+For workflow operations, refer to the base skill rules:
+- Workflow: \`~/.claude/skills/refly/rules/workflow.md\`
+- Node: \`~/.claude/skills/refly/rules/node.md\`
+- File: \`~/.claude/skills/refly/rules/file.md\`
+`;
+  return frontmatterLines.join("\n") + content;
+}
+function parseReflySkillMd(content) {
+  const frontmatterRegex = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    throw new Error("Invalid SKILL.md format: missing frontmatter");
+  }
+  const [, frontmatterStr, body] = match;
+  const meta = {};
+  const lines = frontmatterStr.split("\n");
+  let currentKey = null;
+  let currentArray = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("- ")) {
+      if (currentKey) {
+        currentArray.push(trimmed.slice(2).trim());
+      }
+      continue;
+    }
+    if (currentKey && currentArray.length > 0) {
+      meta[currentKey] = currentArray;
+      currentArray = [];
+      currentKey = null;
+    }
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex > 0) {
+      const key = trimmed.slice(0, colonIndex).trim();
+      const value = trimmed.slice(colonIndex + 1).trim();
+      if (value === "") {
+        currentKey = key;
+        currentArray = [];
+      } else {
+        meta[key] = value;
+      }
+    }
+  }
+  if (currentKey && currentArray.length > 0) {
+    meta[currentKey] = currentArray;
+  }
+  if (!meta.name) {
+    throw new Error('Invalid SKILL.md: missing required field "name"');
+  }
+  if (!meta.description) {
+    throw new Error('Invalid SKILL.md: missing required field "description"');
+  }
+  if (!meta.skillId) {
+    throw new Error('Invalid SKILL.md: missing required field "skillId"');
+  }
+  if (!meta.workflowId) {
+    throw new Error('Invalid SKILL.md: missing required field "workflowId"');
+  }
+  return {
+    meta,
+    body: body.trim(),
+    raw: content
+  };
+}
+var fs5, path5;
+var init_symlink = __esm({
+  "src/skill/symlink.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs5 = __toESM(require("fs"));
+    path5 = __toESM(require("path"));
+    init_paths();
+    init_logger();
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -45,8 +552,16 @@ __export(src_exports, {
   verifyConnection: () => verifyConnection
 });
 module.exports = __toCommonJS(src_exports);
+init_cjs_shims();
+
+// src/utils/output.ts
+init_cjs_shims();
+
+// src/utils/formatter.ts
+init_cjs_shims();
 
 // src/utils/ui.ts
+init_cjs_shims();
 var Style = {
   // Reset
   RESET: "\x1B[0m",
@@ -146,12 +661,14 @@ var ErrorCodes = {
 };
 
 // src/utils/errors.ts
+init_cjs_shims();
 var CLIError = class extends Error {
-  constructor(code, message, details, hint) {
+  constructor(code, message, details, hint, suggestedFix) {
     super(message);
     this.code = code;
     this.details = details;
     this.hint = hint;
+    this.suggestedFix = suggestedFix;
     this.name = "CLIError";
   }
 };
@@ -172,11 +689,15 @@ var NetworkError = class extends CLIError {
 };
 
 // src/config/config.ts
+init_cjs_shims();
 var fs2 = __toESM(require("fs"));
 var path2 = __toESM(require("path"));
 var os2 = __toESM(require("os"));
 var crypto = __toESM(require("crypto"));
 
+// ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/index.js
+init_cjs_shims();
+
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -288,8 +809,19 @@ __export(external_exports, {
   util: () => util,
   void: () => voidType
 });
+init_cjs_shims();
+
+// ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/errors.js
+init_cjs_shims();
+
+// ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/locales/en.js
+init_cjs_shims();
+
+// ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/ZodError.js
+init_cjs_shims();
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/util.js
+init_cjs_shims();
 var util;
 (function(util2) {
   util2.assertEqual = (_) => {
@@ -654,9 +1186,10 @@ function getErrorMap() {
 }
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
+init_cjs_shims();
 var makeIssue = (params) => {
-  const { data, path: path6, errorMaps, issueData } = params;
-  const fullPath = [...path6, ...issueData.path || []];
+  const { data, path: path7, errorMaps, issueData } = params;
+  const fullPath = [...path7, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -763,7 +1296,11 @@ var isDirty = (x) => x.status === "dirty";
 var isValid = (x) => x.status === "valid";
 var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
 
+// ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
+init_cjs_shims();
+
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/errorUtil.js
+init_cjs_shims();
 var errorUtil;
 (function(errorUtil2) {
   errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
@@ -772,11 +1309,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path6, key) {
+  constructor(parent, value, path7, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path6;
+    this._path = path7;
     this._key = key;
   }
   get path() {
@@ -4218,31 +4755,8 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// src/config/paths.ts
-var os = __toESM(require("os"));
-var path = __toESM(require("path"));
-var fs = __toESM(require("fs"));
-function getReflyDir() {
-  const dir = path.join(os.homedir(), ".refly");
-  ensureDir(dir);
-  return dir;
-}
-function getClaudeSkillDir() {
-  return path.join(os.homedir(), ".claude", "skills", "refly");
-}
-function getClaudeCommandsDir() {
-  return path.join(os.homedir(), ".claude", "commands");
-}
-function ensureDir(dir) {
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true, mode: 448 });
-  }
-}
-function getConfigPath() {
-  return path.join(getReflyDir(), "config.json");
-}
-
 // src/config/config.ts
+init_paths();
 var ConfigSchema = external_exports.object({
   version: external_exports.number().default(1),
   auth: external_exports.object({
@@ -4272,7 +4786,7 @@ var ConfigSchema = external_exports.object({
     installedAt: external_exports.string().optional()
   }).optional()
 });
-var DEFAULT_API_ENDPOINT = "https://api.refly.ai";
+var DEFAULT_API_ENDPOINT = "https://refly-api.powerformer.net";
 var DEFAULT_CONFIG = {
   version: 1,
   api: {
@@ -4370,101 +4884,17 @@ function getApiKey() {
 }
 
 // src/api/client.ts
+init_cjs_shims();
 var fs4 = __toESM(require("fs"));
 var import_node_fs = require("fs");
 var path4 = __toESM(require("path"));
 var import_mime = __toESM(require("mime"));
-
-// src/utils/logger.ts
-var fs3 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
-var LOG_FILE = "cli.log";
-var MAX_LOG_SIZE = 5 * 1024 * 1024;
-var LOG_LEVELS = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3
-};
-var SENSITIVE_PATTERNS = [
-  /Bearer\s+[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+/gi,
-  /[A-Za-z0-9]{32,}/g,
-  // API keys
-  /"(access_?token|refresh_?token|api_?key|secret|password)":\s*"[^"]+"/gi
-];
-function redact(message) {
-  let result = message;
-  for (const pattern of SENSITIVE_PATTERNS) {
-    result = result.replace(pattern, "[REDACTED]");
-  }
-  return result;
-}
-var Logger = class {
-  level = "info";
-  logToFile = false;
-  setLevel(level) {
-    this.level = level;
-  }
-  enableFileLogging() {
-    this.logToFile = true;
-  }
-  shouldLog(level) {
-    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
-  }
-  formatMessage(level, message) {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const safeMessage = redact(message);
-    return `[${timestamp}] [${level.toUpperCase()}] ${safeMessage}`;
-  }
-  writeToFile(formatted) {
-    if (!this.logToFile) return;
-    try {
-      const logPath = path3.join(getReflyDir(), LOG_FILE);
-      try {
-        const stats = fs3.statSync(logPath);
-        if (stats.size > MAX_LOG_SIZE) {
-          fs3.renameSync(logPath, `${logPath}.old`);
-        }
-      } catch {
-      }
-      fs3.appendFileSync(logPath, `${formatted}
-`);
-    } catch {
-    }
-  }
-  debug(message, ...args) {
-    if (!this.shouldLog("debug")) return;
-    const formatted = this.formatMessage("debug", this.interpolate(message, args));
-    this.writeToFile(formatted);
-  }
-  info(message, ...args) {
-    if (!this.shouldLog("info")) return;
-    const formatted = this.formatMessage("info", this.interpolate(message, args));
-    this.writeToFile(formatted);
-  }
-  warn(message, ...args) {
-    if (!this.shouldLog("warn")) return;
-    const formatted = this.formatMessage("warn", this.interpolate(message, args));
-    this.writeToFile(formatted);
-  }
-  error(message, ...args) {
-    if (!this.shouldLog("error")) return;
-    const formatted = this.formatMessage("error", this.interpolate(message, args));
-    this.writeToFile(formatted);
-  }
-  interpolate(message, args) {
-    if (args.length === 0) return message;
-    return `${message} ${args.map((a) => JSON.stringify(a)).join(" ")}`;
-  }
-};
-var logger = new Logger();
-
-// src/api/client.ts
+init_logger();
 var DEFAULT_TIMEOUT = 3e4;
-async function apiRequest(path6, options = {}) {
+async function apiRequest(path7, options = {}) {
   const { method = "GET", body, query, timeout = DEFAULT_TIMEOUT, requireAuth = true } = options;
   const endpoint = getApiEndpoint();
-  let url = `${endpoint}${path6}`;
+  let url = `${endpoint}${path7}`;
   if (query && Object.keys(query).length > 0) {
     const params = new URLSearchParams(query);
     url = `${url}?${params.toString()}`;
@@ -4502,7 +4932,7 @@ async function apiRequest(path6, options = {}) {
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), timeout);
   try {
-    logger.debug(`API Request: ${method} ${path6}`);
+    logger.debug(`API Request: ${method} ${path7}`);
     const response = await fetch(url, {
       method,
       headers,
@@ -4594,7 +5024,8 @@ function mapAPIError(status, response) {
       cliError.code || "UNKNOWN",
       cliError.message || "Unknown error",
       void 0,
-      cliError.hint
+      cliError.hint,
+      cliError.suggestedFix
     );
   }
   const errCode = response.errCode ?? response.error ?? "UNKNOWN";
@@ -4646,21 +5077,42 @@ async function verifyConnection() {
 }
 
 // src/skill/installer.ts
-var fs5 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+init_cjs_shims();
+var fs6 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
+init_paths();
+init_logger();
+init_symlink();
+function removeOldSkillDirectory() {
+  const claudeSkillPath = getClaudeSkillSymlinkPath("refly");
+  if (!fs6.existsSync(claudeSkillPath)) {
+    return;
+  }
+  try {
+    const stat = fs6.lstatSync(claudeSkillPath);
+    if (stat.isSymbolicLink()) {
+      fs6.unlinkSync(claudeSkillPath);
+    } else if (stat.isDirectory()) {
+      fs6.rmSync(claudeSkillPath, { recursive: true, force: true });
+      logger.info("Removed old skill directory");
+    }
+  } catch (err) {
+    logger.warn("Failed to remove old directory:", err);
+  }
+}
 function getPackageSkillDir() {
   const possiblePaths = [
-    path5.join(__dirname, "..", "..", "skill"),
+    path6.join(__dirname, "..", "..", "skill"),
     // Built package: dist/bin/../../skill
-    path5.join(__dirname, "..", "..", "..", "skill"),
+    path6.join(__dirname, "..", "..", "..", "skill"),
     // Development: dist/bin/../../../skill
-    path5.join(__dirname, "..", "skill")
+    path6.join(__dirname, "..", "skill")
     // Alternative: dist/../skill
   ];
   logger.debug("Looking for skill files, __dirname:", __dirname);
   for (const p of possiblePaths) {
-    const resolved = path5.resolve(p);
-    const exists = fs5.existsSync(resolved);
+    const resolved = path6.resolve(p);
+    const exists = fs6.existsSync(resolved);
     logger.debug(`  Checking path: ${resolved} - exists: ${exists}`);
     if (exists) {
       return resolved;
@@ -4672,42 +5124,52 @@ function installSkill() {
   const result = {
     skillInstalled: false,
     skillPath: null,
+    symlinkPath: null,
     commandsInstalled: false,
     commandsPath: null,
     version: getSkillVersion()
   };
   const sourceDir = getPackageSkillDir();
   logger.debug("Source skill directory:", sourceDir);
-  const targetDir = getClaudeSkillDir();
+  ensureReflySkillsDir();
+  const targetDir = getReflyBaseSkillDir();
   logger.debug("Target skill directory:", targetDir);
   try {
     ensureDir(targetDir);
-    ensureDir(path5.join(targetDir, "references"));
+    ensureDir(path6.join(targetDir, "rules"));
     logger.debug("Created target directories");
   } catch (err) {
     logger.error("Failed to create target directories:", err);
     throw err;
   }
-  const skillSource = path5.join(sourceDir, "SKILL.md");
-  const skillTarget = path5.join(targetDir, "SKILL.md");
+  const skillSource = path6.join(sourceDir, "SKILL.md");
+  const skillTarget = path6.join(targetDir, "SKILL.md");
   logger.debug(`Copying SKILL.md: ${skillSource} -> ${skillTarget}`);
-  if (fs5.existsSync(skillSource)) {
-    fs5.copyFileSync(skillSource, skillTarget);
+  if (fs6.existsSync(skillSource)) {
+    fs6.copyFileSync(skillSource, skillTarget);
     result.skillInstalled = true;
     result.skillPath = targetDir;
     logger.debug("SKILL.md copied successfully");
   } else {
     logger.warn("SKILL.md source not found:", skillSource);
   }
-  const refsSource = path5.join(sourceDir, "references");
-  const refsTarget = path5.join(targetDir, "references");
-  if (fs5.existsSync(refsSource)) {
-    const files = fs5.readdirSync(refsSource);
-    logger.debug(`Copying ${files.length} reference files`);
+  const refsSource = path6.join(sourceDir, "references");
+  const rulesTarget = path6.join(targetDir, "rules");
+  if (fs6.existsSync(refsSource)) {
+    const files = fs6.readdirSync(refsSource);
+    logger.debug(`Copying ${files.length} rule files`);
     for (const file of files) {
-      fs5.copyFileSync(path5.join(refsSource, file), path5.join(refsTarget, file));
+      fs6.copyFileSync(path6.join(refsSource, file), path6.join(rulesTarget, file));
     }
   }
+  removeOldSkillDirectory();
+  const symlinkResult = createSkillSymlink("refly");
+  if (symlinkResult.success) {
+    result.symlinkPath = symlinkResult.claudePath;
+    logger.info(`Created symlink: ${symlinkResult.claudePath} -> ${symlinkResult.reflyPath}`);
+  } else {
+    logger.warn(`Failed to create symlink: ${symlinkResult.error}`);
+  }
   const commandsDir = getClaudeCommandsDir();
   logger.debug("Commands directory:", commandsDir);
   ensureDir(commandsDir);
@@ -4719,20 +5181,21 @@ function installSkill() {
   updateSkillInfo(result.version);
   logger.info("Skill installation complete:", {
     skillInstalled: result.skillInstalled,
+    symlinkPath: result.symlinkPath,
     commandsInstalled: result.commandsInstalled
   });
   return result;
 }
 function installSlashCommands(sourceDir, targetDir) {
-  const commandsSource = path5.join(sourceDir, "..", "commands");
-  if (!fs5.existsSync(commandsSource)) {
+  const commandsSource = path6.join(sourceDir, "..", "commands");
+  if (!fs6.existsSync(commandsSource)) {
     return false;
   }
   try {
-    const files = fs5.readdirSync(commandsSource);
+    const files = fs6.readdirSync(commandsSource);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        fs5.copyFileSync(path5.join(commandsSource, file), path5.join(targetDir, file));
+        fs6.copyFileSync(path6.join(commandsSource, file), path6.join(targetDir, file));
       }
     }
     return files.length > 0;
@@ -4742,8 +5205,8 @@ function installSlashCommands(sourceDir, targetDir) {
 }
 function getSkillVersion() {
   try {
-    const skillPath = path5.join(getPackageSkillDir(), "SKILL.md");
-    const content = fs5.readFileSync(skillPath, "utf-8");
+    const skillPath = path6.join(getPackageSkillDir(), "SKILL.md");
+    const content = fs6.readFileSync(skillPath, "utf-8");
     const versionMatch = content.match(/version:\s*(\d+\.\d+\.\d+)/);
     if (versionMatch) {
       return versionMatch[1];
@@ -4751,23 +5214,26 @@ function getSkillVersion() {
   } catch {
   }
   try {
-    const pkgPath = path5.join(__dirname, "..", "..", "package.json");
-    const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path6.join(__dirname, "..", "..", "package.json");
+    const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
     return pkg.version;
   } catch {
     return "0.1.0";
   }
 }
 function isSkillInstalled() {
-  const skillPath = path5.join(getClaudeSkillDir(), "SKILL.md");
-  if (!fs5.existsSync(skillPath)) {
+  const skillPath = path6.join(getReflyBaseSkillDir(), "SKILL.md");
+  if (!fs6.existsSync(skillPath)) {
     return { installed: false, upToDate: false };
   }
   const currentVersion = getSkillVersion();
+  const { isSkillSymlinkValid: isSkillSymlinkValid2 } = (init_symlink(), __toCommonJS(symlink_exports));
+  const symlinkStatus = isSkillSymlinkValid2("refly");
   return {
     installed: true,
     upToDate: true,
-    currentVersion
+    currentVersion,
+    symlinkValid: symlinkStatus.isValid
   };
 }
 // Annotate the CommonJS export names for ESM import in node: