hirekit 0.1.0__py3-none-any.whl

hirekit/__init__.py

@@ -0,0 +1,3 @@
+"""HireKit — AI-powered company analysis and interview preparation CLI."""
+
+__version__ = "0.1.0"

hirekit/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI commands for HireKit."""

hirekit/cli/app.py

@@ -0,0 +1,442 @@
+"""HireKit CLI — main entry point."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from dotenv import load_dotenv
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from hirekit import __version__
+from hirekit.core.config import DEFAULT_CONFIG_DIR, ensure_config_dir, load_config
+
+# Auto-load .env from project dir and ~/.hirekit/.env
+load_dotenv()
+load_dotenv(DEFAULT_CONFIG_DIR / ".env")
+
+app = typer.Typer(
+    name="hirekit",
+    help="AI-powered company analysis and interview preparation CLI.",
+    no_args_is_help=True,
+)
+console = Console()
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        console.print(f"[bold]HireKit[/bold] v{__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool | None = typer.Option(
+        None, "--version", "-v", callback=version_callback, is_eager=True
+    ),
+) -> None:
+    """HireKit — Research companies. Match jobs. Ace interviews."""
+
+
+@app.command()
+def analyze(
+    company: str = typer.Argument(help="Company name (e.g., '카카오', 'toss')"),
+    region: str = typer.Option("kr", "--region", "-r", help="Region: kr, us, global"),
+    output: str = typer.Option("markdown", "--output", "-o", help="markdown, json, terminal"),
+    no_llm: bool = typer.Option(False, "--no-llm", help="Skip LLM, template-only"),
+    tier: int = typer.Option(1, "--tier", "-t", help="Depth: 1 (full), 2 (key), 3 (min)"),
+) -> None:
+    """Analyze a company — collect data from multiple sources and generate a report."""
+    config = load_config()
+
+    console.print(Panel(
+        f"[bold]Analyzing:[/bold] {company}\n"
+        f"[bold]Region:[/bold] {region}  [bold]Tier:[/bold] {tier}  "
+        f"[bold]LLM:[/bold] {'off' if no_llm else config.llm.provider}",
+        title="[bold blue]HireKit Analysis[/bold blue]",
+        border_style="blue",
+    ))
+
+    # Import here to avoid circular imports and speed up CLI startup
+    from hirekit.engine.company_analyzer import CompanyAnalyzer
+
+    analyzer = CompanyAnalyzer(config=config, use_llm=not no_llm)
+
+    with console.status("[bold green]Collecting data from sources..."):
+        report = analyzer.analyze(company=company, region=region, tier=tier)
+
+    if output == "terminal":
+        console.print(report.to_rich())
+    elif output == "json":
+        import json
+        console.print(json.dumps(report.to_dict(), ensure_ascii=False, indent=2))
+    else:
+        out_path = Path(config.output.directory) / f"{company}_analysis.md"
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(report.to_markdown(), encoding="utf-8")
+        console.print(f"\n[green]Report saved:[/green] {out_path}")
+
+    # Show scorecard summary
+    if report.scorecard:
+        table = Table(title=f"{company} Scorecard")
+        table.add_column("Dimension", style="cyan")
+        table.add_column("Weight", justify="right")
+        table.add_column("Score", justify="right")
+        table.add_column("Evidence")
+
+        for d in report.scorecard.dimensions:
+            score_str = f"{d.score:.1f}/5" if d.score > 0 else "-"
+            table.add_row(d.label, f"{d.weight:.0%}", score_str, d.evidence[:60])
+
+        table.add_row(
+            "[bold]Total[/bold]", "", f"[bold]{report.scorecard.total_score:.0f}/100[/bold]",
+            f"Grade [bold]{report.scorecard.grade}[/bold]",
+        )
+        console.print(table)
+
+
+@app.command()
+def configure() -> None:
+    """Set up HireKit configuration (API keys, preferences)."""
+    config_dir = ensure_config_dir()
+    config_file = config_dir / "config.toml"
+
+    if config_file.exists():
+        console.print(f"[yellow]Config already exists:[/yellow] {config_file}")
+        console.print("Edit it directly or delete to re-initialize.")
+        return
+
+    # Create default config
+    default_config = """\
+[analysis]
+default_region = "kr"
+cache_ttl_hours = 168
+parallel_workers = 5
+
+[llm]
+provider = "none"  # openai, anthropic, ollama, none
+model = "gpt-4o-mini"
+temperature = 0.3
+
+[sources]
+enabled = ["dart", "github", "naver_news"]
+
+[output]
+format = "markdown"
+directory = "./reports"
+"""
+    config_file.write_text(default_config, encoding="utf-8")
+    console.print(f"[green]Config created:[/green] {config_file}")
+
+    # Create .env template
+    env_file = config_dir / ".env"
+    if not env_file.exists():
+        env_file.write_text(
+            "# HireKit API Keys\n"
+            "# DART_API_KEY=your_dart_api_key_here\n"
+            "# OPENAI_API_KEY=your_openai_key_here\n"
+            "# ANTHROPIC_API_KEY=your_anthropic_key_here\n",
+            encoding="utf-8",
+        )
+        console.print(f"[green]Env template:[/green] {env_file}")
+
+    console.print("\n[bold]Next steps:[/bold]")
+    console.print("  1. Get a DART API key: https://opendart.fss.or.kr/")
+    console.print("  2. Edit ~/.hirekit/.env with your API keys")
+    console.print("  3. Run: [cyan]hirekit analyze 카카오[/cyan]")
+
+
+@app.command()
+def sources() -> None:
+    """List available data sources and their status."""
+    from hirekit.sources.base import SourceRegistry
+
+    SourceRegistry.discover_plugins()
+    all_sources = SourceRegistry.get_all()
+
+    table = Table(title="Data Sources")
+    table.add_column("Name", style="cyan")
+    table.add_column("Region")
+    table.add_column("Sections")
+    table.add_column("API Key")
+    table.add_column("Status")
+
+    for name, source_cls in sorted(all_sources.items()):
+        source = source_cls()
+        available = source.is_available()
+        table.add_row(
+            name,
+            source.region.upper(),
+            ", ".join(source.sections),
+            source.api_key_env_var or "-",
+            "[green]Ready[/green]" if available else "[red]Not configured[/red]",
+        )
+
+    console.print(table)
+
+
+@app.command()
+def match(
+    jd_source: str = typer.Argument(help="JD URL or text file path"),
+    profile: str = typer.Option("", "--profile", "-p", help="Career profile YAML"),
+    output: str = typer.Option("markdown", "--output", "-o", help="markdown, terminal"),
+) -> None:
+    """Match a job description against your career profile."""
+    from hirekit.engine.jd_matcher import JDMatcher
+
+    config = load_config()
+    llm = _get_llm(config)
+    matcher = JDMatcher(llm=llm)
+
+    # Load profile if provided
+    user_profile = _load_profile(profile)
+
+    # Check if jd_source is a file
+    jd_path = Path(jd_source)
+    if jd_path.exists():
+        jd_source = jd_path.read_text(encoding="utf-8")
+
+    with console.status("[bold green]Analyzing job description..."):
+        analysis = matcher.analyze(jd_source=jd_source, profile=user_profile)
+
+    if output == "terminal":
+        console.print(Panel(
+            f"[bold]{analysis.title}[/bold] at {analysis.company}\n"
+            f"Match: [bold]{analysis.match_score:.0f}/100[/bold] "
+            f"(Grade {analysis.match_grade})",
+            title="[bold blue]JD Match[/bold blue]",
+            border_style="blue",
+        ))
+        if analysis.gaps:
+            console.print("\n[red]Gaps:[/red]")
+            for g in analysis.gaps[:5]:
+                console.print(f"  - {g}")
+        if analysis.strengths:
+            console.print("\n[green]Strengths:[/green]")
+            for s in analysis.strengths[:5]:
+                console.print(f"  - {s}")
+    else:
+        out_path = Path(config.output.directory) / "jd_match.md"
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(analysis.to_markdown(), encoding="utf-8")
+        console.print(f"[green]Report saved:[/green] {out_path}")
+
+
+@app.command()
+def interview(
+    company: str = typer.Argument(help="Company name"),
+    position: str = typer.Option("", "--position", "-p", help="Target position"),
+    profile: str = typer.Option("", "--profile", help="Career profile YAML"),
+    output: str = typer.Option("markdown", "--output", "-o", help="markdown, terminal"),
+) -> None:
+    """Generate interview preparation guide for a company."""
+    from hirekit.engine.interview_prep import InterviewPrep
+
+    config = load_config()
+    llm = _get_llm(config)
+    prep = InterviewPrep(llm=llm)
+
+    user_profile = _load_profile(profile)
+
+    with console.status(f"[bold green]Preparing interview guide for {company}..."):
+        guide = prep.prepare(
+            company=company,
+            position=position,
+            profile=user_profile,
+        )
+
+    if output == "terminal":
+        console.print(Panel(
+            f"[bold]{company}[/bold] — {position or 'General'}\n"
+            f"Questions: {len(guide.common_questions)} common, "
+            f"{len(guide.technical_questions)} technical, "
+            f"{len(guide.behavioral_questions)} behavioral\n"
+            f"Reverse questions: {len(guide.reverse_questions)}",
+            title="[bold blue]Interview Prep[/bold blue]",
+            border_style="blue",
+        ))
+        for q in guide.common_questions:
+            console.print(f"\n[cyan]Q:[/cyan] {q['question']}")
+            console.print(f"  [dim]{q.get('answer', '')}[/dim]")
+    else:
+        out_path = Path(config.output.directory) / f"{company}_interview.md"
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(guide.to_markdown(), encoding="utf-8")
+        console.print(f"[green]Report saved:[/green] {out_path}")
+
+
+@app.command()
+def coverletter(
+    company: str = typer.Argument(help="Company name (e.g., '카카오', 'toss')"),
+    position: str = typer.Option("", "--position", "-p", help="Target position (e.g., PM)"),
+    profile: str = typer.Option("", "--profile", help="Career profile YAML"),
+    output: str = typer.Option("markdown", "--output", "-o", help="markdown, terminal"),
+    no_llm: bool = typer.Option(False, "--no-llm", help="Skip LLM, rule-based only"),
+) -> None:
+    """Generate a Korean 자기소개서 (cover letter) draft with coaching feedback."""
+    from hirekit.engine.cover_letter import CoverLetterCoach
+
+    config = load_config()
+    llm = _get_llm(config) if not no_llm else None
+    coach = CoverLetterCoach(llm=llm)
+
+    user_profile = _load_profile(profile)
+
+    with console.status(f"[bold green]{company} 자기소개서 초안 작성 중..."):
+        draft = coach.draft(
+            company=company,
+            position=position,
+            profile=user_profile,
+        )
+
+    if output == "terminal":
+        console.print(Panel(
+            f"[bold]{company}[/bold] — {position or '미지정'}\n"
+            f"종합 점수: [bold]{draft.overall_score:.0f}/100[/bold] "
+            f"(Grade {draft.grade})\n"
+            f"섹션 수: {len(draft.sections)}개",
+            title="[bold blue]자기소개서 코치[/bold blue]",
+            border_style="blue",
+        ))
+        for section in draft.sections:
+            console.print(f"\n[cyan]## {section.title}[/cyan]")
+            console.print(section.content)
+            console.print(
+                f"[dim]점수: {section.score:.0f}/100 | "
+                f"글자 수: {section.word_count}자[/dim]"
+            )
+            if section.feedback:
+                console.print("[yellow]피드백:[/yellow]")
+                for fb in section.feedback:
+                    console.print(f"  - {fb}")
+    else:
+        out_path = Path(config.output.directory) / f"{company}_coverletter.md"
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(draft.to_markdown(), encoding="utf-8")
+        console.print(f"[green]자기소개서 저장:[/green] {out_path}")
+
+        table = Table(title=f"{company} 자기소개서 점수")
+        table.add_column("항목", style="cyan")
+        table.add_column("글자 수", justify="right")
+        table.add_column("점수", justify="right")
+        table.add_column("등급", justify="center")
+
+        for s in draft.sections:
+            table.add_row(s.title, str(s.word_count), f"{s.score:.0f}/100", s.grade)
+
+        table.add_row(
+            "[bold]종합[/bold]", "", f"[bold]{draft.overall_score:.0f}/100[/bold]",
+            f"[bold]{draft.grade}[/bold]",
+        )
+        console.print(table)
+
+
+@app.command()
+def resume(
+    file: str = typer.Argument(help="Resume file path (md, txt, pdf)"),
+    jd: str = typer.Option("", "--jd", help="JD URL or text for targeted review"),
+    profile: str = typer.Option("", "--profile", "-p", help="Career profile YAML"),
+    output: str = typer.Option("markdown", "--output", "-o", help="markdown, terminal"),
+) -> None:
+    """Review and provide feedback on your resume."""
+    from hirekit.engine.resume_advisor import ResumeAdvisor
+
+    config = load_config()
+    llm = _get_llm(config)
+    advisor = ResumeAdvisor(llm=llm)
+
+    user_profile = _load_profile(profile)
+
+    # Resolve JD text
+    jd_text = ""
+    if jd:
+        jd_path = Path(jd)
+        if jd_path.exists():
+            jd_text = jd_path.read_text(encoding="utf-8")
+        elif jd.startswith("http"):
+            import httpx
+            try:
+                resp = httpx.get(jd, timeout=10, follow_redirects=True)
+                from bs4 import BeautifulSoup
+                soup = BeautifulSoup(resp.text, "lxml")
+                jd_text = soup.get_text(separator="\n", strip=True)[:5000]
+            except Exception:
+                console.print(f"[yellow]Could not fetch JD from {jd}[/yellow]")
+        else:
+            jd_text = jd
+
+    with console.status("[bold green]Reviewing resume..."):
+        feedback = advisor.review(
+            resume_path=file, jd_text=jd_text, profile=user_profile
+        )
+
+    if output == "terminal":
+        console.print(Panel(
+            f"[bold]Score:[/bold] {feedback.overall_score:.0f}/100 "
+            f"(Grade {feedback.grade})",
+            title="[bold blue]Resume Review[/bold blue]",
+            border_style="blue",
+        ))
+        if feedback.strengths:
+            console.print("\n[green]Strengths:[/green]")
+            for s in feedback.strengths:
+                console.print(f"  + {s}")
+        if feedback.improvements:
+            console.print("\n[yellow]Improvements:[/yellow]")
+            for i in feedback.improvements:
+                console.print(f"  - {i}")
+        if feedback.keyword_gaps:
+            console.print("\n[red]Keyword gaps vs JD:[/red]")
+            console.print(f"  {', '.join(feedback.keyword_gaps[:10])}")
+    else:
+        out_path = Path(config.output.directory) / "resume_review.md"
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(feedback.to_markdown(), encoding="utf-8")
+        console.print(f"[green]Report saved:[/green] {out_path}")
+
+
+# --- Helpers ---
+
+def _get_llm(config: HireKitConfig) -> BaseLLM:  # noqa: F821
+    """Initialize LLM from config."""
+    from hirekit.llm.base import NoLLM
+    if config.llm.provider == "none":
+        return NoLLM()
+    try:
+        if config.llm.provider == "openai":
+            from hirekit.llm.openai import OpenAIAdapter
+            return OpenAIAdapter(model=config.llm.model)
+        if config.llm.provider == "anthropic":
+            from hirekit.llm.anthropic import AnthropicAdapter
+            return AnthropicAdapter(model=config.llm.model)
+    except ImportError:
+        pass
+    return NoLLM()
+
+
+def _load_profile(path: str) -> dict | None:
+    """Load career profile from YAML file."""
+    if not path:
+        # Check default location
+        default = Path.home() / ".hirekit" / "profile.yaml"
+        if default.exists():
+            path = str(default)
+        else:
+            return None
+
+    p = Path(path)
+    if not p.exists():
+        return None
+
+    try:
+        import yaml
+        return yaml.safe_load(p.read_text(encoding="utf-8"))
+    except ImportError:
+        # Fallback: basic YAML parsing without pyyaml
+        return None
+
+
+if __name__ == "__main__":
+    app()

