@take-out/cli 0.0.39

package/dist/cjs/commands/script.cjs

@@ -0,0 +1,379 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var script_exports = {};
+__export(script_exports, {
+  createShorthandCommand: () => createShorthandCommand,
+  discoverScripts: () => discoverScripts,
+  findScript: () => findScript,
+  formatScriptList: () => import_script_listing2.formatScriptList,
+  getLocalScriptsDir: () => getLocalScriptsDir,
+  getScriptMetadata: () => getScriptMetadata,
+  listAllScripts: () => import_script_listing2.listAllScripts,
+  listCategoryScripts: () => import_script_listing2.listCategoryScripts,
+  scriptCommand: () => scriptCommand
+});
+module.exports = __toCommonJS(script_exports);
+var import_node_fs = require("node:fs"),
+  import_node_os = require("node:os"),
+  import_node_path = require("node:path"),
+  import_node_url = require("node:url"),
+  import_citty = require("citty"),
+  import_picocolors = __toESM(require("picocolors"), 1),
+  import_script_listing = require("../utils/script-listing.cjs"),
+  import_sync = require("../utils/sync.cjs"),
+  import_script_listing2 = require("../utils/script-listing.cjs");
+const import_meta = {},
+  CACHE_DIR = (0, import_node_path.join)((0, import_node_os.homedir)(), ".takeout"),
+  CACHE_FILE = (0, import_node_path.join)(CACHE_DIR, "script-cache.json");
+function findScriptsPackageRoot() {
+  try {
+    const resolved = import_meta.resolve("@take-out/scripts/package.json"),
+      packageJsonPath = (0, import_node_url.fileURLToPath)(new URL(resolved)),
+      packageRoot = (0, import_node_path.join)(packageJsonPath, ".."),
+      srcPath = (0, import_node_path.join)(packageRoot, "src");
+    if ((0, import_node_fs.existsSync)(srcPath)) return srcPath;
+  } catch {}
+  return null;
+}
+function getLocalScriptsDir() {
+  return (0, import_node_path.join)(process.cwd(), "scripts");
+}
+function extractMetadata(filePath) {
+  try {
+    const lines = (0, import_node_fs.readFileSync)(filePath, "utf-8").split(`
+`).slice(0, 20),
+      metadata = {};
+    for (const line of lines) {
+      const descMatch = line.match(/@description\s+(.+)/);
+      descMatch && descMatch[1] && (metadata.description = descMatch[1].trim());
+      const argsMatch = line.match(/@args\s+(.+)/);
+      argsMatch && argsMatch[1] && (metadata.args = argsMatch[1].split(",").map(a => a.trim()));
+    }
+    const stat = (0, import_node_fs.statSync)(filePath);
+    return metadata.mtime = stat.mtimeMs, metadata;
+  } catch {
+    return {};
+  }
+}
+function loadCache() {
+  try {
+    if ((0, import_node_fs.existsSync)(CACHE_FILE)) return JSON.parse((0, import_node_fs.readFileSync)(CACHE_FILE, "utf-8"));
+  } catch {}
+  return {};
+}
+function saveCache(cache) {
+  try {
+    (0, import_node_fs.existsSync)(CACHE_DIR) || (0, import_node_fs.mkdirSync)(CACHE_DIR, {
+      recursive: !0
+    }), (0, import_node_fs.writeFileSync)(CACHE_FILE, JSON.stringify(cache, null, 2));
+  } catch {}
+}
+function getScriptMetadata(filePath) {
+  const cache = loadCache(),
+    stat = (0, import_node_fs.statSync)(filePath);
+  if (cache[filePath] && cache[filePath].mtime === stat.mtimeMs) return cache[filePath];
+  const metadata = extractMetadata(filePath);
+  return cache[filePath] = metadata, saveCache(cache), metadata;
+}
+function discoverScripts(dir, baseDir = dir, depth = 0, maxDepth = 1) {
+  const scripts = /* @__PURE__ */new Map();
+  if (!(0, import_node_fs.existsSync)(dir)) return scripts;
+  try {
+    const entries = (0, import_node_fs.readdirSync)(dir);
+    for (const entry of entries) {
+      const fullPath = (0, import_node_path.join)(dir, entry);
+      if ((0, import_node_fs.statSync)(fullPath).isDirectory()) {
+        if (entry === "helpers" || depth >= maxDepth) continue;
+        const subScripts = discoverScripts(fullPath, baseDir, depth + 1, maxDepth);
+        for (const [name, path] of subScripts) scripts.set(name, path);
+      } else if (entry.endsWith(".ts") || entry.endsWith(".js")) {
+        const scriptName = (0, import_node_path.relative)(baseDir, fullPath).split("\\").join("/").replace(/\.(ts|js)$/, "");
+        scripts.set(scriptName, fullPath);
+      }
+    }
+  } catch {}
+  return scripts;
+}
+function findScript(name) {
+  const normalizedName = name.replace(/:/g, "/"),
+    localDir = getLocalScriptsDir();
+  for (const ext of [".ts", ".js", ""]) {
+    const localPath = (0, import_node_path.join)(localDir, `${normalizedName}${ext}`);
+    if ((0, import_node_fs.existsSync)(localPath)) return localPath;
+  }
+  const builtInDir = findScriptsPackageRoot();
+  if (builtInDir) for (const ext of [".ts", ".js", ""]) {
+    const builtInPath = (0, import_node_path.join)(builtInDir, `${normalizedName}${ext}`);
+    if ((0, import_node_fs.existsSync)(builtInPath)) return builtInPath;
+  }
+  return null;
+}
+async function runScript(scriptPath, args) {
+  console.info(import_picocolors.default.dim(`Running: ${(0, import_node_path.relative)(process.cwd(), scriptPath)}`)), console.info();
+  try {
+    const {
+      $
+    } = await import("bun");
+    await $`bun ${scriptPath} ${args}`;
+  } catch (err) {
+    console.error(import_picocolors.default.red(`\u2717 Error running script: ${err}`)), process.exit(1);
+  }
+}
+const newCommand = (0, import_citty.defineCommand)({
+  meta: {
+    name: "new",
+    description: "Create a new script from template"
+  },
+  args: {
+    path: {
+      type: "positional",
+      description: "Path for the new script (e.g., ci/test)",
+      required: !0
+    }
+  },
+  async run({
+    args
+  }) {
+    const scriptPath = args.path,
+      localDir = getLocalScriptsDir(),
+      fullPath = (0, import_node_path.join)(localDir, `${scriptPath}.ts`),
+      dir = (0, import_node_path.dirname)(fullPath);
+    (0, import_node_fs.existsSync)(dir) || (0, import_node_fs.mkdirSync)(dir, {
+      recursive: !0
+    }), (0, import_node_fs.existsSync)(fullPath) && (console.error(import_picocolors.default.red(`\u2717 Script already exists: ${(0, import_node_path.relative)(process.cwd(), fullPath)}`)), process.exit(1));
+    const template = `#!/usr/bin/env bun
+
+/**
+ * @description TODO: Add description
+ * @args --verbose, --dry-run
+ */
+
+import { parseArgs } from 'node:util'
+
+const { values } = parseArgs({
+  args: process.argv.slice(2),
+  options: {
+    verbose: {
+      type: 'boolean',
+      short: 'v',
+    },
+    'dry-run': {
+      type: 'boolean',
+    },
+  },
+})
+
+async function main() {
+  console.info('Running ${(0, import_node_path.basename)(scriptPath)}...')
+
+  if (values.verbose) {
+    console.info('Verbose mode enabled')
+  }
+
+  if (values['dry-run']) {
+    console.info('Dry run mode - no changes will be made')
+  }
+
+  // TODO: Implement your script logic here
+}
+
+main().catch(console.error)
+`;
+    (0, import_node_fs.writeFileSync)(fullPath, template), console.info(import_picocolors.default.green(`\u2713 Created new script: ${(0, import_node_path.relative)(process.cwd(), fullPath)}`)), console.info(), console.info(import_picocolors.default.dim("Edit the script and update the TODO sections"));
+  }
+});
+function getAllScriptFiles(dir, baseDir = dir) {
+  const files = [];
+  if (!(0, import_node_fs.existsSync)(dir)) return files;
+  try {
+    const entries = (0, import_node_fs.readdirSync)(dir);
+    for (const entry of entries) {
+      const fullPath = (0, import_node_path.join)(dir, entry);
+      (0, import_node_fs.statSync)(fullPath).isDirectory() ? files.push(...getAllScriptFiles(fullPath, baseDir)) : (entry.endsWith(".ts") || entry.endsWith(".js") || entry.endsWith(".cjs")) && files.push((0, import_node_path.relative)(baseDir, fullPath).split("\\").join("/"));
+    }
+  } catch {}
+  return files;
+}
+const ejectCommand = (0, import_citty.defineCommand)({
+    meta: {
+      name: "eject",
+      description: "Eject built-in scripts into your project"
+    },
+    args: {
+      yes: {
+        type: "boolean",
+        description: "Skip confirmations and eject all files",
+        default: !1
+      }
+    },
+    async run({
+      args
+    }) {
+      const cwd = process.cwd(),
+        targetScriptsDir = (0, import_node_path.join)(cwd, "scripts"),
+        sourceScriptsDir = findScriptsPackageRoot();
+      console.info(), console.info(import_picocolors.default.bold(import_picocolors.default.cyan("\u2699\uFE0F  Eject Scripts"))), console.info(), sourceScriptsDir || (console.error(import_picocolors.default.red("\u2717 Built-in scripts package (@take-out/scripts) not found or not installed")), console.info(), console.info(import_picocolors.default.dim("Install with: bun add -d @take-out/scripts")), process.exit(1)), console.info(import_picocolors.default.dim(`Source: ${sourceScriptsDir}`)), console.info(import_picocolors.default.dim(`Target: ${targetScriptsDir}`)), console.info(), (0, import_node_fs.existsSync)(targetScriptsDir) || (console.info(import_picocolors.default.yellow("\u26A0 Target scripts directory does not exist, will create it")), (0, import_node_fs.mkdirSync)(targetScriptsDir, {
+        recursive: !0
+      }));
+      const sourceFiles = getAllScriptFiles(sourceScriptsDir);
+      if (sourceFiles.length === 0) {
+        console.info(import_picocolors.default.yellow("No script files found in built-in scripts package"));
+        return;
+      }
+      const filesToSync = [],
+        stats = {
+          new: 0,
+          modified: 0,
+          identical: 0
+        };
+      for (const file of sourceFiles) {
+        const sourcePath = (0, import_node_path.join)(sourceScriptsDir, file),
+          targetPath = (0, import_node_path.join)(targetScriptsDir, file),
+          status = (0, import_sync.compareFiles)(sourcePath, targetPath);
+        stats[status]++, filesToSync.push({
+          name: file,
+          sourcePath,
+          targetPath,
+          status,
+          sourceSize: (0, import_sync.getFileSize)(sourcePath),
+          targetSize: (0, import_sync.getFileSize)(targetPath)
+        });
+      }
+      if (console.info(import_picocolors.default.bold("Summary:")), console.info(`  ${import_picocolors.default.green(`${stats.new} new`)}`), console.info(`  ${import_picocolors.default.yellow(`${stats.modified} modified`)}`), console.info(`  ${import_picocolors.default.dim(`${stats.identical} identical`)}`), console.info(), stats.new === 0 && stats.modified === 0) {
+        console.info(import_picocolors.default.green("\u2713 All scripts are already up to date!"));
+        return;
+      }
+      const sortOrder = {
+        new: 0,
+        modified: 1,
+        identical: 2
+      };
+      filesToSync.sort((a, b) => sortOrder[a.status] - sortOrder[b.status]);
+      let syncedCount = 0;
+      for (const file of filesToSync) if (args.yes && file.status !== "identical") {
+        const targetDir = (0, import_node_path.dirname)(file.targetPath);
+        (0, import_node_fs.existsSync)(targetDir) || (0, import_node_fs.mkdirSync)(targetDir, {
+          recursive: !0
+        });
+        const content = (0, import_node_fs.readFileSync)(file.sourcePath);
+        (0, import_node_fs.writeFileSync)(file.targetPath, content), console.info(import_picocolors.default.green(`  \u2713 ${file.name}`)), syncedCount++;
+      } else (await (0, import_sync.syncFileWithConfirmation)(file)) && syncedCount++;
+      console.info(), console.info(import_picocolors.default.bold(import_picocolors.default.green(`\u2713 Complete: ${syncedCount} file(s) ejected`))), console.info();
+    }
+  }),
+  runSubCommand = (0, import_citty.defineCommand)({
+    meta: {
+      name: "run",
+      description: "Run a script (for backwards compatibility)"
+    },
+    args: {
+      name: {
+        type: "positional",
+        description: "Script name",
+        required: !0
+      }
+    },
+    async run({
+      args,
+      rawArgs
+    }) {
+      const scriptPath = findScript(args.name);
+      scriptPath || (console.error(import_picocolors.default.red(`\u2717 Script not found: ${args.name}`)), console.info(), console.info(import_picocolors.default.dim("Run 'tko script' to see available scripts")), process.exit(1));
+      const scriptArgs = rawArgs.slice(rawArgs.indexOf(args.name) + 1);
+      await runScript(scriptPath, scriptArgs);
+    }
+  }),
+  scriptCommand = (0, import_citty.defineCommand)({
+    meta: {
+      name: "script",
+      description: "Hybrid script runner with filesystem discovery"
+    },
+    args: {
+      name: {
+        type: "positional",
+        description: "Script name or category to run/list",
+        required: !1
+      }
+    },
+    subCommands: {
+      new: newCommand,
+      run: runSubCommand,
+      eject: ejectCommand
+    },
+    async run({
+      args,
+      rawArgs
+    }) {
+      const scriptName = args.name || rawArgs[1];
+      if (!scriptName) {
+        (0, import_script_listing.listAllScripts)(!1);
+        return;
+      }
+      if ((0, import_script_listing.listCategoryScripts)(scriptName)) return;
+      const scriptPath = findScript(scriptName);
+      scriptPath || (console.error(import_picocolors.default.red(`\u2717 Script not found: ${scriptName}`)), console.info(), console.info(import_picocolors.default.dim("Run 'tko script' to see available scripts")), process.exit(1));
+      const scriptArgs = rawArgs.slice(rawArgs.indexOf(scriptName) + 1);
+      await runScript(scriptPath, scriptArgs);
+    }
+  });
+function createShorthandCommand(name) {
+  return (0, import_citty.defineCommand)({
+    meta: {
+      name,
+      description: "Run script directly"
+    },
+    args: {
+      args: {
+        type: "positional",
+        description: "Script and arguments",
+        required: !1
+      }
+    },
+    async run({
+      rawArgs
+    }) {
+      const scriptName = rawArgs.length > 0 ? `${name}/${rawArgs[0]}` : name,
+        scriptArgs = rawArgs.length > 0 ? ["script", scriptName, ...rawArgs.slice(1)] : ["script", name],
+        {
+          run
+        } = scriptCommand;
+      run && (await run({
+        args: {
+          name: scriptName,
+          _: rawArgs.slice(1)
+        },
+        rawArgs: scriptArgs,
+        cmd: scriptCommand
+      }));
+    }
+  });
+}