@db-ux/agent-cli 4.12.0 → 4.13.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @db-ux/agent-cli
 
+## 4.13.0
+
+_version bump_
+
+## 4.12.1
+
+_version bump_
+
 ## 4.12.0
 
 _version bump_

package/build/index.js

@@ -4,33 +4,41 @@
 import { program } from "commander";
 
 // src/index.ts
-import fs4 from "node:fs";
-import path4 from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join4 } from "node:path";
 
 // src/amazonq/index.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { join as join2, resolve as resolve2 } from "node:path";
 
 // src/utils/index.ts
-import fs from "node:fs";
-import path from "node:path";
+import {
+  existsSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  statSync
+} from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
 function findAllNodeModulesDirectories(directory, found = /* @__PURE__ */ new Set()) {
-  if (!fs.existsSync(directory)) {
+  if (!existsSync(directory)) {
     return found;
   }
-  const entries = fs.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name, "en"));
+  const entries = readdirSync(directory, { withFileTypes: true }).sort(
+    (a, b) => a.name.localeCompare(b.name, "en")
+  );
   for (const entry of entries) {
-    const fullPath = path.resolve(directory, entry.name);
+    const fullPath = resolve(directory, entry.name);
     let isDirectory = false;
     try {
-      const stats = fs.statSync(fullPath);
+      const stats = statSync(fullPath);
       isDirectory = stats.isDirectory();
     } catch {
       continue;
     }
     if (isDirectory) {
       if (entry.name === "node_modules") {
-        found.add(fs.realpathSync(fullPath));
+        found.add(realpathSync(fullPath));
       } else if (!entry.name.startsWith(".")) {
         findAllNodeModulesDirectories(fullPath, found);
       }
@@ -46,24 +54,28 @@ var getInstructions = (rootPath) => {
   }
   let powersPath = "";
   for (const nodeModulesPath of nodeModulesDirectories) {
-    const agentCliPowersPath = path.join(
+    const agentCliPowersPath = join(
       nodeModulesPath,
       "@db-ux",
       "agent-cli",
       "db-ux-consumer-powers"
     );
-    if (fs.existsSync(agentCliPowersPath)) {
-      powersPath = path.relative(rootPath, agentCliPowersPath).replaceAll("\\", "/");
+    if (existsSync(agentCliPowersPath)) {
+      powersPath = relative(rootPath, agentCliPowersPath).replaceAll(
+        "\\",
+        "/"
+      );
       break;
     }
   }
   if (!powersPath) {
-    const packageDir = path.dirname(
-      path.dirname(new URL(import.meta.url).pathname)
-    );
-    const localPowersPath = path.join(packageDir, "db-ux-consumer-powers");
-    if (fs.existsSync(localPowersPath)) {
-      powersPath = path.relative(rootPath, localPowersPath).replaceAll("\\", "/");
+    const packageDir = dirname(dirname(new URL(import.meta.url).pathname));
+    const localPowersPath = join(packageDir, "db-ux-consumer-powers");
+    if (existsSync(localPowersPath)) {
+      powersPath = relative(rootPath, localPowersPath).replaceAll(
+        "\\",
+        "/"
+      );
     }
   }
   let copilotInstructionsContent = `# DB UX Design System Automation Core
@@ -78,30 +90,33 @@ ${powersPath ? `
 `;
   for (const nodeModulesPath of nodeModulesDirectories) {
     const databaseUxPaths = [
-      path.join(nodeModulesPath, "@db-ux/"),
-      path.join(nodeModulesPath, "@db-ux-inner-source/")
+      join(nodeModulesPath, "@db-ux/"),
+      join(nodeModulesPath, "@db-ux-inner-source/")
     ];
     for (const databaseUxPath of databaseUxPaths) {
-      if (!fs.existsSync(databaseUxPath)) {
+      if (!existsSync(databaseUxPath)) {
         continue;
       }
-      const packages = fs.readdirSync(databaseUxPath, {
+      const packages = readdirSync(databaseUxPath, {
         withFileTypes: true
       });
       for (const package_ of packages) {
-        let packagePath = path.resolve(databaseUxPath, package_.name);
+        let packagePath = resolve(databaseUxPath, package_.name);
         let isDirectory = false;
         try {
-          const stats = fs.statSync(packagePath);
+          const stats = statSync(packagePath);
           isDirectory = stats.isDirectory();
           if (!isDirectory && stats.isFile()) {
-            const content = fs.readFileSync(packagePath, "utf8").trim();
+            const content = readFileSync(
+              packagePath,
+              "utf8"
+            ).trim();
             if (!content.includes("\n")) {
-              const targetPath = path.resolve(
-                path.dirname(packagePath),
+              const targetPath = resolve(
+                dirname(packagePath),
                 content
               );
-              if (fs.existsSync(targetPath) && fs.statSync(targetPath).isDirectory()) {
+              if (existsSync(targetPath) && statSync(targetPath).isDirectory()) {
                 isDirectory = true;
                 packagePath = targetPath;
               }
@@ -111,17 +126,14 @@ ${powersPath ? `
           continue;
         }
         if (isDirectory) {
-          const instructionsPath = path.join(
+          const instructionsPath = join(
             packagePath,
             "agent",
             "_instructions.md"
           );
-          if (fs.existsSync(instructionsPath)) {
-            let content = fs.readFileSync(instructionsPath, "utf8");
-            const relativePath = path.relative(
-              rootPath,
-              packagePath
-            );
+          if (existsSync(instructionsPath)) {
+            let content = readFileSync(instructionsPath, "utf8");
+            const relativePath = relative(rootPath, packagePath);
             content = content.replaceAll(
               "__agent-path__",
               relativePath.replaceAll("\\", "/")
@@ -130,7 +142,7 @@ ${powersPath ? `
               relativePath.replaceAll("\\", "/")
             );
             copilotInstructionsContent += `
-# ${path.basename(databaseUxPath)}/${package_.name}
+# ${basename(databaseUxPath)}/${package_.name}
 ${content}
 `;
           }
@@ -144,20 +156,17 @@ ${content}
 
 // src/amazonq/index.ts
 var generateAmazonQ = (rootPath) => {
-  const outputFolder = path2.resolve(rootPath, ".amazonq", "rules");
-  if (!fs2.existsSync(outputFolder)) {
-    fs2.mkdirSync(outputFolder, { recursive: true });
+  const outputFolder = resolve2(rootPath, ".amazonq", "rules");
+  if (!existsSync2(outputFolder)) {
+    mkdirSync(outputFolder, { recursive: true });
   }
-  const amazonqInstructionsPath = path2.join(outputFolder, "db-ux.md");
-  if (!fs2.existsSync(amazonqInstructionsPath)) {
-    fs2.writeFileSync(amazonqInstructionsPath, "");
+  const amazonqInstructionsPath = join2(outputFolder, "db-ux.md");
+  if (!existsSync2(amazonqInstructionsPath)) {
+    writeFileSync(amazonqInstructionsPath, "");
   }
   const amazonqInstructionsContent = getInstructions(rootPath);
-  if (amazonqInstructionsContent) {
-    let amazonqFileContent = fs2.readFileSync(
-      amazonqInstructionsPath,
-      "utf8"
-    );
+  if (amazonqInstructionsContent !== "") {
+    let amazonqFileContent = readFileSync2(amazonqInstructionsPath, "utf8");
     const startMarker = "--- START: DB UX Amazon Q Instructions \u2013 do not edit below ---";
     const endMarker = "--- END: DB UX Amazon Q Instructions \u2013 do not edit above ---";
     const startIndex = amazonqFileContent.indexOf(startMarker);
@@ -173,31 +182,28 @@ ${amazonqInstructionsContent}
 
 ${endMarker}
 `;
-    fs2.writeFileSync(amazonqInstructionsPath, amazonqFileContent);
+    writeFileSync(amazonqInstructionsPath, amazonqFileContent);
   }
 };
 
 // src/copilot/index.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join3, resolve as resolve3 } from "node:path";
 var generateCopilot = (rootPath) => {
-  const outputFolder = path3.resolve(rootPath, ".github");
-  if (!fs3.existsSync(outputFolder)) {
-    fs3.mkdirSync(outputFolder, { recursive: true });
+  const outputFolder = resolve3(rootPath, ".github");
+  if (!existsSync3(outputFolder)) {
+    mkdirSync2(outputFolder, { recursive: true });
   }
-  const copilotInstructionsPath = path3.join(
+  const copilotInstructionsPath = join3(
     outputFolder,
     "copilot-instructions.md"
   );
-  if (!fs3.existsSync(copilotInstructionsPath)) {
-    fs3.writeFileSync(copilotInstructionsPath, "");
+  if (!existsSync3(copilotInstructionsPath)) {
+    writeFileSync2(copilotInstructionsPath, "");
   }
   const copilotInstructionsContent = getInstructions(rootPath);
-  if (copilotInstructionsContent) {
-    let copilotFileContent = fs3.readFileSync(
-      copilotInstructionsPath,
-      "utf8"
-    );
+  if (copilotInstructionsContent !== "") {
+    let copilotFileContent = readFileSync3(copilotInstructionsPath, "utf8");
     const startMarker = "--- START: DB UX Copilot Instructions \u2013 do not edit below ---";
     const endMarker = "--- END: DB UX Copilot Instructions \u2013 do not edit above ---";
     const startIndex = copilotFileContent.indexOf(startMarker);
@@ -213,16 +219,16 @@ ${copilotInstructionsContent}
 
 ${endMarker}
 		`;
-    fs3.writeFileSync(copilotInstructionsPath, copilotFileContent);
+    writeFileSync2(copilotInstructionsPath, copilotFileContent);
   }
 };
 
 // src/index.ts
 var action = async (rootPath = ".") => {
-  const hasCopilot = fs4.existsSync(
-    path4.join(rootPath, ".github", "copilot-instructions.md")
+  const hasCopilot = existsSync4(
+    join4(rootPath, ".github", "copilot-instructions.md")
   );
-  const hasAmazonQ = fs4.existsSync(path4.join(rootPath, ".amazonq", "rules"));
+  const hasAmazonQ = existsSync4(join4(rootPath, ".amazonq", "rules"));
   if (!hasCopilot && !hasAmazonQ) {
     generateCopilot(rootPath);
     generateAmazonQ(rootPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@db-ux/agent-cli",
-  "version": "4.12.0",
+  "version": "4.13.0",
   "type": "module",
   "description": "CLI for DB UX Design System generate AI agent instructions",
   "repository": {
@@ -25,7 +25,7 @@
     "esbuild": "0.28.1",
     "npm-run-all2": "9.0.2",
     "tsx": "4.22.4",
-    "vitest": "4.1.8"
+    "vitest": "4.1.9"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",