hirekit/core/__init__.py

@@ -0,0 +1 @@
+"""Core configuration and utilities for HireKit."""

hirekit/core/cache.py

@@ -0,0 +1,68 @@
+"""Disk cache with TTL using sqlite3 (zero external dependencies)."""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+import time
+from pathlib import Path
+from typing import Any
+
+from hirekit.core.config import DEFAULT_CONFIG_DIR
+
+
+class Cache:
+    """Simple key-value cache backed by SQLite."""
+
+    def __init__(self, db_path: Path | None = None, ttl_hours: int = 168):
+        self.db_path = db_path or (DEFAULT_CONFIG_DIR / "cache.db")
+        self.ttl_seconds = ttl_hours * 3600
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._init_db()
+
+    def _init_db(self) -> None:
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS cache (
+                    key TEXT PRIMARY KEY,
+                    value TEXT NOT NULL,
+                    created_at REAL NOT NULL
+                )
+            """)
+
+    def get(self, key: str) -> Any | None:
+        """Get cached value. Returns None if missing or expired."""
+        with sqlite3.connect(self.db_path) as conn:
+            row = conn.execute(
+                "SELECT value, created_at FROM cache WHERE key = ?", (key,)
+            ).fetchone()
+
+        if row is None:
+            return None
+
+        value, created_at = row
+        if time.time() - created_at > self.ttl_seconds:
+            self.delete(key)
+            return None
+
+        return json.loads(value)
+
+    def set(self, key: str, value: Any) -> None:
+        """Set a cache entry."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute(
+                "INSERT OR REPLACE INTO cache (key, value, created_at) VALUES (?, ?, ?)",
+                (key, json.dumps(value, ensure_ascii=False), time.time()),
+            )
+
+    def delete(self, key: str) -> None:
+        """Delete a cache entry."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute("DELETE FROM cache WHERE key = ?", (key,))
+
+    def clear_expired(self) -> int:
+        """Remove all expired entries. Returns count of removed entries."""
+        cutoff = time.time() - self.ttl_seconds
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute("DELETE FROM cache WHERE created_at < ?", (cutoff,))
+            return cursor.rowcount

hirekit/core/config.py

@@ -0,0 +1,63 @@
+"""Configuration loader for HireKit."""
+
+from __future__ import annotations
+
+import tomllib
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+DEFAULT_CONFIG_DIR = Path.home() / ".hirekit"
+DEFAULT_CONFIG_FILE = DEFAULT_CONFIG_DIR / "config.toml"
+
+
+class LLMConfig(BaseModel):
+    provider: str = "none"  # openai, anthropic, ollama, none
+    model: str = "gpt-4o-mini"
+    temperature: float = 0.3
+    max_tokens: int = 4096
+
+
+class SourcesConfig(BaseModel):
+    enabled: list[str] = Field(default_factory=lambda: ["dart", "github", "naver_news"])
+    disabled: list[str] = Field(default_factory=list)
+
+
+class OutputConfig(BaseModel):
+    format: str = "markdown"  # markdown, json, terminal
+    directory: str = "./reports"
+    template: str = "default"
+
+
+class AnalysisConfig(BaseModel):
+    default_region: str = "kr"
+    cache_ttl_hours: int = 168  # 7 days
+    parallel_workers: int = 5
+
+
+class HireKitConfig(BaseModel):
+    """Root configuration model."""
+
+    analysis: AnalysisConfig = Field(default_factory=AnalysisConfig)
+    llm: LLMConfig = Field(default_factory=LLMConfig)
+    sources: SourcesConfig = Field(default_factory=SourcesConfig)
+    output: OutputConfig = Field(default_factory=OutputConfig)
+
+
+def load_config(config_path: Path | None = None) -> HireKitConfig:
+    """Load configuration from TOML file, falling back to defaults."""
+    path = config_path or DEFAULT_CONFIG_FILE
+
+    if path.exists():
+        with open(path, "rb") as f:
+            data: dict[str, Any] = tomllib.load(f)
+        return HireKitConfig(**data)
+
+    return HireKitConfig()
+
+
+def ensure_config_dir() -> Path:
+    """Create config directory if it doesn't exist."""
+    DEFAULT_CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    return DEFAULT_CONFIG_DIR

