pan-stack-cli 0.1.5 → 0.2.2

package/lib/manifest.js

@@ -1,366 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-
-const PLACEHOLDER_VALUES = new Set(["", "repo_url_to_be_filled", "pan_stack_repo_url"]);
-
-function cleanValue(value) {
-  let result = String(value || "").trim();
-  const commentIndex = result.indexOf(" #");
-  if (commentIndex >= 0) {
-    result = result.slice(0, commentIndex).trimEnd();
-  }
-  if (
-    (result.startsWith('"') && result.endsWith('"')) ||
-    (result.startsWith("'") && result.endsWith("'"))
-  ) {
-    result = result.slice(1, -1);
-  }
-  return result;
-}
-
-function splitKeyValue(text) {
-  const index = text.indexOf(":");
-  if (index < 0) {
-    return [text.trim(), ""];
-  }
-  return [text.slice(0, index).trim(), cleanValue(text.slice(index + 1))];
-}
-
-function parseManifest(manifestPath) {
-  const data = { repositories: [], stack: {}, commands: {} };
-  let section = "";
-  let currentRepo = null;
-  let currentCommandName = "";
-  let currentCommand = null;
-  let currentTargetName = "";
-  let blockMode = null;
-  let blockIndent = 0;
-  let blockLines = [];
-
-  function flushBlock() {
-    if (!blockMode || !currentCommand) {
-      blockMode = null;
-      blockLines = [];
-      return;
-    }
-    const body = blockLines.join("\n");
-    if (blockMode === "command-shell") {
-      currentCommand.shell = body;
-    } else if (blockMode === "target-shell" && currentCommand.targets[currentTargetName]) {
-      currentCommand.targets[currentTargetName].shell = body;
-    }
-    blockMode = null;
-    blockLines = [];
-  }
-
-  const lines = fs.readFileSync(manifestPath, "utf8").split(/\r?\n/);
-  for (const rawLine of lines) {
-    if (blockMode) {
-      const trimmed = rawLine.trimEnd();
-      if (!trimmed.trim()) {
-        blockLines.push("");
-        continue;
-      }
-      const indent = rawLine.length - rawLine.trimStart().length;
-      if (indent < blockIndent) {
-        flushBlock();
-      } else {
-        blockLines.push(rawLine.slice(blockIndent));
-        continue;
-      }
-    }
-
-    if (!rawLine.trim() || rawLine.trimStart().startsWith("#")) {
-      continue;
-    }
-
-    const indent = rawLine.length - rawLine.trimStart().length;
-    const text = rawLine.trim();
-
-    if (indent === 0) {
-      flushBlock();
-      const [key, value] = splitKeyValue(text);
-      section = key;
-      currentRepo = null;
-      currentCommandName = "";
-      currentCommand = null;
-      currentTargetName = "";
-      if (value) {
-        data[key] = value;
-      } else if (!(key in data)) {
-        data[key] = key === "commands" ? {} : {};
-      }
-      continue;
-    }
-
-    if (section === "stack" && indent === 2) {
-      const [key, value] = splitKeyValue(text);
-      data.stack[key] = value;
-      continue;
-    }
-
-    if (section === "repositories") {
-      if (indent === 2 && text.startsWith("- ")) {
-        currentRepo = {};
-        data.repositories.push(currentRepo);
-        const rest = text.slice(2).trim();
-        if (rest) {
-          const [key, value] = splitKeyValue(rest);
-          currentRepo[key] = value;
-        }
-        continue;
-      }
-      if (currentRepo && indent === 4) {
-        const [key, value] = splitKeyValue(text);
-        currentRepo[key] = value;
-      }
-      continue;
-    }
-
-    if (section === "commands") {
-      if (indent === 2) {
-        flushBlock();
-        const [key, value] = splitKeyValue(text);
-        currentCommandName = key;
-        currentCommand = {};
-        currentTargetName = "";
-        data.commands[currentCommandName] = currentCommand;
-        if (value) {
-          currentCommand[key] = value;
-        }
-        continue;
-      }
-
-      if (indent === 4 && currentCommand) {
-        flushBlock();
-        const [key, value] = splitKeyValue(text);
-        if (key === "shell" && (value === "|" || value === ">")) {
-          blockMode = "command-shell";
-          blockIndent = indent + 2;
-          blockLines = [];
-          continue;
-        }
-        if (key === "targets") {
-          currentCommand.targets = currentCommand.targets || {};
-          continue;
-        }
-        currentCommand[key] = value;
-        continue;
-      }
-
-      if (indent === 6 && currentCommand) {
-        flushBlock();
-        const [key, value] = splitKeyValue(text);
-        currentTargetName = key;
-        currentCommand.targets = currentCommand.targets || {};
-        const target = {};
-        currentCommand.targets[currentTargetName] = target;
-        if (value) {
-          target[key] = value;
-        }
-        if (key === "shell" && (value === "|" || value === ">")) {
-          blockMode = "target-shell";
-          blockIndent = indent + 2;
-          blockLines = [];
-        }
-        continue;
-      }
-
-      if (indent === 8 && currentCommand && currentCommand.targets && currentTargetName) {
-        flushBlock();
-        const target = currentCommand.targets[currentTargetName];
-        const [key, value] = splitKeyValue(text);
-        if (key === "shell" && (value === "|" || value === ">")) {
-          blockMode = "target-shell";
-          blockIndent = indent + 2;
-          blockLines = [];
-          continue;
-        }
-        target[key] = value;
-      }
-    }
-  }
-
-  flushBlock();
-  return data;
-}
-
-function uniqueRepos(repos) {
-  const seen = new Set();
-  const result = [];
-  for (const repo of repos) {
-    const key = [
-      cleanValue(repo.name),
-      cleanValue(repo.url),
-      cleanValue(repo.path),
-    ].join("\u0000");
-    if (seen.has(key)) {
-      continue;
-    }
-    seen.add(key);
-    result.push(repo);
-  }
-  return result;
-}
-
-function manifestRepos(data) {
-  return uniqueRepos(data.repositories || []);
-}
-
-function validateRepo(repo) {
-  const name = cleanValue(repo.name);
-  const url = cleanValue(repo.url);
-  const repoPath = cleanValue(repo.path) || name;
-
-  if (!name) {
-    throw new Error("Repository entry is missing 'name'.");
-  }
-  if (PLACEHOLDER_VALUES.has(url)) {
-    throw new Error(`Repository '${name}' is missing a real url.`);
-  }
-  if (!repoPath) {
-    throw new Error(`Repository '${name}' is missing 'path'.`);
-  }
-  return { name, url, repoPath };
-}
-
-function loadManifest(manifestPath) {
-  const resolved = path.resolve(manifestPath);
-  if (!fs.existsSync(resolved)) {
-    throw new Error(`Manifest not found: ${manifestPath}`);
-  }
-  const data = parseManifest(resolved);
-  return {
-    path: resolved,
-    root: path.dirname(resolved),
-    project: cleanValue(data.project) || path.basename(path.dirname(resolved)),
-    managedBy: cleanValue(data.managed_by),
-    stack: data.stack || {},
-    repositories: manifestRepos(data),
-    commands: data.commands || {},
-  };
-}
-
-const PAN_CONFIG_FILE = ".pan.yaml";
-
-function loadPanConfig(configPath, meta = {}) {
-  const resolved = path.resolve(configPath);
-  if (!fs.existsSync(resolved)) {
-    throw new Error(`Config not found: ${configPath}`);
-  }
-  const data = parseManifest(resolved);
-  const root = path.dirname(resolved);
-  return {
-    path: resolved,
-    root,
-    workspaceRoot: meta.workspaceRoot || root,
-    project: cleanValue(data.project) || meta.project || path.basename(root),
-    repoName: meta.repoName || "",
-    scope: meta.scope || "repo",
-    commands: data.commands || {},
-  };
-}
-
-function commandAliases(def) {
-  if (!def) {
-    return [];
-  }
-  const result = [];
-  if (def.alias) {
-    result.push(cleanValue(def.alias));
-  }
-  if (def.aliases) {
-    const raw = def.aliases;
-    if (Array.isArray(raw)) {
-      result.push(...raw.map((item) => cleanValue(item)));
-    } else {
-      const value = cleanValue(raw);
-      if (value.startsWith("[") && value.endsWith("]")) {
-        result.push(
-          ...value
-            .slice(1, -1)
-            .split(",")
-            .map((item) => cleanValue(item))
-            .filter(Boolean)
-        );
-      } else if (value.includes(",")) {
-        result.push(
-          ...value
-            .split(",")
-            .map((item) => cleanValue(item))
-            .filter(Boolean)
-        );
-      } else if (value) {
-        result.push(value);
-      }
-    }
-  }
-  return [...new Set(result.filter(Boolean))];
-}
-
-function resolveCommandName(sources, commandName) {
-  if (sources.some((source) => source.commands[commandName])) {
-    return commandName;
-  }
-  for (const source of sources) {
-    for (const [primaryName, def] of Object.entries(source.commands || {})) {
-      if (commandAliases(def).includes(commandName)) {
-        return primaryName;
-      }
-    }
-  }
-  return commandName;
-}
-
-function getCommandDefinition(source, commandName, subArg) {
-  const def = source.commands[commandName];
-  if (!def) {
-    return null;
-  }
-
-  if (def.targets && typeof def.targets === "object") {
-    const targetName = subArg || def.default || Object.keys(def.targets)[0];
-    const target = def.targets[targetName];
-    if (!target) {
-      const valid = Object.keys(def.targets).join(" | ");
-      throw new Error(`Valid targets for '${commandName}': ${valid}`);
-    }
-    return {
-      ...target,
-      targetName,
-      description: def.description,
-    };
-  }
-
-  return def;
-}
-
-function listCommands(source) {
-  return Object.entries(source.commands || {}).map(([name, def]) => ({
-    name,
-    aliases: commandAliases(def),
-    description: def.description || "",
-    hasTargets: Boolean(def.targets),
-    targets: def.targets ? Object.keys(def.targets) : [],
-  }));
-}
-
-function commandBaseDir(source) {
-  return source.scope === "workspace" ? source.workspaceRoot : source.root;
-}
-
-module.exports = {
-  PLACEHOLDER_VALUES,
-  PAN_CONFIG_FILE,
-  cleanValue,
-  parseManifest,
-  loadManifest,
-  loadPanConfig,
-  manifestRepos,
-  validateRepo,
-  commandAliases,
-  resolveCommandName,
-  getCommandDefinition,
-  listCommands,
-  commandBaseDir,
-};

