@rhseung/ps-cli 1.10.2 → 1.11.0

package/dist/chunk-NQ267PM5.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+import {
+  getUserProblemStats,
+  getUserStats,
+  getUserTagRatings,
+  getUserTop100,
+  scrapeUserStats
+} from "./chunk-S7IL7OXF.js";
+import {
+  findProjectRoot,
+  getArchiveDir,
+  getSolvingDir
+} from "./chunk-AHE4QHJD.js";
+
+// src/hooks/use-user-stats.ts
+import { existsSync } from "fs";
+import { readdir, stat } from "fs/promises";
+import { join } from "path";
+import { useEffect, useState } from "react";
+async function countProblems(dir) {
+  let count = 0;
+  try {
+    if (!existsSync(dir)) return 0;
+    const entries = await readdir(dir);
+    for (const entry of entries) {
+      if (entry.startsWith(".")) continue;
+      const fullPath = join(dir, entry);
+      const s = await stat(fullPath);
+      if (s.isDirectory()) {
+        if (existsSync(join(fullPath, "meta.json"))) {
+          count++;
+        } else {
+          count += await countProblems(fullPath);
+        }
+      }
+    }
+  } catch {
+  }
+  return count;
+}
+function useUserStats({
+  handle,
+  onComplete,
+  fetchLocalCount = false
+}) {
+  const [status, setStatus] = useState(
+    "loading"
+  );
+  const [user, setUser] = useState(null);
+  const [top100, setTop100] = useState(null);
+  const [problemStats, setProblemStats] = useState(null);
+  const [tagRatings, setTagRatings] = useState(
+    null
+  );
+  const [bojStats, setBojStats] = useState(null);
+  const [localSolvedCount, setLocalSolvedCount] = useState(null);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    async function fetchData() {
+      try {
+        const userData = await getUserStats(handle).catch((err) => {
+          if (err instanceof Error && err.message.includes("404")) {
+            throw new Error(`\uC0AC\uC6A9\uC790 '${handle}'\uC744(\uB97C) \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.`);
+          }
+          throw err;
+        });
+        if (!userData) {
+          throw new Error(`\uC0AC\uC6A9\uC790 '${handle}'\uC744(\uB97C) \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.`);
+        }
+        setUser(userData);
+        const [top100Data, problemStatsData, tagRatingsData, bojStatsData] = await Promise.all([
+          getUserTop100(handle).catch((err) => {
+            console.error("Error fetching top 100:", err);
+            return null;
+          }),
+          getUserProblemStats(handle).catch((err) => {
+            console.error("Error fetching problem stats:", err);
+            return null;
+          }),
+          getUserTagRatings(handle).catch((err) => {
+            console.error("Error fetching tag ratings:", err);
+            return null;
+          }),
+          scrapeUserStats(handle).catch((err) => {
+            console.error("Error scraping BOJ stats:", err);
+            return null;
+          })
+        ]);
+        setTop100(top100Data);
+        setProblemStats(problemStatsData);
+        setTagRatings(tagRatingsData);
+        setBojStats(bojStatsData);
+        if (fetchLocalCount) {
+          const projectRoot = findProjectRoot();
+          if (projectRoot) {
+            const archiveDir = getArchiveDir();
+            const solvingDir = getSolvingDir();
+            const archivePath = join(projectRoot, archiveDir);
+            const solvingPath = join(projectRoot, solvingDir);
+            const [archiveCount, solvingCount] = await Promise.all([
+              countProblems(archivePath),
+              countProblems(solvingPath)
+            ]);
+            setLocalSolvedCount(archiveCount + solvingCount);
+          }
+        }
+        setStatus("success");
+        setTimeout(() => {
+          onComplete();
+        }, 5e3);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        setStatus("error");
+        setTimeout(() => {
+          onComplete();
+        }, 3e3);
+      }
+    }
+    void fetchData();
+  }, [fetchLocalCount, handle, onComplete]);
+  return {
+    status,
+    user,
+    top100,
+    problemStats,
+    tagRatings,
+    bojStats,
+    localSolvedCount,
+    error
+  };
+}
+
+export {
+  useUserStats
+};

package/dist/chunk-QT2FQELR.js

