fix: correct pyproject.toml for project-scaffold-cli

- Fixed package name from auto-readme-cli to project-scaffold-cli
- Fixed dependencies to match project-scaffold-cli requirements
- Fixed linting import sorting issues in test files

project_scaffold_cli/config.py

@@ -0,0 +1,152 @@
+"""Configuration handling for Project Scaffold CLI."""
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import yaml
+
+
+class Config:
+    """Configuration management for project scaffold CLI."""
+
+    def __init__(
+        self,
+        author: Optional[str] = None,
+        email: Optional[str] = None,
+        license: Optional[str] = None,
+        description: Optional[str] = None,
+        default_language: Optional[str] = None,
+        default_ci: Optional[str] = None,
+        default_template: Optional[str] = None,
+        template_vars: Optional[Dict[str, Any]] = None,
+        custom_templates_dir: Optional[str] = None,
+        config_path: Optional[str] = None,
+    ):
+        self.author = author
+        self.email = email
+        self.license = license
+        self.description = description
+        self.default_language = default_language
+        self.default_ci = default_ci
+        self.default_template = default_template
+        self.template_vars = template_vars or {}
+        self.custom_templates_dir = custom_templates_dir
+        self.config_path = config_path
+
+    @classmethod
+    def load(cls, config_path: Optional[str] = None) -> "Config":
+        """Load configuration from file."""
+        if config_path:
+            config_file = Path(config_path)
+            if config_file.exists():
+                return cls._from_file(config_file)
+
+        search_paths = [
+            Path("project.yaml"),
+            Path(".project-scaffoldrc"),
+            Path.cwd() / "project.yaml",
+            Path.cwd() / ".project-scaffoldrc",
+        ]
+
+        for path in search_paths:
+            if path.exists():
+                return cls._from_file(path)
+
+        home_config = Path.home() / ".config" / "project-scaffold" / "config.yaml"
+        if home_config.exists():
+            return cls._from_file(home_config)
+
+        return cls()
+
+    @classmethod
+    def _from_file(cls, path: Path) -> "Config":
+        """Load configuration from a YAML file."""
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                data = yaml.safe_load(f) or {}
+        except yaml.YAMLError as e:
+            raise ValueError(f"Invalid YAML in {path}: {e}")
+
+        project_config = data.get("project", {})
+        defaults = data.get("defaults", {})
+        template_vars = data.get("template_vars", {})
+        custom_templates_dir = data.get("custom_templates_dir")
+
+        return cls(
+            author=project_config.get("author"),
+            email=project_config.get("email"),
+            license=project_config.get("license"),
+            description=project_config.get("description"),
+            default_language=defaults.get("language"),
+            default_ci=defaults.get("ci"),
+            default_template=defaults.get("template"),
+            template_vars=template_vars,
+            custom_templates_dir=custom_templates_dir,
+            config_path=str(path),
+        )
+
+    def save(self, path: Path) -> None:
+        """Save configuration to a YAML file."""
+        data = {
+            "project": {
+                "author": self.author,
+                "email": self.email,
+                "license": self.license,
+                "description": self.description,
+            },
+            "defaults": {
+                "language": self.default_language,
+                "ci": self.default_ci,
+                "template": self.default_template,
+            },
+            "template_vars": self.template_vars,
+        }
+
+        if self.custom_templates_dir:
+            data["custom_templates_dir"] = self.custom_templates_dir
+
+        with open(path, "w", encoding="utf-8") as f:
+            yaml.dump(data, f, default_flow_style=False, sort_keys=False)
+
+    def get_template_dirs(self) -> List[str]:
+        """Get list of template directories to search."""
+        dirs = []
+
+        if self.custom_templates_dir:
+            dirs.append(self.custom_templates_dir)
+
+        home_templates = (
+            Path.home()
+            / ".local"
+            / "share"
+            / "project-scaffold"
+            / "templates"
+        )
+        dirs.append(str(home_templates))
+
+        return dirs
+
+    def get_custom_templates_dir(self) -> str:
+        """Get the directory for custom templates."""
+        if self.custom_templates_dir:
+            return self.custom_templates_dir
+
+        custom_dir = (
+            Path.home() / ".config" / "project-scaffold" / "templates"
+        )
+        custom_dir.mkdir(parents=True, exist_ok=True)
+        return str(custom_dir)
+
+    def get_template_vars(self, language: str) -> Dict[str, Any]:
+        """Get template variables for a specific language."""
+        return self.template_vars.get(language, {})
+
+    @property
+    def ci(self) -> Optional[str]:
+        """Get default CI provider."""
+        return self.default_ci
+
+    @property
+    def template(self) -> Optional[str]:
+        """Get default template."""
+        return self.default_template