hyouji 0.0.5 → 0.0.7

package/README.md

@@ -16,7 +16,8 @@ https://levelup.gitconnected.com/create-github-labels-from-terminal-158d4868fab
 
 ![hyouji_terminal](./hyouji.png)
 
-https://user-images.githubusercontent.com/474225/130368605-b5c6410f-53f6-4ef0-b321-8950edeebf7d.mov
+https://github.com/user-attachments/assets/739f185a-1bd0-411b-8947-dd4600c452c8
+
 
 ### Labels API
 
@@ -76,6 +77,9 @@ hyouji
 On your first run, you'll be prompted to enter:
 
 - **GitHub Personal Token** - Generate one [here](https://github.com/settings/tokens) with `repo` scope
+<img width="792" height="564" alt="github_token" src="https://github.com/user-attachments/assets/e460738f-833a-4158-a8ba-61752beaad72" />
+
+  
 - **GitHub Username** - Your GitHub account name
 
 These credentials will be securely saved and reused for future sessions.

package/dist/index.js

@@ -1,13 +1,15 @@
 #!/usr/bin/env node
-import { Octokit } from "@octokit/core";
 import chalk from "chalk";
-import prompts from "prompts";
 import { renderFilled } from "oh-my-logo";
 import * as fs from "fs";
 import { promises, existsSync } from "fs";
 import { homedir } from "os";
-import { join } from "path";
+import { join, dirname } from "path";
 import { createHash, randomBytes, createCipheriv, createDecipheriv } from "crypto";
+import prompts from "prompts";
+import { Octokit } from "@octokit/core";
+import { exec } from "child_process";
+import { promisify } from "util";
 const githubConfigs = [
   {
     type: "password",
@@ -280,17 +282,34 @@ const createLabels = async (configs2) => {
   log$2("Created all labels");
   log$2(chalk.bgBlueBright(extraGuideText));
 };
-const deleteLabel = (configs2, labelNames) => {
-  labelNames.forEach(async (labelName) => {
-    await configs2.octokit.request(
-      "DELETE /repos/{owner}/{repo}/labels/{name}",
-      {
-        owner: configs2.owner,
-        repo: configs2.repo,
-        name: labelName
+const deleteLabel = async (configs2, labelNames) => {
+  for (const labelName of labelNames) {
+    try {
+      const resp = await configs2.octokit.request(
+        "DELETE /repos/{owner}/{repo}/labels/{name}",
+        {
+          owner: configs2.owner,
+          repo: configs2.repo,
+          name: labelName
+        }
+      );
+      if (resp.status === 204) {
+        log$2(chalk.green(`${resp.status}: Deleted ${labelName}`));
+      } else {
+        log$2(chalk.yellow(`${resp.status}: Something wrong with ${labelName}`));
       }
-    );
-  });
+    } catch (error) {
+      if (error && typeof error === "object" && "status" in error && error.status === 404) {
+        log$2(chalk.red(`404: Label "${labelName}" not found`));
+      } else {
+        log$2(
+          chalk.red(
+            `Error deleting label "${labelName}": ${error instanceof Error ? error.message : "Unknown error"}`
+          )
+        );
+      }
+    }
+  }
 };
 const getLabels = async (configs2) => {
   const resp = await configs2.octokit.request(
@@ -310,18 +329,39 @@ const getLabels = async (configs2) => {
 };
 const deleteLabels = async (configs2) => {
   const names = await getLabels(configs2);
-  names.forEach(async (name) => {
-    await configs2.octokit.request(
-      "DELETE /repos/{owner}/{repo}/labels/{name}",
-      {
-        owner: configs2.owner,
-        repo: configs2.repo,
-        name
+  if (names.length === 0) {
+    log$2(chalk.yellow("No labels found to delete"));
+    return;
+  }
+  log$2(chalk.blue(`Deleting ${names.length} labels...`));
+  for (const name of names) {
+    try {
+      const resp = await configs2.octokit.request(
+        "DELETE /repos/{owner}/{repo}/labels/{name}",
+        {
+          owner: configs2.owner,
+          repo: configs2.repo,
+          name
+        }
+      );
+      if (resp.status === 204) {
+        log$2(chalk.green(`${resp.status}: Deleted ${name}`));
+      } else {
+        log$2(chalk.yellow(`${resp.status}: Something wrong with ${name}`));
       }
-    );
-  });
-  log$2("");
-  names.forEach((label) => log$2(chalk.bgGreen(`deleted ${label}`)));
+    } catch (error) {
+      if (error && typeof error === "object" && "status" in error && error.status === 404) {
+        log$2(chalk.red(`404: Label "${name}" not found`));
+      } else {
+        log$2(
+          chalk.red(
+            `Error deleting label "${name}": ${error instanceof Error ? error.message : "Unknown error"}`
+          )
+        );
+      }
+    }
+  }
+  log$2(chalk.blue("Finished deleting labels"));
   log$2(chalk.bgBlueBright(extraGuideText));
 };
 const _CryptoUtils = class _CryptoUtils {
@@ -1071,6 +1111,177 @@ const getTargetLabel = async () => {
   const response = await prompts(deleteLabel$1);
   return [response.name];
 };
+const execAsync = promisify(exec);
+const GIT_COMMAND_TIMEOUT_MS = 5e3;
+class GitRepositoryDetector {
+  /**
+   * Detects Git repository information from the current working directory
+   * @param cwd - Current working directory (defaults to process.cwd())
+   * @returns Promise<GitDetectionResult>
+   */
+  static async detectRepository(cwd) {
+    const workingDir = cwd || process.cwd();
+    try {
+      const gitRoot = await this.findGitRoot(workingDir);
+      if (!gitRoot) {
+        return {
+          isGitRepository: false,
+          error: "Not a Git repository"
+        };
+      }
+      const remotes = await this.getAllRemotes(gitRoot);
+      if (remotes.length === 0) {
+        return {
+          isGitRepository: true,
+          error: "No remotes configured"
+        };
+      }
+      let remoteUrl = null;
+      let detectionMethod = "origin";
+      if (remotes.includes("origin")) {
+        remoteUrl = await this.getRemoteUrl(gitRoot, "origin");
+      }
+      if (!remoteUrl && remotes.length > 0) {
+        remoteUrl = await this.getRemoteUrl(gitRoot, remotes[0]);
+        detectionMethod = "first-remote";
+      }
+      if (!remoteUrl) {
+        return {
+          isGitRepository: true,
+          error: "Could not retrieve remote URL"
+        };
+      }
+      const parsedUrl = this.parseGitUrl(remoteUrl);
+      if (!parsedUrl) {
+        return {
+          isGitRepository: true,
+          error: "Could not parse remote URL"
+        };
+      }
+      return {
+        isGitRepository: true,
+        repositoryInfo: {
+          owner: parsedUrl.owner,
+          repo: parsedUrl.repo,
+          remoteUrl,
+          detectionMethod
+        }
+      };
+    } catch (err) {
+      return {
+        isGitRepository: false,
+        error: err instanceof Error ? err.message : "Unknown error occurred"
+      };
+    }
+  }
+  /**
+   * Finds the Git root directory by traversing up the directory tree
+   * @param startPath - Starting directory path
+   * @returns Promise<string | null> - Git root path or null if not found
+   */
+  static async findGitRoot(startPath) {
+    let currentPath = startPath;
+    while (currentPath !== dirname(currentPath)) {
+      const gitPath = join(currentPath, ".git");
+      if (existsSync(gitPath)) {
+        return currentPath;
+      }
+      currentPath = dirname(currentPath);
+    }
+    return null;
+  }
+  /**
+   * Gets the URL for a specific Git remote
+   * @param gitRoot - Git repository root directory
+   * @param remoteName - Name of the remote (e.g., 'origin')
+   * @returns Promise<string | null> - Remote URL or null if not found
+   */
+  static async getRemoteUrl(gitRoot, remoteName) {
+    try {
+      const { stdout } = await execAsync(`git remote get-url ${remoteName}`, {
+        cwd: gitRoot,
+        timeout: GIT_COMMAND_TIMEOUT_MS
+      });
+      return stdout.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Parses a Git URL to extract owner and repository name
+   * @param url - Git remote URL
+   * @returns Object with owner and repo or null if parsing fails
+   */
+  static parseGitUrl(url) {
+    if (!url || typeof url !== "string" || url.trim().length === 0) {
+      return null;
+    }
+    const trimmedUrl = url.trim();
+    try {
+      const sshMatch = trimmedUrl.match(
+        /^git@github\.com:([^/\s:]+)\/([^/\s:]+?)(?:\.git)?$/
+      );
+      if (sshMatch) {
+        const owner = sshMatch[1];
+        const repo = sshMatch[2];
+        if (this.isValidGitHubIdentifier(owner) && this.isValidGitHubIdentifier(repo)) {
+          return { owner, repo };
+        }
+      }
+      const httpsMatch = trimmedUrl.match(
+        /^https:\/\/github\.com\/([^/\s]+)\/([^/\s]+?)(?:\.git)?(?:\/)?$/
+      );
+      if (httpsMatch) {
+        const owner = httpsMatch[1];
+        const repo = httpsMatch[2];
+        if (this.isValidGitHubIdentifier(owner) && this.isValidGitHubIdentifier(repo)) {
+          return { owner, repo };
+        }
+      }
+      const httpMatch = trimmedUrl.match(
+        /^http:\/\/github\.com\/([^/\s]+)\/([^/\s]+?)(?:\.git)?(?:\/)?$/
+      );
+      if (httpMatch) {
+        const owner = httpMatch[1];
+        const repo = httpMatch[2];
+        if (this.isValidGitHubIdentifier(owner) && this.isValidGitHubIdentifier(repo)) {
+          return { owner, repo };
+        }
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+  /**
+   * Validates if a string is a valid GitHub identifier (username or repository name)
+   * @param identifier - The identifier to validate
+   * @returns boolean - True if valid, false otherwise
+   */
+  static isValidGitHubIdentifier(identifier) {
+    if (!identifier || typeof identifier !== "string") {
+      return false;
+    }
+    const GITHUB_IDENTIFIER_REGEX = /^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/;
+    return identifier.length >= 1 && identifier.length <= 39 && GITHUB_IDENTIFIER_REGEX.test(identifier) && !identifier.includes("--");
+  }
+  /**
+   * Gets all configured Git remotes
+   * @param gitRoot - Git repository root directory
+   * @returns Promise<string[]> - Array of remote names
+   */
+  static async getAllRemotes(gitRoot) {
+    try {
+      const { stdout } = await execAsync("git remote", {
+        cwd: gitRoot,
+        timeout: GIT_COMMAND_TIMEOUT_MS
+      });
+      return stdout.trim().split("\n").filter((remote) => remote.length > 0);
+    } catch {
+      return [];
+    }
+  }
+}
 const getGitHubConfigs = async () => {
   var _a, _b;
   const configManager2 = new ConfigManager();
@@ -1092,6 +1303,50 @@ const getGitHubConfigs = async () => {
     };
   }
   if (validationResult.config && !validationResult.shouldPromptForCredentials) {
+    try {
+      const detectionResult = await GitRepositoryDetector.detectRepository();
+      if (detectionResult.isGitRepository && detectionResult.repositoryInfo) {
+        console.log(
+          chalk.green(
+            `✓ Detected repository: ${detectionResult.repositoryInfo.owner}/${detectionResult.repositoryInfo.repo}`
+          )
+        );
+        console.log(
+          chalk.gray(
+            `  Detection method: ${detectionResult.repositoryInfo.detectionMethod === "origin" ? "origin remote" : "first available remote"}`
+          )
+        );
+        const octokit3 = new Octokit({
+          auth: validationResult.config.token
+        });
+        return {
+          octokit: octokit3,
+          owner: detectionResult.repositoryInfo.owner,
+          repo: detectionResult.repositoryInfo.repo,
+          fromSavedConfig: true,
+          autoDetected: true,
+          detectionMethod: detectionResult.repositoryInfo.detectionMethod
+        };
+      } else {
+        if (detectionResult.error) {
+          console.log(
+            chalk.yellow(
+              `⚠️  Repository auto-detection failed: ${detectionResult.error}`
+            )
+          );
+        }
+        console.log(chalk.gray("  Falling back to manual input..."));
+      }
+    } catch (error) {
+      console.log(
+        chalk.yellow(
+          "⚠️  Repository auto-detection failed, falling back to manual input"
+        )
+      );
+      if (error instanceof Error) {
+        console.log(chalk.gray(`  Error: ${error.message}`));
+      }
+    }
     const repoResponse = await prompts([
       {
         type: "text",
@@ -1106,7 +1361,9 @@ const getGitHubConfigs = async () => {
       octokit: octokit2,
       owner: validationResult.config.owner,
       repo: repoResponse.repo,
-      fromSavedConfig: true
+      fromSavedConfig: true,
+      autoDetected: false,
+      detectionMethod: "manual"
     };
   }
   const promptConfig = [...githubConfigs];
@@ -1158,7 +1415,9 @@ const getGitHubConfigs = async () => {
     octokit,
     owner: response.owner,
     repo: response.repo,
-    fromSavedConfig: false
+    fromSavedConfig: false,
+    autoDetected: false,
+    detectionMethod: "manual"
   };
 };
 const getJsonFilePath = async () => {
@@ -1177,33 +1436,6 @@ const selectAction = async () => {
 const log = console.log;
 let firstStart = true;
 const configManager = new ConfigManager();
-const setupConfigs = async () => {
-  console.log(initialText);
-  if (firstStart) {
-    await configManager.migrateToEncrypted();
-  }
-  const config = await getGitHubConfigs();
-  if (!config.octokit || !config.owner || !config.repo) {
-    throw new Error("Invalid configuration: missing required fields");
-  }
-  try {
-    await config.octokit.request("GET /user");
-  } catch (error) {
-    if (config.fromSavedConfig) {
-      console.log(
-        chalk.yellow(
-          "Saved credentials are invalid. Please provide new credentials."
-        )
-      );
-      await configManager.clearConfig();
-      return setupConfigs();
-    }
-    throw new Error(
-      `GitHub API authentication failed: ${error instanceof Error ? error.message : "Unknown error"}`
-    );
-  }
-  return config;
-};
 const displaySettings = async () => {
   log(chalk.cyan("\n=== Current Settings ==="));
   const configPath = configManager.getConfigPath();
@@ -1247,9 +1479,9 @@ const displaySettings = async () => {
   log(chalk.cyan("========================\n"));
 };
 let configs;
-const main = async () => {
+const initializeConfigs = async () => {
   let hasValidConfig = false;
-  if (firstStart && configManager.configExists()) {
+  if (configManager.configExists()) {
     try {
       const existingConfig = await configManager.loadValidatedConfig();
       if (existingConfig && existingConfig.config && !existingConfig.shouldPromptForCredentials) {
@@ -1268,58 +1500,75 @@ const main = async () => {
           `Please go to ${linkToPersonalToken} and generate a personal token!`
         )
       );
-      return;
+      return null;
     }
   }
-  if (firstStart) {
+  try {
+    const asciiText = await getAsciiText();
+    if (asciiText != null) {
+      log(asciiText);
+    }
+  } catch (error) {
+    console.warn("Failed to display ASCII art, continuing...");
+    console.error("Error:", error);
+  }
+  try {
+    console.log(initialText);
+    if (firstStart) {
+      await configManager.migrateToEncrypted();
+    }
+    const config = await getGitHubConfigs();
+    if (!config.octokit || !config.owner || !config.repo) {
+      throw new Error("Invalid configuration: missing required fields");
+    }
     try {
-      const asciiText = await getAsciiText();
-      if (asciiText != null) {
-        log(asciiText);
-      }
+      await config.octokit.request("GET /user");
     } catch (error) {
-      console.warn("Failed to display ASCII art, continuing...");
-      console.error("Error:", error);
-    }
-    if (hasValidConfig) {
-      try {
-        const existingConfig = await configManager.loadValidatedConfig();
-        if (existingConfig && existingConfig.config) {
-          const repoResponse = await prompts([
-            {
-              type: "text",
-              name: "repo",
-              message: "Please type your target repo name"
-            }
-          ]);
-          configs = {
-            octokit: new Octokit({ auth: existingConfig.config.token }),
-            owner: existingConfig.config.owner,
-            repo: repoResponse.repo,
-            fromSavedConfig: true
-          };
-          log(chalk.green(`Using saved configuration for ${configs.owner}`));
-        } else {
-          configs = await setupConfigs();
-        }
-      } catch (error) {
-        console.error("Error:", error);
-        configs = await setupConfigs();
-      }
-    } else {
-      try {
-        configs = await setupConfigs();
-        if (configs.fromSavedConfig) {
-          log(chalk.green(`Using saved configuration for ${configs.owner}`));
-        }
-      } catch (error) {
-        log(
-          chalk.red(
-            `Configuration error: ${error instanceof Error ? error.message : "Unknown error"}`
+      if (config.fromSavedConfig) {
+        console.log(
+          chalk.yellow(
+            "Saved credentials are invalid. Please provide new credentials."
           )
         );
-        return;
+        await configManager.clearConfig();
+        return initializeConfigs();
       }
+      throw new Error(
+        `GitHub API authentication failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+    if (config.fromSavedConfig) {
+      log(chalk.green(`✓ Using saved configuration for ${config.owner}`));
+    }
+    if (config.autoDetected) {
+      log(
+        chalk.green(
+          `✓ Repository auto-detected: ${config.owner}/${config.repo}`
+        )
+      );
+      const detectionMethodText = config.detectionMethod === "origin" ? "origin remote" : config.detectionMethod === "first-remote" ? "first available remote" : "manual input";
+      log(chalk.gray(`  Detection method: ${detectionMethodText}`));
+    } else if (config.detectionMethod === "manual") {
+      log(
+        chalk.blue(`✓ Repository configured: ${config.owner}/${config.repo}`)
+      );
+      log(chalk.gray(`  Input method: manual`));
+    }
+    return config;
+  } catch (error) {
+    log(
+      chalk.red(
+        `Configuration error: ${error instanceof Error ? error.message : "Unknown error"}`
+      )
+    );
+    return null;
+  }
+};
+const main = async () => {
+  if (firstStart) {
+    configs = await initializeConfigs();
+    if (!configs) {
+      return;
     }
   }
   let selectedIndex = await selectAction();
@@ -1329,23 +1578,23 @@ const main = async () => {
   switch (selectedIndex) {
     case 0: {
       const newLabel2 = await getNewLabel();
-      createLabel(configs, newLabel2);
+      await createLabel(configs, newLabel2);
       firstStart = firstStart && false;
       break;
     }
     case 1: {
-      createLabels(configs);
+      await createLabels(configs);
       firstStart = firstStart && false;
       break;
     }
     case 2: {
       const targetLabel = await getTargetLabel();
-      deleteLabel(configs, targetLabel);
+      await deleteLabel(configs, targetLabel);
       firstStart = firstStart && false;
       break;
     }
     case 3: {
-      deleteLabels(configs);
+      await deleteLabels(configs);
       firstStart = firstStart && false;
       break;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hyouji",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Hyouji (表示) — A command-line tool for organizing and displaying GitHub labels with clarity and harmony.",
   "main": "dist/index.js",
   "bin": {
@@ -35,6 +35,12 @@
     "test:coverage": "vitest run --coverage",
     "test:lint": "eslint src --ext .ts",
     "test:prettier": "prettier \"src/**/*.ts\" --list-different",
+    "test:error-handling": "node tests/scripts/error-handling/run-all.cjs",
+    "test:config": "node tests/scripts/config/run-all.cjs",
+    "test:integration": "node tests/scripts/run-integration.cjs",
+    "test:auto-detection": "node tests/integration/auto-detection/integration-flow.cjs",
+    "test:verification": "node tests/scripts/verification/run-all.cjs",
+    "test:all-custom": "npm run test:error-handling && npm run test:config && npm run test:integration && npm run test:verification",
     "check-cli": "run-s test diff-integration-tests check-integration-tests",
     "check-integration-tests": "run-s check-integration-test:*",
     "diff-integration-tests": "mkdir -p diff && rm -rf diff/test && cp -r test diff/test && rm -rf diff/test/test-*/.git && cd diff && git init --quiet && git add -A && git commit --quiet --no-verify --allow-empty -m 'WIP' && echo '\\n\\nCommitted most recent integration test output in the \"diff\" directory. Review the changes with \"cd diff && git diff HEAD\" or your preferred git diff viewer.'",