@@ -0,0 +1,427 @@
+#!/usr/bin/env node
+import {
+  getArchiveDir,
+  getArchiveStrategy,
+  getAutoOpenEditor,
+  getConfigMetadata,
+  getDefaultLanguage,
+  getEditor,
+  getIncludeTag,
+  getSolvedAcHandle,
+  getSolvingDir
+} from "./chunk-AHE4QHJD.js";
+
+// src/hooks/use-init.ts
+import { existsSync } from "fs";
+import {
+  mkdir,
+  readFile,
+  writeFile,
+  access,
+  copyFile,
+  readdir
+} from "fs/promises";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { execaCommand, execa } from "execa";
+import { useEffect, useState, useCallback } from "react";
+function getCliRoot() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  let current = __dirname;
+  while (current !== dirname(current)) {
+    const templatesDir = join(current, "templates");
+    try {
+      const stats = existsSync(templatesDir);
+      if (stats) return current;
+    } catch {
+    }
+    current = dirname(current);
+  }
+  return join(__dirname, "../..");
+}
+function buildDefaultConfigYaml({
+  language,
+  editor,
+  autoOpen,
+  solvingDir,
+  archiveDir,
+  archiveStrategy,
+  includeTag,
+  handle
+}) {
+  return `
+# ps-cli \uC124\uC815 \uD30C\uC77C
+# \uB354 \uC790\uC138\uD55C \uC815\uBCF4\uB294 \uB2E4\uC74C\uC744 \uCC38\uACE0\uD558\uC138\uC694: https://github.com/rhseung/ps-cli
+
+general:
+  # \uC0C8\uB85C\uC6B4 \uBB38\uC81C\uB97C \uAC00\uC838\uC62C \uB54C \uC0AC\uC6A9\uD560 \uAE30\uBCF8 \uD504\uB85C\uADF8\uB798\uBC0D \uC5B8\uC5B4\uC785\uB2C8\uB2E4.
+  default_language: ${language}
+  # \uD1B5\uACC4 \uC870\uD68C\uB97C \uC704\uD55C Solved.ac \uD578\uB4E4(\uB2C9\uB124\uC784)\uC785\uB2C8\uB2E4.
+  solved_ac_handle: "${handle}"
+
+editor:
+  # \uC5D0\uB514\uD130\uB97C \uC5F4 \uB54C \uC0AC\uC6A9\uD560 \uBA85\uB839\uC5B4\uC785\uB2C8\uB2E4 (\uC608: code, cursor, vim).
+  command: ${editor}
+  # \uBB38\uC81C\uB97C \uAC00\uC838\uC628 \uD6C4 \uC790\uB3D9\uC73C\uB85C \uC5D0\uB514\uD130\uB97C \uC5F4\uC9C0 \uC5EC\uBD80\uC785\uB2C8\uB2E4.
+  auto_open: ${autoOpen}
+
+paths:
+  # \uD604\uC7AC \uD480\uACE0 \uC788\uB294 \uBB38\uC81C\uB4E4\uC744 \uB2F4\uC744 \uB514\uB809\uD1A0\uB9AC \uACBD\uB85C\uC785\uB2C8\uB2E4.
+  solving: ${solvingDir}
+  # \uD574\uACB0\uD55C \uBB38\uC81C\uB97C \uBCF4\uAD00\uD560 \uB514\uB809\uD1A0\uB9AC \uACBD\uB85C\uC785\uB2C8\uB2E4.
+  archive: ${archiveDir}
+  # \uC544\uCE74\uC774\uBE59 \uC804\uB7B5\uC785\uB2C8\uB2E4 (flat, by-range, by-tier, by-tag).
+  archive_strategy: ${archiveStrategy}
+
+archive:
+  # \uC544\uCE74\uC774\uBE0C \uC2DC \uC790\uB3D9\uC73C\uB85C Git \uCEE4\uBC0B\uC744 \uC218\uD589\uD560\uC9C0 \uC5EC\uBD80\uC785\uB2C8\uB2E4.
+  auto_commit: true
+  # Git \uCEE4\uBC0B \uBA54\uC2DC\uC9C0 \uD15C\uD50C\uB9BF\uC785\uB2C8\uB2E4 ({id}, {title} \uC0AC\uC6A9 \uAC00\uB2A5).
+  commit_message: "feat: solve {id} {title}"
+
+markdown:
+  # \uBB38\uC81C README\uC5D0 \uC54C\uACE0\uB9AC\uC998 \uBD84\uB958(\uD0DC\uADF8)\uB97C \uD3EC\uD568\uD560\uC9C0 \uC5EC\uBD80\uC785\uB2C8\uB2E4.
+  include_tag: ${includeTag}
+
+# \uC5B8\uC5B4\uBCC4 \uC124\uC815
+# \uC774\uACF3\uC5D0\uC11C \uCEF4\uD30C\uC77C/\uC2E4\uD589 \uBA85\uB839\uC5B4\uB098 \uD15C\uD50C\uB9BF \uD30C\uC77C\uBA85\uC744 \uC218\uC815\uD558\uAC70\uB098 \uC0C8\uB85C\uC6B4 \uC5B8\uC5B4\uB97C \uCD94\uAC00\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.
+languages:
+  python:
+    extension: py
+    # \uD15C\uD50C\uB9BF \uD30C\uC77C\uBA85 (\uC635\uC158, \uAE30\uBCF8\uAC12: solution.py)
+    template_file: "solution.py"
+    # \uC2E4\uD589 \uBA85\uB839\uC5B4 (\uD544\uC218)
+    run: python3
+  cpp:
+    extension: cpp
+    # \uD15C\uD50C\uB9BF \uD30C\uC77C\uBA85 (\uC635\uC158, \uAE30\uBCF8\uAC12: solution.cpp)
+    template_file: "solution.cpp"
+    # \uCEF4\uD30C\uC77C \uBA85\uB839\uC5B4 (\uC635\uC158)
+    compile: "g++ -fdiagnostics-absolute-paths -o solution solution.cpp"
+    # \uC2E4\uD589 \uBA85\uB839\uC5B4 (\uD544\uC218)
+    run: "./solution"
+  #   rust:
+  #     extension: rs
+  #     # \uD15C\uD50C\uB9BF \uD30C\uC77C\uBA85\uC744 \uC9C1\uC811 \uC9C0\uC815\uD558\uB824\uBA74 template_file\uC744 \uC0AC\uC6A9\uD558\uC138\uC694 (\uAE30\uBCF8: solution.{extension})
+  #     template_file: "solution.rs"
+  #     compile: "rustc {file}"
+  #     run: "./{file_no_ext}"
+`.trim();
+}
+function useInit({ onComplete }) {
+  const [currentStep, setCurrentStep] = useState("archive-dir");
+  const [completedSteps, setCompletedSteps] = useState([]);
+  const [confirmExit, setConfirmExit] = useState(false);
+  const [initialized, setInitialized] = useState(false);
+  const [form, setForm] = useState({
+    archiveDir: getArchiveDir(),
+    solvingDir: getSolvingDir(),
+    archiveStrategy: getArchiveStrategy(),
+    language: getDefaultLanguage(),
+    editor: getEditor(),
+    autoOpen: getAutoOpenEditor(),
+    includeTag: getIncludeTag(),
+    handle: getSolvedAcHandle() || ""
+  });
+  const [handleInputMode, setHandleInputMode] = useState(false);
+  const [created, setCreated] = useState([]);
+  const [cancelled, setCancelled] = useState(false);
+  useEffect(() => {
+    const handleSigInt = () => {
+      if (confirmExit) {
+        setCancelled(true);
+        setCurrentStep("cancelled");
+        setTimeout(() => {
+          onComplete();
+        }, 500);
+        return;
+      }
+      setConfirmExit(true);
+    };
+    process.on("SIGINT", handleSigInt);
+    return () => {
+      process.off("SIGINT", handleSigInt);
+    };
+  }, [confirmExit, onComplete]);
+  useEffect(() => {
+    async function loadProjectConfig() {
+      try {
+        const cwd = process.cwd();
+        const projectConfigPath = join(cwd, ".ps-cli.json");
+        await access(projectConfigPath);
+        const configContent = await readFile(projectConfigPath, "utf-8");
+        const projectConfig = JSON.parse(configContent);
+        setForm((prev) => ({
+          ...prev,
+          archiveDir: projectConfig.archiveDir ?? prev.archiveDir,
+          solvingDir: projectConfig.solvingDir ?? prev.solvingDir,
+          archiveStrategy: projectConfig.archiveStrategy ?? prev.archiveStrategy,
+          language: projectConfig.defaultLanguage ?? prev.language,
+          editor: projectConfig.editor ?? prev.editor,
+          autoOpen: projectConfig.autoOpenEditor !== void 0 ? projectConfig.autoOpenEditor : prev.autoOpen,
+          includeTag: projectConfig.includeTag !== void 0 ? projectConfig.includeTag : prev.includeTag,
+          handle: projectConfig.solvedAcHandle ?? prev.handle
+        }));
+      } catch {
+      } finally {
+        setInitialized(true);
+      }
+    }
+    void loadProjectConfig();
+  }, []);
+  const getStepLabel = useCallback((step) => {
+    const stepToConfigKey = {
+      "archive-dir": "paths.archive",
+      "solving-dir": "paths.solving",
+      "archive-strategy": "paths.archive-strategy",
+      language: "general.default-language",
+      editor: "editor.command",
+      "auto-open": "editor.auto-open",
+      "include-tag": "markdown.include-tag",
+      handle: "general.solved-ac-handle"
+    };
+    const configKey = stepToConfigKey[step];
+    if (!configKey) return "";
+    const meta = getConfigMetadata().find((m) => m.key === configKey);
+    return meta?.label ?? "";
+  }, []);
+  const getStepValue = useCallback(
+    (step) => {
+      switch (step) {
+        case "archive-dir":
+          return form.archiveDir === "." ? "\uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8" : form.archiveDir;
+        case "solving-dir":
+          return form.solvingDir === "." ? "\uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8" : form.solvingDir;
+        case "archive-strategy": {
+          const strategyLabels = {
+            flat: "\uD3C9\uBA74 (\uC804\uBD80 \uB098\uC5F4)",
+            "by-range": "1000\uBC88\uB300 \uBB36\uAE30",
+            "by-tier": "\uD2F0\uC5B4\uBCC4",
+            "by-tag": "\uD0DC\uADF8\uBCC4"
+          };
+          return strategyLabels[form.archiveStrategy] || form.archiveStrategy;
+        }
+        case "language":
+          return form.language;
+        case "editor":
+          return form.editor;
+        case "auto-open":
+          return form.autoOpen ? "\uC608" : "\uC544\uB2C8\uC624";
+        case "include-tag":
+          return form.includeTag ? "\uC608" : "\uC544\uB2C8\uC624";
+        case "handle":
+          return form.handle || "(\uC2A4\uD0B5)";
+        default:
+          return "";
+      }
+    },
+    [form]
+  );
+  const executeInit = useCallback(
+    async (overrideHandle) => {
+      try {
+        const cwd = process.cwd();
+        const cliRoot = getCliRoot();
+        const psCliDir = join(cwd, ".ps-cli");
+        const templatesDir = join(psCliDir, "templates");
+        await mkdir(psCliDir, { recursive: true });
+        await mkdir(templatesDir, { recursive: true });
+        setCreated((prev) => [...prev, ".ps-cli/"]);
+        const handleToUse = (overrideHandle ?? form.handle)?.trim() || "";
+        const configYaml = buildDefaultConfigYaml({
+          language: form.language,
+          editor: form.editor,
+          autoOpen: form.autoOpen,
+          solvingDir: form.solvingDir,
+          archiveDir: form.archiveDir,
+          archiveStrategy: form.archiveStrategy,
+          includeTag: form.includeTag,
+          handle: handleToUse
+        });
+        await writeFile(join(psCliDir, "config.yaml"), configYaml, "utf-8");
+        setCreated((prev) => [...prev, ".ps-cli/config.yaml"]);
+        const defaultTemplatesDir = join(cliRoot, "templates");
+        if (existsSync(defaultTemplatesDir)) {
+          const files = await readdir(defaultTemplatesDir);
+          for (const file of files) {
+            await copyFile(
+              join(defaultTemplatesDir, file),
+              join(templatesDir, file)
+            );
+          }
+          setCreated((prev) => [
+            ...prev,
+            ".ps-cli/templates/ (\uAE30\uBCF8 \uD15C\uD50C\uB9BF \uBCF5\uC0AC)"
+          ]);
+        }
+        if (form.archiveDir !== "." && form.archiveDir !== "") {
+          const archiveDirPath = join(cwd, form.archiveDir);
+          try {
+            await mkdir(archiveDirPath, { recursive: true });
+            setCreated((prev) => [...prev, `${form.archiveDir}/`]);
+          } catch (err) {
+            const error = err;
+            if (error.code !== "EEXIST") {
+              throw err;
+            }
+          }
+        }
+        if (form.solvingDir !== "." && form.solvingDir !== "") {
+          const solvingDirPath = join(cwd, form.solvingDir);
+          try {
+            await mkdir(solvingDirPath, { recursive: true });
+            setCreated((prev) => [...prev, `${form.solvingDir}/`]);
+          } catch (err) {
+            const error = err;
+            if (error.code !== "EEXIST") {
+              throw err;
+            }
+          }
+        }
+        const gitignorePath = join(cwd, ".gitignore");
+        const gitignorePatterns = [];
+        if (form.solvingDir !== "." && form.solvingDir !== "") {
+          gitignorePatterns.push(`${form.solvingDir}/`);
+        }
+        if (gitignorePatterns.length > 0) {
+          try {
+            const gitignoreContent = await readFile(gitignorePath, "utf-8");
+            let updatedContent = gitignoreContent.trim();
+            let hasChanges = false;
+            for (const pattern of gitignorePatterns) {
+              if (!gitignoreContent.includes(pattern)) {
+                updatedContent += (updatedContent ? "\n" : "") + `
+# ps-cli \uBB38\uC81C \uB514\uB809\uD1A0\uB9AC
+${pattern}`;
+                hasChanges = true;
+              }
+            }
+            if (hasChanges) {
+              await writeFile(gitignorePath, updatedContent + "\n", "utf-8");
+              setCreated((prev) => [...prev, ".gitignore \uC5C5\uB370\uC774\uD2B8"]);
+            }
+          } catch (err) {
+            const error = err;
+            if (error.code === "ENOENT") {
+              const content = `# ps-cli \uBB38\uC81C \uB514\uB809\uD1A0\uB9AC
+${gitignorePatterns.join("\n")}
+`;
+              await writeFile(gitignorePath, content, "utf-8");
+              setCreated((prev) => [...prev, ".gitignore \uC0DD\uC131"]);
+            } else {
+              console.warn(".gitignore \uC5C5\uB370\uC774\uD2B8 \uC2E4\uD328:", error.message);
+            }
+          }
+        }
+        try {
+          const gitDir = join(cwd, ".git");
+          let isGitRepo = false;
+          try {
+            await access(gitDir);
+            isGitRepo = true;
+          } catch {
+          }
+          if (!isGitRepo) {
+            await execaCommand("git init", { cwd });
+            setCreated((prev) => [...prev, "Git \uC800\uC7A5\uC18C \uCD08\uAE30\uD654"]);
+          }
+          const filesToAdd = [".ps-cli"];
+          try {
+            await access(gitignorePath);
+            filesToAdd.push(".gitignore");
+          } catch {
+          }
+          if (filesToAdd.length > 0) {
+            await execa("git", ["add", ...filesToAdd], { cwd });
+            try {
+              await execa("git", ["rev-parse", "--verify", "HEAD"], { cwd });
+            } catch {
+              await execa(
+                "git",
+                ["commit", "-m", "chore: ps-cli \uD504\uB85C\uC81D\uD2B8 \uCD08\uAE30\uD654"],
+                { cwd }
+              );
+              setCreated((prev) => [...prev, "\uCD08\uAE30 \uCEE4\uBC0B \uC0DD\uC131"]);
+            }
+          }
+        } catch (err) {
+          const error = err;
+          console.warn("Git \uC5F0\uB3D9 \uC2E4\uD328:", error.message);
+        }
+        setTimeout(() => {
+          onComplete();
+        }, 3e3);
+      } catch (err) {
+        const error = err;
+        console.error("\uCD08\uAE30\uD654 \uC911 \uC624\uB958 \uBC1C\uC0DD:", error.message);
+        setCancelled(true);
+        setCurrentStep("cancelled");
+        setTimeout(() => {
+          onComplete();
+        }, 2e3);
+      }
+    },
+    [form, onComplete]
+  );
+  const moveToNextStep = useCallback(
+    (selectedValue, stepLabel, handleValue) => {
+      setCompletedSteps((prev) => [
+        ...prev,
+        { label: stepLabel, value: selectedValue }
+      ]);
+      if (currentStep === "handle" && handleValue !== void 0) {
+        setForm((prev) => ({
+          ...prev,
+          handle: handleValue
+        }));
+      }
+      const stepOrder = [
+        "archive-dir",
+        "solving-dir",
+        "archive-strategy",
+        "language",
+        "editor",
+        "auto-open",
+        "include-tag",
+        "handle",
+        "done"
+      ];
+      const currentIndex = stepOrder.indexOf(currentStep);
+      if (currentIndex < stepOrder.length - 1) {
+        const nextStep = stepOrder[currentIndex + 1];
+        setCurrentStep(nextStep);
+        if (nextStep === "done") {
+          if (currentStep === "handle" && handleValue !== void 0) {
+            void executeInit(handleValue.trim());
+          } else {
+            void executeInit();
+          }
+        }
+      }
+    },
+    [currentStep, executeInit]
+  );
+  return {
+    currentStep,
+    completedSteps,
+    confirmExit,
+    initialized,
+    form,
+    handleInputMode,
+    created,
+    cancelled,
+    setForm,
+    setHandleInputMode,
+    setConfirmExit,
+    setCurrentStep,
+    setCancelled,
+    moveToNextStep,
+    getStepLabel,
+    getStepValue
+  };
+}
+
+export {
+  useInit
+};