package/lib/platform.js

@@ -1,140 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const { spawnSync } = require("child_process");
-
-const WINDOWS_RESERVED_NAMES = new Set([
-  "CON",
-  "PRN",
-  "AUX",
-  "NUL",
-  "COM1",
-  "COM2",
-  "COM3",
-  "COM4",
-  "COM5",
-  "COM6",
-  "COM7",
-  "COM8",
-  "COM9",
-  "LPT1",
-  "LPT2",
-  "LPT3",
-  "LPT4",
-  "LPT5",
-  "LPT6",
-  "LPT7",
-  "LPT8",
-  "LPT9",
-]);
-
-function isWindows() {
-  return process.platform === "win32";
-}
-
-function splitEnvList(value) {
-  if (!value) {
-    return [];
-  }
-  // On Windows, do not split on ":" — drive letters use "C:".
-  const parts = isWindows() ? value.split(/[;,]/) : value.split(/[:;,]/);
-  return parts.map((part) => part.trim()).filter(Boolean);
-}
-
-function findBash() {
-  const candidates = isWindows()
-    ? [
-        process.env.PAN_GIT_BASH,
-        process.env.PAN_BASH,
-        process.env.GIT_BASH,
-        process.env.PROGRAMFILES && path.join(process.env.PROGRAMFILES, "Git", "bin", "bash.exe"),
-        process.env["ProgramFiles(x86)"] &&
-          path.join(process.env["ProgramFiles(x86)"], "Git", "bin", "bash.exe"),
-        process.env.LOCALAPPDATA &&
-          path.join(process.env.LOCALAPPDATA, "Programs", "Git", "bin", "bash.exe"),
-      ]
-    : [process.env.PAN_BASH, process.env.BASH, "/usr/bin/bash", "/bin/bash"];
-
-  for (const candidate of candidates.filter(Boolean)) {
-    if (fs.existsSync(candidate)) {
-      return candidate;
-    }
-  }
-
-  return null;
-}
-
-/** @deprecated use findBash */
-function findGitBash() {
-  return findBash();
-}
-
-function spawnOptions(extra = {}) {
-  return isWindows() ? { windowsHide: true, ...extra } : extra;
-}
-
-function normalizeShellEnv(env) {
-  if (!isWindows()) {
-    return env;
-  }
-
-  const normalized = { ...env };
-  for (const key of ["PAN_WORKSPACE_ROOT", "PAN_REPO_ROOT", "PAN_PROJECT_ROOT"]) {
-    if (typeof normalized[key] === "string") {
-      normalized[key] = normalized[key].replace(/\\/g, "/");
-    }
-  }
-  return normalized;
-}
-
-function runShellScript(script, { cwd, env, stdio = "inherit" } = {}) {
-  const shellEnv = normalizeShellEnv(env);
-  const bash = findBash();
-
-  if (!bash) {
-    const hint = isWindows()
-      ? "Install Git for Windows (https://git-scm.com/download/win) or set PAN_GIT_BASH / PAN_BASH to bash.exe."
-      : "Install bash or set PAN_BASH to its path.";
-    throw new Error(
-      `Shell commands in .pan.yaml require bash. ${hint} Alternatively, use 'exec' instead of 'shell'.`
-    );
-  }
-
-  return spawnSync(bash, ["-lc", script], spawnOptions({ cwd, env: shellEnv, stdio }));
-}
-
-function runExecLine(execLine, { cwd, env, stdio = "inherit" } = {}) {
-  return spawnSync(
-    execLine,
-    spawnOptions({ cwd, env: normalizeShellEnv(env), stdio, shell: true })
-  );
-}
-
-function validateFolderName(name) {
-  if (!name || !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name)) {
-    throw new Error(
-      "Invalid folder name. Use letters, numbers, dots, hyphens, or underscores."
-    );
-  }
-
-  if (isWindows()) {
-    if (/[<>:"/\\|?*]/.test(name)) {
-      throw new Error("Invalid folder name for Windows (<>:\"/\\|?* are not allowed).");
-    }
-    const base = name.replace(/\.+$/, "").toUpperCase();
-    if (WINDOWS_RESERVED_NAMES.has(base)) {
-      throw new Error(`Invalid folder name for Windows (reserved name: ${base}).`);
-    }
-  }
-}
-
-module.exports = {
-  isWindows,
-  splitEnvList,
-  findBash,
-  findGitBash,
-  spawnOptions,
-  normalizeShellEnv,
-  runShellScript,
-  runExecLine,
-  validateFolderName,
-};