hirekit/core/parallel.py

@@ -0,0 +1,47 @@
+"""Parallel data collection executor."""
+
+from __future__ import annotations
+
+import logging
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Any
+
+from hirekit.sources.base import BaseSource, SourceResult
+
+logger = logging.getLogger(__name__)
+
+
+def collect_parallel(
+    sources: list[BaseSource],
+    company: str,
+    max_workers: int = 5,
+    **kwargs: Any,
+) -> list[SourceResult]:
+    """Run multiple data source collectors in parallel.
+
+    Returns all successfully collected results. Failed sources are logged and skipped.
+    """
+    all_results: list[SourceResult] = []
+
+    def _run_source(source: BaseSource) -> list[SourceResult]:
+        try:
+            return source.collect(company, **kwargs)
+        except Exception as e:
+            logger.warning("Source %s failed for %s: %s", source.name, company, e)
+            return []
+
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = {executor.submit(_run_source, s): s for s in sources}
+
+        for future in as_completed(futures):
+            source = futures[future]
+            try:
+                results = future.result(timeout=source.get_timeout())
+                all_results.extend(results)
+                logger.info("Source %s: %d results", source.name, len(results))
+            except TimeoutError:
+                logger.warning("Source %s timed out after %ds", source.name, source.get_timeout())
+            except Exception as e:
+                logger.warning("Source %s error: %s", source.name, e)
+
+    return all_results

hirekit/core/scoring.py

@@ -0,0 +1,22 @@
+"""Shared scoring utilities — deduplicated grade calculation."""
+
+from __future__ import annotations
+
+import datetime
+
+
+def score_to_grade(score: float, thresholds: tuple[float, ...] = (80, 65, 50, 35)) -> str:
+    """Convert a numeric score to letter grade.
+
+    Default thresholds: S >= 80, A >= 65, B >= 50, C >= 35, D < 35.
+    """
+    grades = ("S", "A", "B", "C", "D")
+    for threshold, grade in zip(thresholds, grades):
+        if score >= threshold:
+            return grade
+    return grades[-1]
+
+
+def current_year() -> int:
+    """Get current year (avoids hardcoded year strings)."""
+    return datetime.date.today().year

hirekit/engine/__init__.py

@@ -0,0 +1 @@
+"""Core analysis engines for HireKit."""