pan-stack-cli 0.1.0

package/lib/manifest.js

@@ -0,0 +1,312 @@
+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 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(`Target hợp lệ cho '${commandName}': ${valid}`);
+    }
+    return {
+      ...target,
+      targetName,
+      description: def.description,
+    };
+  }
+
+  return def;
+}
+
+function listCommands(source) {
+  return Object.entries(source.commands || {}).map(([name, def]) => ({
+    name,
+    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,
+  getCommandDefinition,
+  listCommands,
+  commandBaseDir,
+};

package/lib/run-command.js

@@ -0,0 +1,196 @@
+const fs = require("fs");
+const path = require("path");
+const { spawn, spawnSync } = require("child_process");
+const readline = require("readline");
+const { getCommandDefinition, commandBaseDir } = require("./manifest");
+const { sourceMatchesProject } = require("./discover");
+
+function needDir(dir) {
+  if (!fs.existsSync(dir)) {
+    throw new Error(`Chưa có thư mục: ${dir} (chạy 'pan clone' trước?)`);
+  }
+}
+
+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 thiếu 'exec' hoặc 'shell'.");
+  }
+
+  const result = spawnSync(execLine, {
+    cwd,
+    shell: true,
+    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);
+  }
+
+  const result = spawnSync(def.shell, {
+    cwd,
+    shell: true,
+    stdio: "inherit",
+    env: buildPanEnv(source, forwardedArgs),
+  });
+
+  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(`Không tìm thấy lệnh '${commandName}' trong ${source.path}`);
+  }
+
+  if (resolved.shell) {
+    runShell(source, resolved, forwardedArgs);
+    return;
+  }
+
+  if (resolved.exec) {
+    runExec(source, resolved, forwardedArgs);
+    return;
+  }
+
+  throw new Error(`Lệnh '${commandName}' thiếu 'exec' hoặc 'shell' trong ${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("Chọn dự án (số): ", (answer) => {
+      rl.close();
+      const choice = Number.parseInt(answer, 10);
+      if (!Number.isFinite(choice) || choice < 1 || choice > matches.length) {
+        reject(new Error("Lựa chọn không hợp lệ."));
+        return;
+      }
+      resolve(matches[choice - 1]);
+    });
+  });
+}
+
+async function runWithProjectResolution(matches, commandName, args, projectFlag) {
+  if (matches.length === 0) {
+    throw new Error(
+      `Không tìm thấy lệnh '${commandName}' trong bất kỳ .pan.yaml nào.`
+    );
+  }
+
+  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(`Không tìm thấy dự án '${projectFlag}'. Có: ${names}`);
+    }
+  } else if (matches.length === 1) {
+    source = matches[0];
+  } else {
+    const withTargetArg = matches.filter((item) => {
+      const def = item.commands[commandName];
+      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(
+        `Lệnh '${commandName}' trùng ở nhiều dự án. Dùng --project <tên>.\n${lines.join("\n")}`
+      );
+    }
+  }
+
+  runProjectCommand(source, commandName, args);
+}
+
+function runGitScript(scriptName, args) {
+  const scriptPath = path.join(__dirname, "git", scriptName);
+  if (!fs.existsSync(scriptPath)) {
+    throw new Error(`Không tìm thấy script: ${scriptPath}`);
+  }
+
+  const child = spawn(process.execPath, [scriptPath, ...args], {
+    stdio: "inherit",
+    env: process.env,
+  });
+
+  child.on("exit", (code) => {
+    process.exit(code ?? 1);
+  });
+}
+
+module.exports = {
+  runProjectCommand,
+  runWithProjectResolution,
+  runGitScript,
+  sourceLabel,
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "pan-stack-cli",
+  "version": "0.1.0",
+  "description": "CLI điều phối PAN Stack — git đa repo và lệnh dự án từ .project.yaml",
+  "license": "MIT",
+  "bin": {
+    "pan": "bin/pan.js"
+  },
+  "files": [
+    "bin",
+    "lib"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "pan-stack",
+    "monorepo",
+    "git",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/doiya46/pan-stack.git",
+    "directory": ".pan/pan-stack-cli"
+  }
+}