package/lib/run-command.js

@@ -1,213 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const { spawn, spawnSync } = require("child_process");
-const readline = require("readline");
-const {
-  getCommandDefinition,
-  commandBaseDir,
-  resolveCommandName,
-} = require("./manifest");
-const { sourceMatchesProject } = require("./discover");
-const { runShellScript, runExecLine, spawnOptions } = require("./platform");
-
-function needDir(dir) {
-  if (!fs.existsSync(dir)) {
-    throw new Error(`Directory not found: ${dir} (run 'pan clone' first?)`);
-  }
-}
-
-function resolveCwd(source, cwd) {
-  const base = commandBaseDir(source);
-  if (!cwd) {
-    return base;
-  }
-  if (path.isAbsolute(cwd)) {
-    return cwd;
-  }
-  return path.resolve(base, cwd);
-}
-
-function buildPanEnv(source, forwardedArgs) {
-  const panEnv = {
-    ...process.env,
-    PAN_REPO_ROOT: source.root,
-    PAN_WORKSPACE_ROOT: source.workspaceRoot,
-    PAN_PROJECT_ROOT: source.workspaceRoot,
-    PAN_ARGS: forwardedArgs.join(" "),
-  };
-  forwardedArgs.forEach((value, index) => {
-    panEnv[`PAN_ARG_${index + 1}`] = value;
-  });
-  return panEnv;
-}
-
-function runExec(source, def, forwardedArgs) {
-  const cwd = resolveCwd(source, def.cwd);
-  needDir(cwd);
-
-  const execLine = [def.exec, ...forwardedArgs].filter(Boolean).join(" ").trim();
-  if (!execLine) {
-    throw new Error("Command is missing 'exec' or 'shell'.");
-  }
-
-  const result = runExecLine(execLine, {
-    cwd,
-    stdio: "inherit",
-    env: buildPanEnv(source, forwardedArgs),
-  });
-
-  process.exit(result.status ?? 1);
-}
-
-function runShell(source, def, forwardedArgs) {
-  const cwd = resolveCwd(source, def.cwd || ".");
-  if (def.cwd) {
-    needDir(cwd);
-  }
-
-  let result;
-  try {
-    result = runShellScript(def.shell, {
-      cwd,
-      stdio: "inherit",
-      env: buildPanEnv(source, forwardedArgs),
-    });
-  } catch (error) {
-    console.error(error.message);
-    process.exit(1);
-  }
-
-  process.exit(result.status ?? 1);
-}
-
-function runProjectCommand(source, commandName, args) {
-  let subArg = "";
-  let forwardedArgs = [...args];
-
-  const def = source.commands[commandName];
-  if (def?.targets) {
-    if (forwardedArgs.length > 0 && def.targets[forwardedArgs[0]]) {
-      subArg = forwardedArgs.shift();
-    }
-  }
-
-  const resolved = getCommandDefinition(source, commandName, subArg);
-  if (!resolved) {
-    throw new Error(`Command '${commandName}' not found in ${source.path}`);
-  }
-
-  if (resolved.shell) {
-    runShell(source, resolved, forwardedArgs);
-    return;
-  }
-
-  if (resolved.exec) {
-    runExec(source, resolved, forwardedArgs);
-    return;
-  }
-
-  throw new Error(`Command '${commandName}' is missing 'exec' or 'shell' in ${source.path}`);
-}
-
-function sourceLabel(source) {
-  if (source.scope === "workspace") {
-    return `${source.project} (workspace)`;
-  }
-  return source.repoName || source.project;
-}
-
-function promptProjectChoice(matches, commandName) {
-  return new Promise((resolve, reject) => {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-
-    console.log("");
-    matches.forEach((source, index) => {
-      const def = source.commands[commandName];
-      const desc = def?.description ? ` — ${def.description}` : "";
-      console.log(`  ${index + 1}. ${sourceLabel(source)} (${source.root})${desc}`);
-    });
-    console.log("");
-
-    rl.question("Pick a project (number): ", (answer) => {
-      rl.close();
-      const choice = Number.parseInt(answer, 10);
-      if (!Number.isFinite(choice) || choice < 1 || choice > matches.length) {
-        reject(new Error("Invalid choice."));
-        return;
-      }
-      resolve(matches[choice - 1]);
-    });
-  });
-}
-
-async function runWithProjectResolution(
-  matches,
-  commandName,
-  args,
-  projectFlag,
-  allSources = matches
-) {
-  const resolvedName = resolveCommandName(allSources, commandName);
-
-  if (matches.length === 0) {
-    throw new Error(
-      `Command '${commandName}' not found in any .pan.yaml file.`
-    );
-  }
-
-  let source = null;
-  if (projectFlag) {
-    source = matches.find((item) => sourceMatchesProject(item, projectFlag));
-    if (!source) {
-      const names = matches.map((item) => sourceLabel(item)).join(", ");
-      throw new Error(`Project '${projectFlag}' not found. Available: ${names}`);
-    }
-  } else if (matches.length === 1) {
-    source = matches[0];
-  } else {
-    const withTargetArg = matches.filter((item) => {
-      const def = item.commands[resolvedName];
-      return def?.targets && args[0] && def.targets[args[0]];
-    });
-    if (withTargetArg.length === 1) {
-      source = withTargetArg[0];
-    } else if (process.stdin.isTTY) {
-      source = await promptProjectChoice(matches, commandName);
-    } else {
-      const lines = matches.map(
-        (item, index) => `${index + 1}. ${sourceLabel(item)} (${item.root})`
-      );
-      throw new Error(
-        `Command '${commandName}' is defined in multiple projects. Use --project <name>.\n${lines.join("\n")}`
-      );
-    }
-  }
-
-  runProjectCommand(source, resolvedName, args);
-}
-
-function runGitScript(scriptName, args) {
-  const scriptPath = path.join(__dirname, "git", scriptName);
-  if (!fs.existsSync(scriptPath)) {
-    throw new Error(`Script not found: ${scriptPath}`);
-  }
-
-  const child = spawn(process.execPath, [scriptPath, ...args], spawnOptions({
-    stdio: "inherit",
-    env: process.env,
-  }));
-
-  child.on("exit", (code) => {
-    process.exit(code ?? 1);
-  });
-}
-
-module.exports = {
-  runProjectCommand,
-  runWithProjectResolution,
-  runGitScript,
-  sourceLabel,
-};