@precisa-saude/cli 1.0.1

package/dist/index.js

@@ -0,0 +1,630 @@
+// src/commands/doctor.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve4 } from "path";
+import chalk from "chalk";
+
+// src/lib/templates.ts
+import { readFileSync } from "fs";
+import { resolve as resolve2 } from "path";
+import { parse as parseYaml } from "yaml";
+
+// src/lib/paths.ts
+import { existsSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+function resolveTemplatesDir() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const bundled = resolve(here, "templates");
+  if (existsSync(bundled)) return bundled;
+  const repoRoot = resolve(here, "..", "..", "..", "..");
+  const repoTemplates = resolve(repoRoot, "templates");
+  if (existsSync(repoTemplates)) return repoTemplates;
+  const packageParent = resolve(here, "..", "..", "templates");
+  if (existsSync(packageParent)) return packageParent;
+  throw new Error(
+    `Could not locate templates/ directory. Searched:
+  ${bundled}
+  ${repoTemplates}
+  ${packageParent}`
+  );
+}
+
+// src/lib/templates.ts
+function loadTemplateManifest() {
+  const dir = resolveTemplatesDir();
+  const manifestPath = resolve2(dir, "templates.manifest.yml");
+  const raw = readFileSync(manifestPath, "utf-8");
+  const parsed = parseYaml(raw);
+  if (!parsed || !Array.isArray(parsed.templates)) {
+    throw new Error(`${manifestPath}: expected { templates: [...] } at root`);
+  }
+  for (const [i, t] of parsed.templates.entries()) {
+    if (!t.source || !t.target) {
+      throw new Error(`${manifestPath}: entry ${i} is missing source or target`);
+    }
+  }
+  return parsed.templates;
+}
+function readTemplateSource(entry) {
+  const dir = resolveTemplatesDir();
+  const path = resolve2(dir, entry.source);
+  return readFileSync(path, "utf-8");
+}
+function renderTokens(source, context) {
+  return source.replace(/\{\{([A-Z_]+)\}\}/g, (match, token) => {
+    return Object.prototype.hasOwnProperty.call(context, token) ? context[token] : match;
+  });
+}
+
+// src/manifest.ts
+import { readFileSync as readFileSync2, writeFileSync } from "fs";
+import { resolve as resolve3 } from "path";
+var MANIFEST_FILENAME = ".precisa.json";
+var DEFAULT_MANIFEST_FIELDS = {
+  hasPackages: true,
+  hasSite: false,
+  nodeVersion: "22",
+  pnpmVersion: "9.15.9",
+  publishesToNpm: true,
+  schemaVersion: 1,
+  visibility: "oss"
+};
+function isRequired(when, manifest) {
+  switch (when) {
+    case "always":
+      return true;
+    case "oss":
+      return manifest.visibility === "oss";
+    case "private":
+      return manifest.visibility === "private";
+    case "has_site":
+      return manifest.hasSite;
+    case "has_packages":
+      return manifest.hasPackages;
+    case "publishes_to_npm":
+      return manifest.publishesToNpm;
+    default:
+      return true;
+  }
+}
+function tokenContext(manifest) {
+  return {
+    COMMIT_SCOPES: manifest.commitScopes.join(","),
+    CONDUCT_EMAIL: manifest.contactEmails.conduct,
+    HAS_PACKAGES: String(manifest.hasPackages),
+    HAS_SITE: String(manifest.hasSite),
+    NODE_VERSION: manifest.nodeVersion ?? "22",
+    OWNER_ORG: manifest.owner,
+    PNPM_VERSION: manifest.pnpmVersion ?? "9.15.9",
+    PUBLISHES_TO_NPM: String(manifest.publishesToNpm),
+    REPO_NAME: manifest.name,
+    REPO_SLUG: `${manifest.owner}/${manifest.name}`,
+    SECURITY_EMAIL: manifest.contactEmails.security,
+    VISIBILITY: manifest.visibility
+  };
+}
+function validateManifest(raw) {
+  const errors = [];
+  const m = raw;
+  if (!m || typeof m !== "object") {
+    return [{ message: "manifest must be a JSON object", path: "$" }];
+  }
+  if (m.schemaVersion !== 1) {
+    errors.push({ message: "must be 1", path: "schemaVersion" });
+  }
+  if (typeof m.name !== "string" || !m.name) {
+    errors.push({ message: "must be a non-empty string", path: "name" });
+  }
+  if (typeof m.owner !== "string" || !m.owner) {
+    errors.push({ message: "must be a non-empty string", path: "owner" });
+  }
+  if (m.visibility !== "oss" && m.visibility !== "private") {
+    errors.push({ message: "must be 'oss' or 'private'", path: "visibility" });
+  }
+  for (const key of ["hasSite", "hasPackages", "publishesToNpm"]) {
+    if (typeof m[key] !== "boolean") {
+      errors.push({ message: "must be a boolean", path: key });
+    }
+  }
+  if (!Array.isArray(m.commitScopes)) {
+    errors.push({ message: "must be an array of strings", path: "commitScopes" });
+  }
+  if (!m.contactEmails || typeof m.contactEmails !== "object") {
+    errors.push({ message: "must be an object", path: "contactEmails" });
+  } else {
+    for (const key of ["security", "conduct"]) {
+      if (typeof m.contactEmails[key] !== "string" || !m.contactEmails[key]) {
+        errors.push({
+          message: "must be a non-empty string",
+          path: `contactEmails.${key}`
+        });
+      }
+    }
+  }
+  return errors;
+}
+function loadManifest(cwd) {
+  const path = resolve3(cwd, MANIFEST_FILENAME);
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync2(path, "utf-8"));
+  } catch (err) {
+    throw new Error(`Failed to read ${MANIFEST_FILENAME} at ${path}: ${err.message}`);
+  }
+  const errors = validateManifest(raw);
+  if (errors.length > 0) {
+    const detail = errors.map((e) => `  - ${e.path}: ${e.message}`).join("\n");
+    throw new Error(`Invalid ${MANIFEST_FILENAME}:
+${detail}`);
+  }
+  return raw;
+}
+function writeManifest(cwd, manifest) {
+  const path = resolve3(cwd, MANIFEST_FILENAME);
+  writeFileSync(path, `${JSON.stringify(manifest, null, 2)}
+`);
+}
+
+// src/commands/doctor.ts
+async function runDoctor() {
+  const cwd = process.cwd();
+  console.log(chalk.bold.cyan("\nprecisa doctor"));
+  let manifest;
+  try {
+    manifest = loadManifest(cwd);
+  } catch (err) {
+    console.error(chalk.red(`
+${err.message}`));
+    process.exit(1);
+  }
+  const entries = loadTemplateManifest();
+  const context = tokenContext(manifest);
+  const reports = [];
+  for (const entry of entries) {
+    const required = isRequired(entry.required_when, manifest);
+    const targetPath = resolve4(cwd, entry.target);
+    const exists = existsSync2(targetPath);
+    if (!required && !exists) continue;
+    if (!required && exists) {
+      reports.push({
+        message: `Present but not required by the manifest profile (ok)`,
+        severity: "info",
+        target: entry.target
+      });
+      continue;
+    }
+    if (!exists) {
+      reports.push({
+        message: "Missing",
+        severity: "error",
+        target: entry.target
+      });
+      continue;
+    }
+    const source = readTemplateSource(entry);
+    const rendered = renderTokens(source, context);
+    const current = readFileSync3(targetPath, "utf-8");
+    reports.push(compareContent(entry, current, rendered));
+  }
+  console.log("");
+  let errors = 0;
+  let warnings = 0;
+  let infos = 0;
+  let oks = 0;
+  for (const r of reports) {
+    const icon = iconFor(r.severity);
+    const line = `${icon} ${r.target}${r.message ? chalk.dim(` \u2014 ${r.message}`) : ""}`;
+    console.log(line);
+    if (r.severity === "error") errors += 1;
+    else if (r.severity === "warning") warnings += 1;
+    else if (r.severity === "info") infos += 1;
+    else oks += 1;
+  }
+  console.log("");
+  console.log(chalk.dim(`${oks} ok, ${warnings} warning, ${errors} error, ${infos} info`));
+  if (errors > 0) process.exit(1);
+}
+function compareContent(entry, current, rendered) {
+  if (entry.merge_strategy === "preserve") {
+    return {
+      message: current === rendered ? "" : "Differs from template (preserve strategy \u2014 suggestion only)",
+      severity: current === rendered ? "ok" : "info",
+      target: entry.target
+    };
+  }
+  if (current === rendered) {
+    return { message: "", severity: "ok", target: entry.target };
+  }
+  return {
+    message: "Differs from template (run `precisa sync` to update)",
+    severity: "warning",
+    target: entry.target
+  };
+}
+function iconFor(severity) {
+  switch (severity) {
+    case "ok":
+      return chalk.green("\u2713");
+    case "info":
+      return chalk.blue("i");
+    case "warning":
+      return chalk.yellow("!");
+    case "error":
+      return chalk.red("\u2717");
+  }
+}
+
+// src/commands/new.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync } from "fs";
+import { resolve as resolve6 } from "path";
+import chalk2 from "chalk";
+import ora from "ora";
+import prompts from "prompts";
+
+// src/lib/merge.ts
+import { chmodSync, existsSync as existsSync3, mkdirSync, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, resolve as resolve5 } from "path";
+function applyTemplate({ cwd, dryRun, entry, rendered }) {
+  const targetPath = resolve5(cwd, entry.target);
+  const exists = existsSync3(targetPath);
+  if (!exists) {
+    if (!dryRun) writeFile(targetPath, rendered, entry.executable === true);
+    return { kind: "create", rendered, target: entry.target };
+  }
+  const current = readFileSync4(targetPath, "utf-8");
+  switch (entry.merge_strategy) {
+    case "overwrite": {
+      if (current === rendered) {
+        return { kind: "skip-identical", target: entry.target };
+      }
+      if (!dryRun) writeFile(targetPath, rendered, entry.executable === true);
+      return { kind: "update", previous: current, rendered, target: entry.target };
+    }
+    case "skip_if_exists": {
+      return { kind: "skip-exists", target: entry.target };
+    }
+    case "preserve": {
+      return { current, kind: "preserve", rendered, target: entry.target };
+    }
+    case "merge_json": {
+      let merged;
+      try {
+        merged = mergeJson(current, rendered);
+      } catch (err) {
+        return {
+          kind: "error",
+          message: `JSON merge failed: ${err.message}`,
+          target: entry.target
+        };
+      }
+      if (current === merged) {
+        return { kind: "skip-identical", target: entry.target };
+      }
+      if (!dryRun) writeFile(targetPath, merged, entry.executable === true);
+      return { kind: "merge-json", previous: current, rendered: merged, target: entry.target };
+    }
+    default: {
+      return {
+        kind: "error",
+        message: `Unknown merge_strategy '${entry.merge_strategy}'`,
+        target: entry.target
+      };
+    }
+  }
+}
+function writeFile(path, contents, executable) {
+  mkdirSync(dirname2(path), { recursive: true });
+  writeFileSync2(path, contents);
+  if (executable) chmodSync(path, 493);
+}
+function mergeJson(currentRaw, templateRaw) {
+  const current = JSON.parse(currentRaw);
+  const template = JSON.parse(templateRaw);
+  const merged = mergeValue(template, current);
+  return `${JSON.stringify(merged, null, 2)}
+`;
+}
+function mergeValue(template, current) {
+  if (current === void 0) return template;
+  if (typeof template !== "object" || template === null || Array.isArray(template) || typeof current !== "object" || current === null || Array.isArray(current)) {
+    return current;
+  }
+  const out = {};
+  const keys = /* @__PURE__ */ new Set([
+    ...Object.keys(template),
+    ...Object.keys(current)
+  ]);
+  for (const k of keys) {
+    out[k] = mergeValue(
+      template[k],
+      current[k]
+    );
+  }
+  return out;
+}
+
+// src/commands/new.ts
+var PROFILES = {
+  "oss-library": {
+    hasPackages: true,
+    hasSite: false,
+    publishesToNpm: true,
+    visibility: "oss"
+  },
+  "oss-site": {
+    hasPackages: false,
+    hasSite: true,
+    publishesToNpm: false,
+    visibility: "oss"
+  },
+  "private-app": {
+    hasPackages: true,
+    hasSite: true,
+    publishesToNpm: false,
+    visibility: "private"
+  }
+};
+async function runNew(repoName, opts) {
+  const targetDir = resolve6(process.cwd(), repoName);
+  if (existsSync4(targetDir) && readdirSync(targetDir).length > 0) {
+    console.error(chalk2.red(`
+Error: ${targetDir} already exists and is not empty.`));
+    process.exit(1);
+  }
+  const profile = PROFILES[opts.profile];
+  if (!profile) {
+    console.error(
+      chalk2.red(`
+Error: unknown profile '${opts.profile}'. Choose one of:`),
+      Object.keys(PROFILES).join(", ")
+    );
+    process.exit(1);
+  }
+  console.log(chalk2.bold.cyan(`
+precisa new ${repoName}`));
+  console.log(chalk2.dim(`profile: ${opts.profile}${opts.dryRun ? " (dry-run)" : ""}`));
+  console.log(chalk2.dim(`target:  ${targetDir}
+`));
+  const answers = await prompts(
+    [
+      {
+        initial: "Precisa-Saude",
+        message: "GitHub owner (org or user):",
+        name: "owner",
+        type: "text"
+      },
+      {
+        initial: "security@precisa-saude.com.br",
+        message: "Security contact email:",
+        name: "securityEmail",
+        type: "text"
+      },
+      {
+        initial: "conduct@precisa-saude.com.br",
+        message: "Code-of-conduct contact email:",
+        name: "conductEmail",
+        type: "text"
+      },
+      {
+        initial: "docs,ci,deps",
+        message: "Commit scopes (comma-separated):",
+        name: "commitScopes",
+        separator: ",",
+        type: "list"
+      }
+    ],
+    { onCancel: () => process.exit(1) }
+  );
+  const manifest = {
+    ...DEFAULT_MANIFEST_FIELDS,
+    ...profile,
+    commitScopes: answers.commitScopes,
+    contactEmails: {
+      conduct: answers.conductEmail,
+      security: answers.securityEmail
+    },
+    name: repoName,
+    owner: answers.owner
+  };
+  const spinner = ora("Rendering templates").start();
+  try {
+    if (!opts.dryRun) mkdirSync2(targetDir, { recursive: true });
+    const entries = loadTemplateManifest().filter((e) => isRequired(e.required_when, manifest));
+    const context = tokenContext(manifest);
+    let created = 0;
+    let skipped = 0;
+    for (const entry of entries) {
+      const source = readTemplateSource(entry);
+      const rendered = renderTokens(source, context);
+      const outcome = applyTemplate({
+        cwd: targetDir,
+        dryRun: opts.dryRun,
+        entry,
+        rendered
+      });
+      if (outcome.kind === "create") created += 1;
+      else if (outcome.kind === "skip-exists") skipped += 1;
+      else if (outcome.kind === "error") {
+        spinner.fail(`Failed on ${entry.target}`);
+        console.error(chalk2.red(outcome.message));
+        process.exit(1);
+      }
+    }
+    spinner.succeed(
+      opts.dryRun ? `Would render ${created} file${created === 1 ? "" : "s"} (${skipped} skipped)` : `Rendered ${created} file${created === 1 ? "" : "s"} (${skipped} skipped)`
+    );
+    if (opts.dryRun) return;
+    writeManifest(targetDir, manifest);
+    console.log(chalk2.dim(`  wrote .precisa.json`));
+    const gitStep = ora("git init + pnpm install").start();
+    try {
+      execSync("git init --initial-branch=main", { cwd: targetDir, stdio: "pipe" });
+      execSync("pnpm install", { cwd: targetDir, stdio: "pipe" });
+      gitStep.succeed("git init + pnpm install complete");
+    } catch (err) {
+      gitStep.warn(
+        `git/pnpm setup skipped: ${err.message}. Run manually in ${targetDir}.`
+      );
+    }
+    console.log(chalk2.bold.green(`
+\u2713 ${repoName} scaffolded at ${targetDir}`));
+    console.log(chalk2.dim("\nNext:"));
+    console.log(chalk2.dim(`  cd ${repoName}`));
+    console.log(chalk2.dim(`  # start adding your code`));
+  } catch (err) {
+    spinner.fail(err.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/sync.ts
+import chalk4 from "chalk";
+
+// src/lib/diff.ts
+import chalk3 from "chalk";
+import { createPatch } from "diff";
+function colorDiff(filename, previous, next) {
+  const patch = createPatch(filename, previous, next, "", "");
+  const lines = patch.split("\n");
+  const out = [];
+  for (const line of lines) {
+    if (line.startsWith("---") || line.startsWith("+++")) continue;
+    if (line.startsWith("@@")) {
+      out.push(chalk3.cyan(line));
+      continue;
+    }
+    if (line.startsWith("+")) {
+      out.push(chalk3.green(line));
+      continue;
+    }
+    if (line.startsWith("-")) {
+      out.push(chalk3.red(line));
+      continue;
+    }
+    out.push(line);
+  }
+  return out.join("\n");
+}
+
+// src/commands/sync.ts
+async function runSync(opts) {
+  const cwd = process.cwd();
+  console.log(chalk4.bold.cyan(`
+precisa sync${opts.dryRun ? " --dry-run" : ""}`));
+  let manifest;
+  try {
+    manifest = loadManifest(cwd);
+  } catch (err) {
+    console.error(chalk4.red(`
+${err.message}`));
+    console.error(
+      chalk4.dim("\n  Run `precisa new <repo>` in an empty directory to scaffold a new repo,")
+    );
+    console.error(chalk4.dim("  or create a `.precisa.json` manifest manually."));
+    process.exit(1);
+  }
+  const entries = loadTemplateManifest().filter((e) => isRequired(e.required_when, manifest));
+  const context = tokenContext(manifest);
+  const outcomes = [];
+  for (const entry of entries) {
+    const source = readTemplateSource(entry);
+    const rendered = renderTokens(source, context);
+    outcomes.push(
+      applyTemplate({
+        cwd,
+        dryRun: opts.dryRun,
+        entry,
+        rendered
+      })
+    );
+  }
+  console.log("");
+  for (const o of outcomes) {
+    printOutcome(o, opts.dryRun);
+  }
+  const summary = summarize(outcomes);
+  console.log("");
+  console.log(
+    chalk4.dim(
+      `${summary.create} create, ${summary.update} update, ${summary.mergeJson} merge-json, ${summary.preserve} preserve, ${summary.skip} skip, ${summary.error} error`
+    )
+  );
+  if (summary.error > 0) process.exit(1);
+}
+function summarize(outcomes) {
+  const s = { create: 0, error: 0, mergeJson: 0, preserve: 0, skip: 0, update: 0 };
+  for (const o of outcomes) {
+    switch (o.kind) {
+      case "create":
+        s.create += 1;
+        break;
+      case "update":
+        s.update += 1;
+        break;
+      case "merge-json":
+        s.mergeJson += 1;
+        break;
+      case "preserve":
+        s.preserve += 1;
+        break;
+      case "skip-identical":
+      case "skip-exists":
+        s.skip += 1;
+        break;
+      case "error":
+        s.error += 1;
+        break;
+    }
+  }
+  return s;
+}
+function printOutcome(o, dryRun) {
+  const prefix = dryRun ? "(dry-run) " : "";
+  switch (o.kind) {
+    case "create":
+      console.log(`${chalk4.green("+")} ${prefix}create    ${o.target}`);
+      return;
+    case "update":
+      console.log(`${chalk4.yellow("~")} ${prefix}update    ${o.target}`);
+      if (dryRun) console.log(indent(colorDiff(o.target, o.previous, o.rendered)));
+      return;
+    case "merge-json":
+      console.log(`${chalk4.yellow("~")} ${prefix}merge     ${o.target}`);
+      if (dryRun) console.log(indent(colorDiff(o.target, o.previous, o.rendered)));
+      return;
+    case "preserve":
+      console.log(
+        `${chalk4.blue("i")} ${prefix}preserve  ${o.target} (template differs; not written)`
+      );
+      if (dryRun && o.current !== o.rendered) {
+        console.log(indent(colorDiff(o.target, o.current, o.rendered)));
+      }
+      return;
+    case "skip-identical":
+      console.log(`${chalk4.dim("=")} ${prefix}unchanged ${o.target}`);
+      return;
+    case "skip-exists":
+      console.log(`${chalk4.dim("s")} ${prefix}skip      ${o.target} (already exists)`);
+      return;
+    case "error":
+      console.log(`${chalk4.red("!")} ${prefix}error     ${o.target}: ${o.message}`);
+      return;
+  }
+}
+function indent(text) {
+  return text.split("\n").map((l) => `      ${l}`).join("\n");
+}
+export {
+  DEFAULT_MANIFEST_FIELDS,
+  MANIFEST_FILENAME,
+  isRequired,
+  loadManifest,
+  runDoctor,
+  runNew,
+  runSync,
+  tokenContext,
+  validateManifest,
+  writeManifest
+};
+//# sourceMappingURL=index.js.map