@grekt/cli 6.39.0 → 6.40.1

package/dist/index.js

@@ -91853,6 +91853,9 @@ var INDEX_FILE = join8(GREKT_DIR, "index");
 
 // src/shared/filesystem/filesystem.ts
 import { dirname as dirname3, join as join9 } from "path";
+function normalizePath(path8) {
+  return path8.replace(/\\/g, "/");
+}
 function ensureDir(filepath) {
   const dir = dirname3(filepath);
   if (!fs.exists(dir)) {
@@ -102326,6 +102329,24 @@ async function loadWorkspace(cwd) {
     artifacts: discovered.artifacts
   };
 }
+function generateWorkspaceFile(root, artifacts) {
+  const workspacePath = join29(root, "pnpm-workspace.yaml");
+  const rootPackageJsonPath = join29(root, "package.json");
+  const relativePaths = artifacts.map((artifact) => artifact.relativePath);
+  fs.writeFile(workspacePath, $stringify2({ packages: relativePaths }));
+  fs.writeFile(rootPackageJsonPath, JSON.stringify({ name: "workspace-root", private: true }, null, 2) + `
+`);
+}
+function cleanWorkspaceFile(root) {
+  const workspacePath = join29(root, "pnpm-workspace.yaml");
+  const rootPackageJsonPath = join29(root, "package.json");
+  if (fs.exists(workspacePath)) {
+    fs.unlink(workspacePath);
+  }
+  if (fs.exists(rootPackageJsonPath)) {
+    fs.unlink(rootPackageJsonPath);
+  }
+}
 function generatePackageJsonFiles(artifacts) {
   for (const artifact of artifacts) {
     const packageJsonPath = join29(artifact.path, "package.json");
@@ -103268,11 +103289,12 @@ async function handleExecMode(options2) {
     info(`Would run: ${command}`);
     return;
   }
-  const genSpin = spinner("Generating package.json files...");
+  const genSpin = spinner("Generating workspace config files...");
   genSpin.start();
+  generateWorkspaceFile(cwd, workspace.artifacts);
   generatePackageJsonFiles(workspace.artifacts);
   genSpin.stop();
-  success(`Generated ${workspace.artifacts.length} package.json file(s)`);
+  success("Generated workspace config files");
   log("");
   info(`Running: ${command}`);
   log("");
@@ -103282,6 +103304,7 @@ async function handleExecMode(options2) {
     stdio: "inherit"
   });
   if (result.status !== 0) {
+    cleanWorkspaceFile(cwd);
     cleanPackageJsonFiles(workspace.artifacts);
     error(`Command failed with exit code ${result.status}`);
     process.exit(result.status ?? 1);
@@ -103292,6 +103315,7 @@ async function handleExecMode(options2) {
   const updatedWorkspace = await loadWorkspace(cwd);
   if (!updatedWorkspace) {
     syncSpin.stop();
+    cleanWorkspaceFile(cwd);
     cleanPackageJsonFiles(workspace.artifacts);
     error("Failed to reload workspace");
     process.exit(1);
@@ -103305,9 +103329,10 @@ async function handleExecMode(options2) {
   }
   const cleanSpin = spinner("Cleaning up...");
   cleanSpin.start();
+  cleanWorkspaceFile(cwd);
   cleanPackageJsonFiles(workspace.artifacts);
   cleanSpin.stop();
-  success("Removed temporary package.json files");
+  success("Removed temporary config files");
   log("");
   success("Version update complete");
 }
@@ -103332,6 +103357,343 @@ function findArtifacts(basePath) {
   return artifacts;
 }
 
+// src/commands/changelog/git.ts
+function exec(args) {
+  return shell.execFile("git", args).trim();
+}
+function execOrNull(args) {
+  try {
+    const result = exec(args);
+    return result || null;
+  } catch {
+    return null;
+  }
+}
+function splitLines(output) {
+  if (!output)
+    return [];
+  return output.split(`
+`).map((line) => line.trim()).filter(Boolean);
+}
+function detectDefaultBranch() {
+  const symbolicRef = execOrNull([
+    "symbolic-ref",
+    "refs/remotes/origin/HEAD"
+  ]);
+  if (symbolicRef) {
+    const parts = symbolicRef.split("/");
+    return parts[parts.length - 1] ?? "main";
+  }
+  return "main";
+}
+function getFirstCommit() {
+  return execOrNull(["rev-list", "--max-parents=0", "HEAD"]);
+}
+function detectBaseRef(overrideSince) {
+  if (overrideSince) {
+    const resolved = execOrNull(["rev-parse", "--verify", overrideSince]);
+    if (!resolved) {
+      throw new Error(`Invalid ref: ${overrideSince}`);
+    }
+    return overrideSince;
+  }
+  const currentBranch = execOrNull(["rev-parse", "--abbrev-ref", "HEAD"]);
+  const defaultBranch = detectDefaultBranch();
+  const isDefaultBranch = currentBranch === defaultBranch || currentBranch === "HEAD";
+  if (isDefaultBranch) {
+    return null;
+  }
+  const hasRemote = execOrNull(["remote"]);
+  if (hasRemote) {
+    return `origin/${defaultBranch}`;
+  }
+  warning("No remote found, falling back to local refs");
+  return defaultBranch;
+}
+function detectArtifactBaseRef(artifactName) {
+  const lastTag = execOrNull([
+    "describe",
+    "--tags",
+    "--abbrev=0",
+    "--match",
+    `${artifactName}@*`
+  ]);
+  if (lastTag)
+    return lastTag;
+  const firstCommit = getFirstCommit();
+  if (firstCommit)
+    return firstCommit;
+  warning(`${artifactName}: no tags found, falling back to HEAD~1`);
+  return "HEAD~1";
+}
+function getChangedFiles(baseRef, path8) {
+  const baseArgs = ["diff", "--name-only"];
+  const pathFilter = path8 ? ["--", path8] : [];
+  const output = execOrNull([...baseArgs, `${baseRef}...HEAD`, ...pathFilter]) ?? execOrNull([...baseArgs, baseRef, "HEAD", ...pathFilter]);
+  return splitLines(output);
+}
+function getCommitsForPath(baseRef, path8) {
+  const output = execOrNull([
+    "log",
+    "--format=%H %s",
+    `${baseRef}..HEAD`,
+    "--",
+    path8
+  ]);
+  return splitLines(output);
+}
+
+// src/commands/changelog/conventional-commits.ts
+var CONVENTIONAL_COMMIT_REGEX = /^([a-f0-9]+)\s+(\w+)(\(.+?\))?(!)?\s*:\s*(.+)$/;
+function parseConventionalCommit(line) {
+  if (line.includes("\x00"))
+    return null;
+  const match = line.match(CONVENTIONAL_COMMIT_REGEX);
+  if (!match)
+    return null;
+  const hash = match[1] ?? "";
+  const type = match[2] ?? "";
+  const scopeRaw = match[3];
+  const bang = match[4];
+  const message = match[5] ?? "";
+  const scope = scopeRaw ? scopeRaw.slice(1, -1) : null;
+  const breaking = bang === "!" || message.toUpperCase().includes("BREAKING CHANGE");
+  return {
+    hash,
+    type,
+    scope,
+    breaking,
+    message,
+    raw: line
+  };
+}
+function determineBumpType(commits) {
+  if (commits.some((commit) => commit.breaking))
+    return "major";
+  if (commits.some((commit) => commit.type === "feat"))
+    return "minor";
+  return "patch";
+}
+function mapFilesToArtifacts(changedFiles, artifacts) {
+  const result = new Map;
+  for (const file of changedFiles) {
+    for (const artifact of artifacts) {
+      const normalized = normalizePath(artifact.relativePath);
+      const prefix = normalized.endsWith("/") ? normalized : `${normalized}/`;
+      if (file.startsWith(prefix)) {
+        const existing = result.get(artifact.relativePath) ?? [];
+        existing.push(file);
+        result.set(artifact.relativePath, existing);
+        break;
+      }
+    }
+  }
+  return result;
+}
+
+// src/commands/changelog/changeset-output.ts
+import { join as join31 } from "path";
+import { randomBytes as randomBytes3 } from "crypto";
+var CHANGESET_DIR = ".changeset";
+function generateChangesetFile(artifacts, workspaceRoot) {
+  const changesetDir = join31(workspaceRoot, CHANGESET_DIR);
+  if (!fs.exists(changesetDir)) {
+    fs.mkdir(changesetDir, { recursive: true });
+  }
+  const filename = `${randomBytes3(4).toString("hex")}.md`;
+  const filepath = join31(changesetDir, filename);
+  const content = buildChangesetContent(artifacts);
+  fs.writeFile(filepath, content);
+  return filepath;
+}
+function buildChangesetContent(artifacts) {
+  const frontmatterLines = [];
+  const bodyLines = [];
+  for (const entry of artifacts) {
+    const { name: name2 } = entry.artifact.manifest;
+    frontmatterLines.push(`"${name2}": ${entry.calculatedBump}`);
+    if (entry.commits.length > 0) {
+      for (const commit of entry.commits) {
+        bodyLines.push(`- ${name2}: ${commit.type}: ${commit.message}`);
+      }
+    } else {
+      bodyLines.push(`- ${name2}: changed files detected`);
+    }
+  }
+  return ["---", ...frontmatterLines, "---", "", ...bodyLines, ""].join(`
+`);
+}
+function previewChangesetContent(artifacts) {
+  return buildChangesetContent(artifacts);
+}
+function toOutputEntry(entry) {
+  return {
+    name: entry.artifact.manifest.name,
+    version: entry.artifact.manifest.version,
+    bump: entry.calculatedBump,
+    commits: entry.commits.map((commit) => ({
+      hash: commit.hash,
+      type: commit.type,
+      scope: commit.scope,
+      breaking: commit.breaking,
+      message: commit.message
+    })),
+    changedFiles: entry.changedFiles
+  };
+}
+function formatJson(artifacts, baseRef) {
+  return JSON.stringify({ baseRef, artifacts: artifacts.map(toOutputEntry) }, null, 2);
+}
+function formatYaml(artifacts, baseRef) {
+  return $stringify2({
+    baseRef,
+    artifacts: artifacts.map(toOutputEntry)
+  });
+}
+
+// src/commands/changelog/changelog.ts
+var BUMP_CHOICES = [
+  { name: "patch", value: "patch" },
+  { name: "minor", value: "minor" },
+  { name: "major", value: "major" },
+  { name: "skip", value: "skip" }
+];
+var changelogCommand = new Command("changelog").description("Generate changesets from git history for workspace artifacts").option("--ci", "Unattended mode (no prompts, auto-generate from commits)").option("--format <format>", "Output format: changeset (default), json, yaml", "changeset").option("--since <ref>", "Override base ref (auto-detected otherwise)").option("--dry-run", "Preview without writing").action(async (options2) => {
+  const cwd = process.cwd();
+  if (!isWorkspaceRoot(fs, cwd)) {
+    error("Not a workspace (grekt-workspace.yaml not found)");
+    info("Run this command from your workspace root");
+    process.exit(1);
+  }
+  const workspace = await loadWorkspace(cwd);
+  if (!workspace || workspace.artifacts.length === 0) {
+    error("No artifacts found in workspace");
+    process.exit(1);
+  }
+  const globalBaseRef = detectBaseRef(options2.since);
+  const artifactChangelogs = globalBaseRef ? buildFromGlobalRef(workspace.artifacts, globalBaseRef, options2.ci) : buildPerArtifact(workspace.artifacts, options2.ci);
+  if (artifactChangelogs.length === 0) {
+    info("No artifact changes detected");
+    process.exit(0);
+  }
+  const displayRef = globalBaseRef ?? "per-artifact tags";
+  if (options2.ci) {
+    printSummary(artifactChangelogs, displayRef);
+    outputResult(artifactChangelogs, displayRef, cwd, options2);
+  } else {
+    await withPromptHandler(() => handleInteractiveMode(artifactChangelogs, displayRef, cwd, options2));
+  }
+});
+function buildFromGlobalRef(artifacts, baseRef, ciMode) {
+  const changedFiles = getChangedFiles(baseRef);
+  if (changedFiles.length === 0)
+    return [];
+  const filesByArtifact = mapFilesToArtifacts(changedFiles, artifacts);
+  const result = [];
+  for (const artifact of artifacts) {
+    const files = filesByArtifact.get(artifact.relativePath);
+    if (!files)
+      continue;
+    result.push(buildArtifactChangelog(artifact, files, baseRef, ciMode));
+  }
+  return result;
+}
+function buildPerArtifact(artifacts, ciMode) {
+  const result = [];
+  for (const artifact of artifacts) {
+    const baseRef = detectArtifactBaseRef(artifact.manifest.name);
+    const changedFiles = getChangedFiles(baseRef, artifact.relativePath);
+    if (changedFiles.length === 0)
+      continue;
+    result.push(buildArtifactChangelog(artifact, changedFiles, baseRef, ciMode));
+  }
+  return result;
+}
+function buildArtifactChangelog(artifact, changedFiles, baseRef, ciMode) {
+  const commitLines = getCommitsForPath(baseRef, artifact.relativePath);
+  const commits = commitLines.map(parseConventionalCommit).filter((commit) => commit !== null);
+  const nonConventionalCount = commitLines.length - commits.length;
+  if (nonConventionalCount > 0 && ciMode) {
+    warning(`${artifact.manifest.name}: ${nonConventionalCount} non-conventional commit(s) ignored`);
+  }
+  const calculatedBump = commits.length > 0 ? determineBumpType(commits) : "patch";
+  if (commits.length === 0 && ciMode) {
+    warning(`${artifact.manifest.name}: no conventional commits found, defaulting to patch`);
+  }
+  return {
+    artifact,
+    commits,
+    calculatedBump,
+    changedFiles
+  };
+}
+function printSummary(artifactChangelogs, baseRef) {
+  newline();
+  info(`Base ref: ${colors5.highlight(baseRef)}`);
+  info(`${artifactChangelogs.length} artifact(s) with changes:`);
+  newline();
+  for (const entry of artifactChangelogs) {
+    const { name: name2, version: version3 } = entry.artifact.manifest;
+    log(`  ${name2} ${colors5.dim(`v${version3}`)} ${symbols.arrow} ${colors5.bold(entry.calculatedBump)} ${colors5.dim(`(${entry.commits.length} commit(s))`)}`);
+  }
+  newline();
+}
+async function handleInteractiveMode(artifactChangelogs, baseRef, cwd, options2) {
+  printSummary(artifactChangelogs, baseRef);
+  const finalChangelogs = [];
+  for (const entry of artifactChangelogs) {
+    const { name: name2 } = entry.artifact.manifest;
+    const bump = await esm_default6({
+      message: `${name2}: bump type?`,
+      choices: BUMP_CHOICES,
+      default: entry.calculatedBump
+    });
+    if (bump === "skip") {
+      info(`Skipping ${name2}`);
+      continue;
+    }
+    finalChangelogs.push({
+      ...entry,
+      calculatedBump: bump
+    });
+  }
+  if (finalChangelogs.length === 0) {
+    newline();
+    info("All artifacts skipped");
+    return;
+  }
+  newline();
+  const confirmed = await esm_default3({
+    message: `Generate changeset for ${finalChangelogs.length} artifact(s)?`,
+    default: true
+  });
+  if (!confirmed) {
+    info("Cancelled");
+    return;
+  }
+  outputResult(finalChangelogs, baseRef, cwd, options2);
+}
+function outputResult(artifactChangelogs, baseRef, cwd, options2) {
+  const format = options2.format ?? "changeset";
+  if (format === "json") {
+    log(formatJson(artifactChangelogs, baseRef));
+    return;
+  }
+  if (format === "yaml") {
+    log(formatYaml(artifactChangelogs, baseRef));
+    return;
+  }
+  if (options2.dryRun) {
+    newline();
+    info("Dry run — changeset content:");
+    newline();
+    log(previewChangesetContent(artifactChangelogs));
+    return;
+  }
+  const filepath = generateChangesetFile(artifactChangelogs, cwd);
+  newline();
+  success(`Changeset written to ${filepath}`);
+}
 // src/commands/workspace/workspace.ts
 var listSubcommand = new Command("list").description("List all artifacts in the workspace").action(async () => {
   const cwd = process.cwd();
@@ -103355,7 +103717,7 @@ var listSubcommand = new Command("list").description("List all artifacts in the
 });
 var workspaceCommand = new Command("workspace").description("Manage monorepo workspaces").addCommand(listSubcommand);
 // src/commands/worktree/worktree.ts
-import { join as join31, dirname as dirname11, isAbsolute as isAbsolute4 } from "path";
+import { join as join32, dirname as dirname11, isAbsolute as isAbsolute4 } from "path";
 var GREKT_DIR2 = ".grekt";
 function getGitCommonDir() {
   try {
@@ -103372,7 +103734,7 @@ function getWorktreeRoot() {
   }
 }
 function resolveOriginalRepoRoot(commonDir, worktreeRoot) {
-  const absoluteCommonDir = isAbsolute4(commonDir) ? commonDir : join31(worktreeRoot, commonDir);
+  const absoluteCommonDir = isAbsolute4(commonDir) ? commonDir : join32(worktreeRoot, commonDir);
   return dirname11(absoluteCommonDir);
 }
 function isInsideWorktree(commonDir) {
@@ -103395,8 +103757,8 @@ var syncSubcommand = new Command("sync").description("Copy .grekt/ from the orig
     process.exit(1);
   }
   const originalRepoRoot = resolveOriginalRepoRoot(commonDir, worktreeRoot);
-  const sourcePath = join31(originalRepoRoot, GREKT_DIR2);
-  const destPath = join31(worktreeRoot, GREKT_DIR2);
+  const sourcePath = join32(originalRepoRoot, GREKT_DIR2);
+  const destPath = join32(worktreeRoot, GREKT_DIR2);
   if (!fs.exists(sourcePath)) {
     info("No .grekt/ directory found in the original repository");
     process.exit(0);
@@ -103419,7 +103781,7 @@ var syncSubcommand = new Command("sync").description("Copy .grekt/ from the orig
 });
 var worktreeCommand = new Command("worktree").description("Manage git worktree integration").addCommand(syncSubcommand);
 // src/commands/scan.ts
-import { join as join32, resolve as resolve8 } from "path";
+import { join as join33, resolve as resolve8 } from "path";
 var VALID_BADGES = ["certified", "conditional", "suspicious", "rejected"];
 var BADGE_COLORS = {
   certified: colors5.success,
@@ -103515,7 +103877,7 @@ var scanCommand = new Command("scan").description("Scan artifacts for security i
 });
 async function scanRemoteArtifact(source, projectRoot, jsonOutput, failOnThreshold) {
   const displayName = getSourceDisplayName(source);
-  const tempDir = join32(projectRoot, ARTIFACTS_DIR, `.tmp-scan-${cryptoProvider.randomUUID()}`);
+  const tempDir = join33(projectRoot, ARTIFACTS_DIR, `.tmp-scan-${cryptoProvider.randomUUID()}`);
   try {
     if (!jsonOutput) {
       const spin = spinner(`Downloading ${colors5.highlight(displayName)}...`);
@@ -103641,14 +104003,14 @@ async function scanAllInstalled(projectRoot, jsonOutput, failOnThreshold) {
   }
   const config = getConfig(projectRoot);
   const trustKey = process.env.GREKT_TRUST_KEY;
-  const artifactsDir = join32(projectRoot, ARTIFACTS_DIR);
+  const artifactsDir = join33(projectRoot, ARTIFACTS_DIR);
   const results = [];
   const errors4 = [];
   if (!jsonOutput) {
     log(`Scanning ${colors5.bold(String(artifactIds.length))} artifact${artifactIds.length === 1 ? "" : "s"}...`);
   }
   for (const artifactId of artifactIds) {
-    const artifactDir = join32(artifactsDir, artifactId);
+    const artifactDir = join33(artifactsDir, artifactId);
     if (!fs.exists(artifactDir)) {
       errors4.push({ artifactId, message: "Not installed (directory missing)" });
       continue;
@@ -103996,7 +104358,7 @@ var whoamiCommand = new Command("whoami").description("Show current user").actio
 // package.json
 var package_default = {
   name: "@grekt/cli",
-  version: "6.39.0",
+  version: "6.40.1",
   description: "AI tools versioned, synced, and shared across tools and teams",
   type: "module",
   bin: {
@@ -104065,13 +104427,13 @@ var package_default = {
 // src/update-check/update-check.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 var CACHE_FILENAME = ".update-check";
 var STALENESS_MS = 24 * 60 * 60 * 1000;
 var FETCH_TIMEOUT_MS = 1500;
 var GITHUB_RELEASES_URL = "https://api.github.com/repos/grekt-labs/cli/releases/latest";
 function getCachePath() {
-  return join33(homedir3(), ".grekt", CACHE_FILENAME);
+  return join34(homedir3(), ".grekt", CACHE_FILENAME);
 }
 function isOptedOut() {
   return process.env.GREKT_NO_UPDATE_CHECK === "1";
@@ -104090,7 +104452,7 @@ function readCache() {
 }
 function writeCache(cache2) {
   try {
-    const dir = join33(homedir3(), ".grekt");
+    const dir = join34(homedir3(), ".grekt");
     if (!existsSync2(dir)) {
       mkdirSync3(dir, { recursive: true });
     }
@@ -104198,6 +104560,7 @@ program2.addCommand(versionsCommand);
 program2.addCommand(outdatedCommand);
 program2.addCommand(upgradeCommand);
 program2.addCommand(versionCommand);
+program2.addCommand(changelogCommand);
 program2.addCommand(workspaceCommand);
 program2.addCommand(worktreeCommand);
 program2.addCommand(scanCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grekt/cli",
-  "version": "6.39.0",
+  "version": "6.40.1",
   "description": "AI tools versioned, synced, and shared across tools and teams",
   "type": "module",
   "bin": {