@aigne/doc-smith 0.2.4 → 0.2.6

package/utils/utils.mjs

@@ -83,6 +83,7 @@ export async function saveDocWithTranslations({
   locale,
   translates = [],
   labels,
+  isTranslate = false,
 }) {
   const results = [];
   try {
@@ -96,20 +97,22 @@ export async function saveDocWithTranslations({
       return isEnglish ? `${flatName}.md` : `${flatName}.${language}.md`;
     };
 
-    // Save main content with appropriate filename based on locale
-    const mainFileName = getFileName(locale);
-    const mainFilePath = path.join(docsDir, mainFileName);
+    // Save main content with appropriate filename based on locale (skip if isTranslate is true)
+    if (!isTranslate) {
+      const mainFileName = getFileName(locale);
+      const mainFilePath = path.join(docsDir, mainFileName);
 
-    // Add labels front matter if labels are provided
-    let finalContent = processContent({ content });
-    if (labels && labels.length > 0) {
-      const frontMatter = `---\nlabels: ${JSON.stringify(labels)}\n---\n\n`;
-      finalContent = frontMatter + finalContent;
-    }
+      // Add labels front matter if labels are provided
+      let finalContent = processContent({ content });
+      if (labels && labels.length > 0) {
+        const frontMatter = `---\nlabels: ${JSON.stringify(labels)}\n---\n\n`;
+        finalContent = frontMatter + finalContent;
+      }
 
-    await fs.writeFile(mainFilePath, finalContent, "utf8");
-    results.push({ path: mainFilePath, success: true });
-    console.log(chalk.green(`Saved: ${chalk.cyan(mainFilePath)}`));
+      await fs.writeFile(mainFilePath, finalContent, "utf8");
+      results.push({ path: mainFilePath, success: true });
+      console.log(chalk.green(`Saved: ${chalk.cyan(mainFilePath)}`));
+    }
 
     // Process all translations
     for (const translate of translates) {
@@ -162,7 +165,7 @@ export async function saveGitHeadToConfig(gitHead) {
   }
 
   try {
-    const docSmithDir = path.join(process.cwd(), "doc-smith");
+    const docSmithDir = path.join(process.cwd(), "./.aigne/doc-smith");
     if (!existsSync(docSmithDir)) {
       mkdirSync(docSmithDir, { recursive: true });
     }
@@ -345,7 +348,11 @@ export function hasFileChangesBetweenCommits(
  * @returns {Promise<Object|null>} - The config object or null if file doesn't exist
  */
 export async function loadConfigFromFile() {
-  const configPath = path.join(process.cwd(), "doc-smith", "config.yaml");
+  const configPath = path.join(
+    process.cwd(),
+    "./.aigne/doc-smith",
+    "config.yaml"
+  );
 
   try {
     if (!existsSync(configPath)) {
@@ -364,14 +371,15 @@ export async function loadConfigFromFile() {
  * Save value to config.yaml file
  * @param {string} key - The config key to save
  * @param {string} value - The value to save
+ * @param {string} [comment] - Optional comment to add above the key
  */
-export async function saveValueToConfig(key, value) {
-  if (!value) {
-    return; // Skip if no value provided
+export async function saveValueToConfig(key, value, comment) {
+  if (value === undefined) {
+    return; // Skip if value is undefined
   }
 
   try {
-    const docSmithDir = path.join(process.cwd(), "doc-smith");
+    const docSmithDir = path.join(process.cwd(), "./.aigne/doc-smith");
     if (!existsSync(docSmithDir)) {
       mkdirSync(docSmithDir, { recursive: true });
     }
@@ -385,17 +393,38 @@ export async function saveValueToConfig(key, value) {
     }
 
     // Check if key already exists in the file
-    const keyRegex = new RegExp(`^${key}:\\s*.*$`, "m");
-    const newKeyLine = `${key}: ${value}`;
+    const lines = fileContent.split("\n");
+    const keyRegex = new RegExp(`^${key}:\\s*.*$`);
+    const newKeyLine = `${key}: "${value}"`;
+
+    const keyIndex = lines.findIndex((line) => keyRegex.test(line));
 
-    if (keyRegex.test(fileContent)) {
+    if (keyIndex !== -1) {
       // Replace existing key line
-      fileContent = fileContent.replace(keyRegex, newKeyLine);
+      lines[keyIndex] = newKeyLine;
+      fileContent = lines.join("\n");
+
+      // Add comment if provided and not already present
+      if (
+        comment &&
+        keyIndex > 0 &&
+        !lines[keyIndex - 1].trim().startsWith("# ")
+      ) {
+        // Add comment above the key if it doesn't already have one
+        lines.splice(keyIndex, 0, `# ${comment}`);
+        fileContent = lines.join("\n");
+      }
     } else {
       // Add key to the end of file
       if (fileContent && !fileContent.endsWith("\n")) {
         fileContent += "\n";
       }
+
+      // Add comment if provided
+      if (comment) {
+        fileContent += `# ${comment}\n`;
+      }
+
       fileContent += newKeyLine + "\n";
     }
 
@@ -472,20 +501,20 @@ export function validatePaths(paths) {
 }
 
 /**
- * Check if input is a valid directory and add it to results if so
+ * Check if input is a valid directory or file and add it to results if so
  * @param {string} searchTerm - The search term to check
  * @param {Array} results - The results array to modify
  */
-function addExactDirectoryMatch(searchTerm, results) {
+function addExactPathMatch(searchTerm, results) {
   const inputValidation = validatePath(searchTerm);
   if (inputValidation.isValid) {
     const stats = statSync(normalizePath(searchTerm));
-    if (stats.isDirectory()) {
-      results.unshift({
-        name: searchTerm,
-        value: searchTerm,
-      });
-    }
+    const isDirectory = stats.isDirectory();
+    results.unshift({
+      name: searchTerm,
+      value: searchTerm,
+      description: isDirectory ? "📁 Directory" : "📄 File",
+    });
   }
 }
 
@@ -510,7 +539,7 @@ export function getAvailablePaths(userInput = "") {
       const dirPath = path.dirname(searchTerm);
       const fileName = path.basename(searchTerm);
       results = getDirectoryContents(dirPath, fileName);
-      addExactDirectoryMatch(searchTerm, results);
+      addExactPathMatch(searchTerm, results);
     }
     // Handle relative paths
     else if (searchTerm.startsWith("./") || searchTerm.startsWith("../")) {
@@ -519,7 +548,7 @@ export function getAvailablePaths(userInput = "") {
       if (lastSlashIndex === -1) {
         // No slash found, treat as current directory search
         results = getDirectoryContents("./", searchTerm);
-        addExactDirectoryMatch(searchTerm, results);
+        addExactPathMatch(searchTerm, results);
       } else {
         const dirPath = searchTerm.substring(0, lastSlashIndex + 1);
         const fileName = searchTerm.substring(lastSlashIndex + 1);
@@ -537,13 +566,13 @@ export function getAvailablePaths(userInput = "") {
         }
 
         results = getDirectoryContents(dirPath, fileName);
-        addExactDirectoryMatch(searchTerm, results);
+        addExactPathMatch(searchTerm, results);
       }
     }
     // Handle simple file/directory names (search in current directory)
     else {
       results = getDirectoryContents("./", searchTerm);
-      addExactDirectoryMatch(searchTerm, results);
+      addExactPathMatch(searchTerm, results);
     }
 
     // Remove duplicates based on value (path)
@@ -571,7 +600,7 @@ export function getAvailablePaths(userInput = "") {
  * Get directory contents for a specific path
  * @param {string} dirPath - Directory path to search in
  * @param {string} searchTerm - Optional search term to filter results
- * @returns {Array<Object>} - Array of path objects
+ * @returns {Array<Object>} - Array of path objects (both files and directories)
  */
 function getDirectoryContents(dirPath, searchTerm = "") {
   try {
@@ -623,17 +652,24 @@ function getDirectoryContents(dirPath, searchTerm = "") {
 
       const isDirectory = entry.isDirectory();
 
-      // Only include directories, skip files
-      if (isDirectory) {
-        items.push({
-          name: relativePath,
-          value: relativePath,
-        });
-      }
+      // Include both directories and files
+      items.push({
+        name: relativePath,
+        value: relativePath,
+        description: isDirectory ? "📁 Directory" : "📄 File",
+      });
     }
 
-    // Sort alphabetically (all items are directories now)
-    items.sort((a, b) => a.name.localeCompare(b.name));
+    // Sort alphabetically (directories first, then files)
+    items.sort((a, b) => {
+      const aIsDir = a.description === "📁 Directory";
+      const bIsDir = b.description === "📁 Directory";
+
+      if (aIsDir && !bIsDir) return -1;
+      if (!aIsDir && bIsDir) return 1;
+
+      return a.name.localeCompare(b.name);
+    });
 
     return items;
   } catch (error) {
@@ -644,3 +680,78 @@ function getDirectoryContents(dirPath, searchTerm = "") {
     return [];
   }
 }
+
+/**
+ * Get GitHub repository information
+ * @param {string} repoUrl - The repository URL
+ * @returns {Promise<Object>} - Repository information
+ */
+export async function getGitHubRepoInfo(repoUrl) {
+  try {
+    // Extract owner and repo from GitHub URL
+    const match = repoUrl.match(
+      /github\.com[\/:]([^\/]+)\/([^\/]+?)(?:\.git)?$/
+    );
+    if (!match) return null;
+
+    const [, owner, repo] = match;
+    const apiUrl = `https://api.github.com/repos/${owner}/${repo}`;
+
+    const response = await fetch(apiUrl);
+    if (!response.ok) return null;
+
+    const data = await response.json();
+    return {
+      name: data.name,
+      description: data.description || "",
+      icon: data.owner?.avatar_url || "",
+    };
+  } catch (error) {
+    console.warn("Failed to fetch GitHub repository info:", error.message);
+    return null;
+  }
+}
+
+/**
+ * Get project information automatically without user confirmation
+ * @returns {Promise<Object>} - Project information including name, description, icon, and fromGitHub flag
+ */
+export async function getProjectInfo() {
+  let repoInfo = null;
+  let defaultName = path.basename(process.cwd());
+  let defaultDescription = "";
+  let defaultIcon = "";
+  let fromGitHub = false;
+
+  // Check if we're in a git repository
+  try {
+    const gitRemote = execSync("git remote get-url origin", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"],
+    }).trim();
+
+    // Extract repository name from git remote URL
+    const repoName = gitRemote.split("/").pop().replace(".git", "");
+    defaultName = repoName;
+
+    // If it's a GitHub repository, try to get additional info
+    if (gitRemote.includes("github.com")) {
+      repoInfo = await getGitHubRepoInfo(gitRemote);
+      if (repoInfo) {
+        defaultDescription = repoInfo.description;
+        defaultIcon = repoInfo.icon;
+        fromGitHub = true;
+      }
+    }
+  } catch (error) {
+    // Not in git repository or no origin remote, use current directory name
+    console.warn("No git repository found, using current directory name");
+  }
+
+  return {
+    name: defaultName,
+    description: defaultDescription,
+    icon: defaultIcon,
+    fromGitHub,
+  };
+}