package/dist/chunk-XNZBOLC2.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+import {
+  findProjectRoot,
+  getConfigMetadata
+} from "./chunk-AHE4QHJD.js";
+
+// src/hooks/use-config.ts
+import { existsSync, mkdirSync } from "fs";
+import { readFile, writeFile, unlink, rm } from "fs/promises";
+import { join } from "path";
+import { useEffect, useState } from "react";
+import { parse, stringify } from "yaml";
+function getProjectConfigPath() {
+  const root = findProjectRoot();
+  if (!root) return null;
+  return join(root, ".ps-cli", "config.yaml");
+}
+async function readProjectConfig() {
+  const configPath = getProjectConfigPath();
+  if (!configPath || !existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const content = await readFile(configPath, "utf-8");
+    return parse(content);
+  } catch {
+    return null;
+  }
+}
+async function writeProjectConfig(config) {
+  const configPath = getProjectConfigPath();
+  if (!configPath) {
+    const root = process.cwd();
+    const psCliDir = join(root, ".ps-cli");
+    if (!existsSync(psCliDir)) {
+      mkdirSync(psCliDir, { recursive: true });
+    }
+    const newConfigPath = join(psCliDir, "config.yaml");
+    await writeFile(newConfigPath, stringify(config), "utf-8");
+    return;
+  }
+  await writeFile(configPath, stringify(config), "utf-8");
+}
+function setDeep(obj, path, value) {
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+}
+function useConfig({
+  configKey,
+  value,
+  get: _get,
+  list: _list,
+  clear,
+  onComplete: _onComplete
+}) {
+  const [config, setConfig] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [cleared, setCleared] = useState(false);
+  const [saved, setSaved] = useState(false);
+  useEffect(() => {
+    async function loadConfig() {
+      const projectConfig = await readProjectConfig();
+      setConfig(projectConfig);
+      setLoading(false);
+    }
+    void loadConfig();
+  }, []);
+  useEffect(() => {
+    if (clear && !cleared) {
+      void (async () => {
+        const root = findProjectRoot();
+        if (root) {
+          const psCliDir = join(root, ".ps-cli");
+          if (existsSync(psCliDir)) {
+            await rm(psCliDir, { recursive: true, force: true });
+          }
+          const legacyPath = join(root, ".ps-cli.json");
+          if (existsSync(legacyPath)) {
+            await unlink(legacyPath);
+          }
+        }
+        setCleared(true);
+      })();
+    }
+  }, [clear, cleared]);
+  useEffect(() => {
+    if (configKey && value !== void 0 && !saved) {
+      void (async () => {
+        const currentConfig = await readProjectConfig() ?? {};
+        const updatedConfig = { ...currentConfig };
+        const metadata = getConfigMetadata();
+        const item = metadata.find((m) => m.key === configKey);
+        if (!item) {
+          console.error(`\uC54C \uC218 \uC5C6\uB294 \uC124\uC815 \uD0A4: ${configKey}`);
+          process.exit(1);
+        }
+        const path = item.path;
+        let finalValue = value;
+        if (item.type === "boolean") {
+          if (value !== "true" && value !== "false") {
+            console.error(
+              `${configKey} \uAC12\uC740 true \uB610\uB294 false \uC5EC\uC57C \uD569\uB2C8\uB2E4: ${value}`
+            );
+            process.exit(1);
+          }
+          finalValue = value === "true";
+        } else if (item.type === "select" && item.suggestions) {
+          if (!item.suggestions.includes(value)) {
+            console.error(
+              `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uAC12\uC785\uB2C8\uB2E4: ${value}
+\uC9C0\uC6D0\uB418\uB294 \uAC12: ${item.suggestions.join(", ")}`
+            );
+            process.exit(1);
+          }
+        }
+        setDeep(
+          updatedConfig,
+          path,
+          finalValue
+        );
+        await writeProjectConfig(updatedConfig);
+        setSaved(true);
+      })();
+    }
+  }, [configKey, value, saved]);
+  return {
+    config,
+    loading,
+    cleared,
+    saved
+  };
+}
+
+export {
+  useConfig
+};