interviewprep-cli 0.1.0__py3-none-any.whl

interviewprep/cli.py

@@ -0,0 +1,29 @@
+import click
+from interviewprep.commands.add import add
+from interviewprep.commands.list import list_problems
+from interviewprep.commands.view import view
+from interviewprep.commands.edit import edit
+from interviewprep.commands.delete import delete
+from interviewprep.commands.review import review
+from interviewprep.commands.dashboard import dashboard
+from interviewprep.commands.today import today
+from interviewprep.commands.export import export
+from interviewprep.commands.import_problems import import_problems
+
+
+@click.group()
+def main():
+    """Interview CLI - manage your technical interview preparation."""
+    pass
+
+
+main.add_command(add)
+main.add_command(list_problems)
+main.add_command(view)
+main.add_command(edit)
+main.add_command(delete)
+main.add_command(review)
+main.add_command(dashboard)
+main.add_command(today)
+main.add_command(export)
+main.add_command(import_problems)

interviewprep/commands/add.py

@@ -0,0 +1,20 @@
+import click
+from interviewprep.storage import save_problems, load_problems, find_attempts_by_name
+from interviewprep.prompts import prompt_for_problem
+from interviewprep.scheduler import calculate_next_review_date
+from interviewprep.streak import update_streak
+
+
+@click.command()
+def add():
+    click.echo("===Add New Problem===")
+
+    problem = prompt_for_problem()
+    problems = load_problems()
+    prior = find_attempts_by_name(problems, problem.problem_name)
+    problem.next_review_date = calculate_next_review_date(problem, prior)
+    problems.append(problem)
+    save_problems(problems)
+    update_streak()
+
+    click.echo(f"\nSaved '{problem.problem_name}' saved successfully")

interviewprep/commands/dashboard.py

@@ -0,0 +1,81 @@
+import click
+from interviewprep.storage import load_problems, find_attempts_by_needs_resolve
+from rich.console import Console
+from rich.table import Table
+import heapq
+
+
+@click.command()
+def dashboard():
+    problems = load_problems()
+    console = Console()
+    freq_table = Table()
+    average_difficulty_table = Table()
+    resolve_count_table = Table()
+    leetcode_difficulty_table = Table()
+    pattern_frequency = {}
+    difficulty_frequency = {}
+    personal_difficulty_frequency = {}
+
+    leetcode_difficulty_table.add_column("#")
+    leetcode_difficulty_table.add_column("Leetcode Difficulty")
+    leetcode_difficulty_table.add_column("Solved Count")
+    freq_table.add_column("#")
+    freq_table.add_column("Pattern")
+    freq_table.add_column("Solved Count")
+    average_difficulty_table.add_column("#")
+    average_difficulty_table.add_column("Pattern")
+    average_difficulty_table.add_column("Average Personal Difficulty")
+    resolve_count_table.add_column("Total Resolves Needed")
+
+    if not problems:
+        click.echo("No Saved Problems yet")
+        return
+
+    # for Leetcode Difficulty
+    for problem in problems:
+        difficulty_frequency[problem.leetcode_difficulty.value] = (
+            1 + difficulty_frequency.get(problem.leetcode_difficulty.value, 0)
+        )
+
+    for i, (difficulty, count) in enumerate(difficulty_frequency.items(), start=1):
+        leetcode_difficulty_table.add_row(str(i), difficulty, str(count))
+
+    # for patter frequency
+    for problem in problems:
+        pattern_frequency[problem.pattern] = 1 + pattern_frequency.get(
+            problem.pattern, 0
+        )
+
+    top_five_patterns = heapq.nlargest(
+        5, pattern_frequency.items(), key=lambda item: item[1]
+    )
+
+    for i, (pattern, count) in enumerate(top_five_patterns, start=1):
+        freq_table.add_row(str(i), pattern, str(count))
+
+    # for average difficulty
+    for problem in problems:
+        pattern = problem.pattern
+        difficulty = problem.personal_difficulty
+
+        if pattern not in personal_difficulty_frequency:
+            personal_difficulty_frequency[pattern] = {"total_difficulty": 0, "count": 0}
+
+        personal_difficulty_frequency[pattern]["total_difficulty"] += difficulty
+        personal_difficulty_frequency[pattern]["count"] += 1
+
+    for i, (pattern, count) in enumerate(
+        personal_difficulty_frequency.items(), start=1
+    ):
+        average = count["total_difficulty"] / count["count"]
+        average_difficulty_table.add_row(str(i), pattern, str(average))
+
+    # problems needing resolve
+    resolve_problems = find_attempts_by_needs_resolve(problems, True)
+    resolve_count_table.add_row(str(len(resolve_problems)))
+
+    console.print(leetcode_difficulty_table)
+    console.print(freq_table)
+    console.print(average_difficulty_table)
+    console.print(resolve_count_table)

interviewprep/commands/delete.py

@@ -0,0 +1,24 @@
+import click
+from interviewprep.storage import load_problems, save_problems
+
+
+@click.command()
+@click.argument("number", type=int)
+def delete(number):
+    problems = load_problems()
+    num = number - 1
+
+    if 0 <= num < len(problems):
+        problem = problems[num]
+        sure = click.confirm(
+            f"Are you sure you want to delete problem {number}:{problem.problem_name}? "
+        )
+        if sure:
+            problems.pop(num)
+            save_problems(problems)
+            click.echo(f"You have Succesfully deleted problem {number}")
+        else:
+            click.echo("Problem was not deleted")
+    else:
+        click.echo(f"Problem {number} does not exist")
+        raise SystemExit(1)

interviewprep/commands/edit.py

@@ -0,0 +1,22 @@
+import click
+from interviewprep.storage import load_problems, save_problems
+from interviewprep.prompts import prompt_for_problem
+
+
+@click.command()
+@click.argument("number", type=int)
+def edit(number):
+    problems = load_problems()
+    num = number - 1
+
+    if 0 <= num < len(problems):
+        problem = problems[num]
+
+        updated_problem = prompt_for_problem(existing=problem)
+
+        problems[num] = updated_problem
+        save_problems(problems)
+        click.echo("\n Edit Saved Succesfully!")
+    else:
+        click.echo("That problem does not exist!")
+        raise SystemExit(1)

interviewprep/commands/export.py

@@ -0,0 +1,18 @@
+import click
+from pathlib import Path
+from interviewprep.storage import load_problems, write_problems_to_file
+
+
+@click.command()
+@click.option("--output", "-o", required=True, type=click.Path())
+def export(output):
+    path = Path(output)
+    problems = load_problems()
+    count = len(problems)
+
+    if count == 0:
+        click.echo("No problems to export")
+        return
+
+    write_problems_to_file(problems, path)
+    click.echo(f"You have successfully exported {count} problems to {path}")

interviewprep/commands/import_problems.py

@@ -0,0 +1,34 @@
+import click
+from interviewprep.storage import load_problems, save_problems, read_problems_from_file
+from pathlib import Path
+
+
+@click.command(name="import")
+@click.option("--input", "-i", required=True, type=click.Path())
+@click.option(
+    "--mode",
+    type=click.Choice(["merge", "replace"], case_sensitive=False),
+    default="merge",
+    show_default=True,
+)
+def import_problems(input, mode):
+    path = Path(input)
+
+    try:
+        new_problems = read_problems_from_file(path)
+    except FileNotFoundError:
+        click.echo(f"Error: file '{path}' not found.")
+        raise SystemExit(1)
+    except ValueError as e:
+        click.echo(f"Error reading file: {e}")
+        raise SystemExit(1)
+
+    count = len(new_problems)
+
+    if mode == "merge":
+        existing = load_problems()
+        save_problems(existing + new_problems)
+        click.echo(f"You have successfully imported {count} new problems to your list")
+    elif mode == "replace":
+        save_problems(new_problems)
+        click.echo(f"You have succesfully imported {count} problems")

interviewprep/commands/list.py

@@ -0,0 +1,34 @@
+import click
+from interviewprep.storage import load_problems
+from rich.console import Console
+from rich.table import Table
+
+
+@click.command(name="list")
+def list_problems():
+    click.echo("===List Problems===")
+
+    problems = load_problems()
+    console = Console()
+    table = Table()
+
+    table.add_column("#")
+    table.add_column("Problem Name")
+    table.add_column("Date Attempted")
+    table.add_column("Personal Difficulty")
+    table.add_column("Needs Resolve")
+
+    if not problems:
+        click.echo("No Saved problems yet.")
+        return
+
+    for i, problem in enumerate(problems, start=1):
+        table.add_row(
+            str(i),
+            problem.problem_name,
+            problem.date_attempted.isoformat(),
+            str(problem.personal_difficulty),
+            "Yes" if problem.needs_resolve else "No",
+        )
+
+    console.print(table)

interviewprep/commands/review.py

@@ -0,0 +1,28 @@
+import click
+from interviewprep.storage import load_problems, save_problems, find_attempts_by_name
+from datetime import date
+from interviewprep.prompts import prompt_for_problem
+from interviewprep.scheduler import calculate_next_review_date
+from interviewprep.streak import update_streak
+
+
+@click.command()
+@click.argument("number", type=int)
+def review(number):
+    problems = load_problems()
+    num = number - 1
+
+    if 0 <= num < len(problems):
+        reviewed_problem = problems[num]
+
+        new_problem = prompt_for_problem(reviewed_problem)
+        new_problem.date_attempted = date.today()
+        prior = find_attempts_by_name(problems, new_problem.problem_name)
+        new_problem.next_review_date = calculate_next_review_date(new_problem, prior)
+        problems.append(new_problem)
+        save_problems(problems)
+        update_streak()
+
+    else:
+        click.echo("That problem does not exist")
+        raise SystemExit(1)

interviewprep/commands/today.py

@@ -0,0 +1,102 @@
+import click
+from interviewprep.storage import (
+    load_problems,
+    find_overdue_attempts_by_date,
+    find_due_today_attempts_by_date,
+    find_attempts_due_later_by_date,
+    load_streak,
+)
+from rich.console import Console
+from rich.table import Table
+from datetime import date
+import heapq
+
+
+@click.command()
+def today():
+    problems = load_problems()
+    console = Console()
+    overdue_table = Table()
+    due_today_table = Table()
+    upcoming_due_table = Table()
+    streak_table = Table()
+    today = date.today()
+    streak = load_streak()
+
+    overdue_table.add_column("#")
+    overdue_table.add_column("Problem name")
+    overdue_table.add_column("Pattern")
+    overdue_table.add_column("Days Overdue")
+    due_today_table.add_column("#")
+    due_today_table.add_column("Problem Name")
+    due_today_table.add_column("Pattern")
+    upcoming_due_table.add_column("#")
+    upcoming_due_table.add_column("Problem Name")
+    upcoming_due_table.add_column("Pattern")
+    upcoming_due_table.add_column("Resolve Date")
+    streak_table.add_column("Current Streak")
+    streak_table.add_column("Longest Streak")
+    streak_table.add_column("Last problem Completed")
+
+    if not problems:
+        click.echo("No Saved Problems")
+        return
+
+    # overdue Table
+    overdue = find_overdue_attempts_by_date(problems, today)
+    for i, problem in enumerate(overdue, start=1):
+        days_overdue = (today - problem.next_review_date).days
+        overdue_table.add_row(
+            str(i),
+            problem.problem_name,
+            problem.pattern,
+            days_overdue,
+        )
+
+    # due today Table
+    due_today = find_due_today_attempts_by_date(problems, today)
+    for i, problem in enumerate(due_today, start=1):
+        due_today_table.add_row(
+            str(i),
+            problem.problem_name,
+            problem.pattern,
+        )
+
+    # due later Table
+    due_later = find_attempts_due_later_by_date(problems, today)
+    five_upcoming_resolves = heapq.nsmallest(
+        5, due_later, key=lambda p: p.next_review_date
+    )
+    for i, problem in enumerate(five_upcoming_resolves, start=1):
+        upcoming_due_table.add_row(
+            str(i),
+            problem.problem_name,
+            problem.pattern,
+            problem.next_review_date.isoformat(),
+        )
+
+    # streak table
+    streak_table.add_row(
+        str(streak["current_streak"]),
+        str(streak["longest_streak"]),
+        (streak["last_completed"]),
+    )
+
+    if due_today:
+        console.print("Problems due today")
+        console.print(due_today_table)
+    else:
+        click.echo("No problems due today")
+
+    if overdue:
+        click.echo("Problems Overdue")
+        console.print(overdue_table)
+    else:
+        click.echo("No problems overdue")
+    if due_later:
+        click.echo("Upcoming Problems")
+        console.print(upcoming_due_table)
+    else:
+        click.echo("No upcoming problems due")
+    click.echo("Streak")
+    console.print(streak_table)

interviewprep/commands/view.py

@@ -0,0 +1,25 @@
+import click
+from interviewprep.storage import load_problems
+
+
+@click.command()
+@click.argument("number", type=int)
+def view(number):
+    problems = load_problems()
+    num = number - 1
+
+    if 0 <= num < len(problems):
+        problem = problems[num]
+        click.echo(f"Problem Name: {problem.problem_name}")
+        click.echo(f"Pattern: {problem.pattern}")
+        click.echo(f"Leetcode Difficulty: {problem.leetcode_difficulty.value}")
+        click.echo(f"Personal Difficulty: {problem.personal_difficulty}")
+        click.echo(f"Time Taken(min): {problem.time_taken_min}")
+        click.echo(f"Did You Use Help {problem.needed_help}")
+        click.echo(f"Needs Resolve: {problem.needs_resolve}")
+        click.echo(f"Date Attempted: {problem.date_attempted}")
+        click.echo(f"Next Review Date: {problem.next_review_date}")
+        click.echo(f"Recognition Sentence: {problem.recognition_sentence}")
+    else:
+        click.echo("Error: invalid problem number.")
+        raise SystemExit(1)

interviewprep/models.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass, field
+from datetime import date
+from typing import Optional
+from enum import Enum
+
+
+class LeetcodeDifficulty(Enum):
+    EASY = "Easy"
+    MEDIUM = "Medium"
+    HARD = "Hard"
+
+
+@dataclass
+class Problem:
+    problem_name: str
+    pattern: str
+    leetcode_difficulty: LeetcodeDifficulty
+    personal_difficulty: int
+    time_taken_min: int
+    needed_help: bool
+    needs_resolve: bool
+    date_attempted: date = field(default_factory=date.today)
+    next_review_date: Optional[date] = None
+    recognition_sentence: Optional[str] = None
+
+    def __post_init__(self):
+        self.problem_name = self.problem_name.strip()
+        if not 1 <= self.personal_difficulty <= 10:
+            raise ValueError(
+                "personal_difficulty must be between 1 & 10, "
+                f"{self.personal_difficulty} not a valid number"
+            )

interviewprep/prompts.py

@@ -0,0 +1,77 @@
+from typing import Optional
+from interviewprep.models import Problem, LeetcodeDifficulty
+import click
+from datetime import date
+
+
+def prompt_for_problem(existing: Optional[Problem] = None) -> Problem:
+    show_defaults = existing is not None
+
+    date_attempted = existing.date_attempted if existing else date.today()
+
+    problem_name = click.prompt(
+        "Problem Name:  ",
+        default=existing.problem_name if existing else "",
+        show_default=show_defaults,
+    )
+
+    pattern = click.prompt(
+        "Pattern: ",
+        default=existing.pattern if existing else "",
+        show_default=show_defaults,
+    )
+
+    difficulty_choice = click.prompt(
+        "Leetcode Difficulty: ",
+        type=click.Choice(["Easy", "Medium", "Hard"], case_sensitive=False),
+        default=existing.leetcode_difficulty.value if existing else "Easy",
+        show_default=show_defaults,
+    )
+
+    leetcode_difficulty = LeetcodeDifficulty(difficulty_choice.capitalize())
+
+    personal_difficulty = click.prompt(
+        "Personal Difficulty: ",
+        type=click.IntRange(1, 10),
+        default=existing.personal_difficulty if existing else 1,
+        show_default=show_defaults,
+    )
+
+    time_taken_min = click.prompt(
+        "Time Taken to Complete(min): ",
+        type=int,
+        default=existing.time_taken_min if existing else 15,
+        show_default=show_defaults,
+    )
+
+    needed_help = click.confirm(
+        "Did you need help/hint? ",
+        default=existing.needed_help if existing else False,
+        show_default=show_defaults,
+    )
+
+    needs_resolve = click.confirm(
+        "Does this need resolve? ",
+        default=existing.needs_resolve if existing else False,
+        show_default=show_defaults,
+    )
+
+    recognition_sentence = click.prompt(
+        "Recognition Sentence: ",
+        default=existing.recognition_sentence or "" if existing else "",
+        show_default=False,
+    )
+
+    problem = Problem(
+        problem_name=problem_name,
+        pattern=pattern,
+        leetcode_difficulty=leetcode_difficulty,
+        personal_difficulty=personal_difficulty,
+        time_taken_min=time_taken_min,
+        needed_help=needed_help,
+        needs_resolve=needs_resolve,
+        date_attempted=date_attempted,
+        recognition_sentence=recognition_sentence if recognition_sentence else None,
+    )
+
+    return problem

interviewprep/scheduler.py

@@ -0,0 +1,22 @@
+from datetime import timedelta, date
+from interviewprep.models import Problem
+
+
+def calculate_next_review_date(problem: Problem, prior_attempts: list[Problem]) -> date:
+    if not prior_attempts:
+        if problem.personal_difficulty > 5:
+            days = 1
+        else:
+            days = 3
+    else:
+        if problem.needed_help or problem.personal_difficulty >= 8:
+            days = 1
+        elif problem.personal_difficulty >= 6:
+            days = 3
+        elif problem.personal_difficulty >= 4:
+            days = 7
+        elif problem.personal_difficulty >= 2:
+            days = 14
+        else:
+            days = 30
+    return problem.date_attempted + timedelta(days=days)

interviewprep/storage.py

@@ -0,0 +1,137 @@
+import json
+from pathlib import Path
+from datetime import date
+from platformdirs import user_data_dir
+from interviewprep.models import Problem, LeetcodeDifficulty
+
+DATA_DIR = Path(user_data_dir("interviewprep"))
+DATA_FILE = DATA_DIR / "problems.json"
+STREAK_FILE = DATA_DIR / "streak.json"
+
+
+def _problem_to_dict(problem: Problem) -> dict:
+    return {
+        "problem_name": problem.problem_name,
+        "pattern": problem.pattern,
+        "leetcode_difficulty": problem.leetcode_difficulty.value,
+        "personal_difficulty": problem.personal_difficulty,
+        "time_taken_min": problem.time_taken_min,
+        "needed_help": problem.needed_help,
+        "needs_resolve": problem.needs_resolve,
+        "date_attempted": problem.date_attempted.isoformat(),
+        "next_review_date": (
+            problem.next_review_date.isoformat() if problem.next_review_date else None
+        ),
+        "recognition_sentence": problem.recognition_sentence,
+    }
+
+
+def _dict_to_problem(data: dict) -> Problem:
+    return Problem(
+        problem_name=data["problem_name"],
+        pattern=data["pattern"],
+        leetcode_difficulty=LeetcodeDifficulty(data["leetcode_difficulty"]),
+        personal_difficulty=data["personal_difficulty"],
+        time_taken_min=data["time_taken_min"],
+        needed_help=data["needed_help"],
+        needs_resolve=data["needs_resolve"],
+        date_attempted=date.fromisoformat(data["date_attempted"]),
+        next_review_date=(
+            date.fromisoformat(data["next_review_date"])
+            if data["next_review_date"]
+            else None
+        ),
+        recognition_sentence=data.get("recognition_sentence"),
+    )
+
+
+def save_streak(streak: dict) -> None:
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    with open(STREAK_FILE, "w") as f:
+        json.dump(streak, f, indent=2)
+
+
+def load_streak() -> dict:
+    if not STREAK_FILE.exists():
+        return {
+            "current_streak": 0,
+            "longest_streak": 0,
+            "last_completed": None,
+        }
+    with open(STREAK_FILE) as f:
+        return json.load(f)
+
+
+def write_problems_to_file(problems: list[Problem], path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w") as f:
+        json.dump([_problem_to_dict(p) for p in problems], f, indent=2)
+
+
+def read_problems_from_file(path: Path) -> list[Problem]:
+    if not path.exists():
+        raise FileNotFoundError(f"file not found: {path}")
+    with open(path) as f:
+        try:
+            data = json.load(f)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Not valid Json: {e}")
+    if not isinstance(data, list):
+        raise ValueError("Expected a json list of problems")
+    problems = []
+    for i, entry in enumerate(data, start=1):
+        try:
+            problems.append(_dict_to_problem(entry))
+        except (KeyError, ValueError, TypeError) as e:
+            raise ValueError(f"Invalid data in row {i}: {e}")
+    return problems
+
+
+def save_problems(problems: list[Problem]) -> None:
+    write_problems_to_file(problems, DATA_FILE)
+
+
+def load_problems() -> list[Problem]:
+    if not DATA_FILE.exists():
+        return []
+    return read_problems_from_file(DATA_FILE)
+
+
+def find_attempts_by_name(problems: list[Problem], name: str) -> list[Problem]:
+    return [p for p in problems if p.problem_name == name]
+
+
+def find_attempts_by_needs_resolve(
+    problems: list[Problem], needs_resolve: bool
+) -> list[Problem]:
+    return [p for p in problems if p.needs_resolve == needs_resolve]
+
+
+def find_overdue_attempts_by_date(
+    problems: list[Problem], review_date: date
+) -> list[Problem]:
+    return [
+        p
+        for p in problems
+        if p.next_review_date is not None and p.next_review_date < review_date
+    ]
+
+
+def find_due_today_attempts_by_date(
+    problems: list[Problem], review_date: date
+) -> list[Problem]:
+    return [
+        p
+        for p in problems
+        if p.next_review_date is not None and p.next_review_date == review_date
+    ]
+
+
+def find_attempts_due_later_by_date(
+    problems: list[Problem], review_date: date
+) -> list[Problem]:
+    return [
+        p
+        for p in problems
+        if p.next_review_date is not None and p.next_review_date > review_date
+    ]

interviewprep/streak.py

@@ -0,0 +1,32 @@
+from datetime import date
+from interviewprep.storage import load_streak, save_streak
+
+
+def update_streak() -> dict:
+    streak = load_streak()
+    today = date.today()
+
+    if streak["last_completed"]:
+        last = date.fromisoformat(streak["last_completed"])
+        diff = (today - last).days
+
+        if diff == 1:
+            streak["current_streak"] += 1
+            streak["longest_streak"] = max(
+                streak["current_streak"], streak["longest_streak"]
+            )
+        elif diff == 0:
+            return streak
+        else:
+            streak["current_streak"] = 1
+
+    else:
+        streak["current_streak"] = 1
+        streak["longest_streak"] = 1
+        streak["last_completed"] = today.isoformat()
+
+    streak["last_completed"] = today.isoformat()
+
+    save_streak(streak)
+
+    return streak

interviewprep_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,257 @@
+Metadata-Version: 2.4
+Name: interviewprep-cli
+Version: 0.1.0
+Summary: A CLI tool for organizing technical interview preparation
+Author-email: Tevita Mathias <mathias.tevita@icloud.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/aldohl95/InterviewPrepCli
+Project-URL: Repository, https://github.com/aldohl95/InterviewPrepCli
+Project-URL: Issues, https://github.com/aldohl95/InterviewPrepCli/issues
+Keywords: cli,leetcode,interview-prep,spaced-repetition
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Education
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: platformdirs
+Requires-Dist: click
+Requires-Dist: rich
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: pytest-cov>=4.1; extra == "dev"
+Requires-Dist: black>=24.0; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Dynamic: license-file
+
+# InterviewPrep CLI
+
+A command-line application for organizing and optimizing technical interview preparation. Instead of tracking LeetCode problems, study notes, and review schedules across spreadsheets and multiple apps, everything lives in a single terminal-based tool with spaced repetition built in.
+
+## Features
+
+- **Problem Tracker** — full CRUD for practice attempts with problem name, pattern, difficulty, time taken, and self-assessment fields
+- **Spaced Repetition Engine** — automatic scheduling of review dates based on personal difficulty and whether hints were used
+- **Progress Dashboard** — aggregated statistics on problems solved, patterns practiced, and difficulty distribution
+- **Daily Study Planner** — shows what's due for review today with streak tracking
+- **Data Import / Export** — JSON-based backup and restore with merge and replace modes
+
+## Installation
+
+Requires Python 3.11 or higher.
+
+```bash
+git clone https://github.com/aldohl95/InterviewPrepCli.git
+cd InterviewPrepCli
+python3 -m venv .venv
+source .venv/bin/activate    # On Windows: .venv\Scripts\activate
+pip install -e ".[dev]" --no-build-isolation
+```
+
+Verify the installation:
+
+```bash
+interviewprep --help
+```
+
+## Usage
+
+### Adding a problem
+
+```bash
+interviewprep add
+```
+
+Walks through interactive prompts for problem name, pattern (e.g. "hash map"), LeetCode difficulty, personal difficulty (1–10), time taken, whether you needed help, and an optional recognition sentence.
+
+### Listing all problems
+
+```bash
+interviewprep list
+```
+
+Displays a summary table with problem number, name, date attempted, personal difficulty, and whether it needs resolving.
+
+### Viewing full details
+
+```bash
+interviewprep view 1
+```
+
+Shows every field for the numbered problem.
+
+### Editing a problem
+
+```bash
+interviewprep edit 1
+```
+
+Prompts field-by-field with current values as defaults. Press Enter to keep any field unchanged.
+
+### Deleting a problem
+
+```bash
+interviewprep delete 1
+```
+
+Confirmation prompt before deletion.
+
+### Logging a new review
+
+```bash
+interviewprep review 1
+```
+
+Creates a new attempt record for an existing problem and calculates the next review date based on the spaced repetition algorithm.
+
+### Progress dashboard
+
+```bash
+interviewprep dashboard
+```
+
+Displays statistics: total problems solved, breakdown by LeetCode difficulty, top patterns practiced, and problems still needing resolve.
+
+### Daily study planner
+
+```bash
+interviewprep today
+```
+
+Shows problems due for review today, falls back to upcoming reviews if nothing is due, and tracks your daily streak.
+
+### Exporting data
+
+```bash
+interviewprep export --output=backup.json
+```
+
+Writes all problems to a JSON file for backup.
+
+### Importing data
+
+```bash
+interviewprep import --input=backup.json --mode=merge
+interviewprep import --input=backup.json --mode=replace
+```
+
+Merge mode adds imported problems to existing data. Replace mode overwrites everything.
+
+## Architecture
+
+### Directory structure
+### Full project structure
+
+```
+interviewprep-cli/
+├── src/
+│   └── interviewprep/
+│       ├── __init__.py
+│       ├── cli.py           — Click entry point and command registration
+│       ├── models.py        — Problem dataclass and LeetcodeDifficulty enum
+│       ├── storage.py       — JSON persistence via platformdirs
+│       ├── prompts.py       — shared interactive prompt logic
+│       ├── scheduler.py     — spaced repetition algorithm
+│       └── commands/        — one file per CLI command
+│           ├── __init__.py
+│           ├── add.py
+│           ├── list.py
+│           ├── view.py
+│           ├── edit.py
+│           ├── delete.py
+│           ├── review.py
+│           ├── dashboard.py
+│           ├── today.py
+│           ├── export.py
+│           └── import_problems.py
+│
+├── tests/
+│   ├── test_basic.py
+│   ├── test_model.py
+│   ├── test_storage.py
+│   ├── test_scheduler.py
+│   └── test_command.py
+│
+├── docs/
+│   └── scheduler.md         — algorithm design and tradeoffs
+│
+├── README.md
+├── SPEC.md
+├── LICENSE
+└── pyproject.toml           — project config, dependencies, tool settings
+```
+
+### Data storage
+
+Problems are stored as JSON at the platform-appropriate user data directory (via `platformdirs`):
+
+- **Linux**: `~/.local/share/interviewprep/problems.json`
+- **macOS**: `~/Library/Application Support/interviewprep/problems.json`
+- **Windows**: `%LOCALAPPDATA%\interviewprep\problems.json`
+
+### Spaced repetition
+
+A custom piecewise algorithm designed for interview preparation. First reviews use gentle intervals (1 or 3 days). Subsequent reviews scale from 1 day (needed help or difficulty ≥ 8) up to 30 days (mastered). Full details in `docs/scheduler.md`.
+
+## Design Decisions
+
+Several deliberate tradeoffs are documented in-code and worth calling out:
+
+- **JSON over SQLite** — chosen for simplicity and human-readable data. SQLite migration is noted as future work.
+- **Custom scheduling algorithm over SM-2** — the industry-standard SM-2 algorithm was overkill for the expected data size. The custom algorithm is simpler to test, defend, and reason about.
+- **Problem name as identifier** — prior attempts are looked up by name rather than by a separate ID system. Acceptable tradeoff for a single-user tool.
+- **New attempts as separate records** — the `review` command creates new records rather than mutating existing ones, preserving history.
+- **Edit does not recalculate schedules** — editing a problem is treated as metadata correction. Users who want to update their schedule should use `review` instead.
+
+## Development
+
+### Running tests
+
+```bash
+pytest
+```
+
+Current test count: **42 tests passing** across models, storage, scheduler, and all commands.
+
+### Formatting and linting
+
+```bash
+black src/ tests/
+ruff check src/ tests/
+```
+
+Configuration lives in `pyproject.toml`.
+
+### Test coverage areas
+
+- Data model validation (boundary values, invalid inputs)
+- Storage round-trip (save then load produces equivalent data)
+- Scheduler algorithm (every branch and boundary tested)
+- Every CLI command (success paths and error cases)
+
+## Future Work
+
+- Migrate storage layer from JSON to SQLite for efficient querying
+- Add CSV import/export format
+- Refactor to split `Problem` (identity) from `Attempt` (per-session data)
+- Recalculate `next_review_date` on edit when scheduling fields change
+- Add filtering to `list` command (by pattern, difficulty, date range)
+- CI pipeline with GitHub Actions
+
+## Tech Stack
+
+- **Python 3.11+**
+- **Click** — CLI framework
+- **Rich** — formatted terminal output
+- **platformdirs** — cross-platform data directory handling
+- **pytest** — testing framework
+- **Black** and **Ruff** — code formatting and linting
+
+## License
+
+MIT

interviewprep_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+interviewprep/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+interviewprep/cli.py,sha256=oifdE_Mj54LuU5qtYgR9M_3DCMZbeQNz8D46Rz-9FDw,888
+interviewprep/models.py,sha256=vssAH7YAS3K3200XPyAuOBS0v_FJqI1-SkfwLyDappo,879
+interviewprep/prompts.py,sha256=8aWUNdsqnmLu9-GerH0DiYOFsYoeAQo5xefdb2Bux_M,2360
+interviewprep/scheduler.py,sha256=5zcAtBdUdVZKnRbcE77NjndTGTyQfHj5ffryFlo3jT8,693
+interviewprep/storage.py,sha256=COT32vxonIUwCyrDCUdGbLefhFknQ7LhAAoeqtvQeqA,4258
+interviewprep/streak.py,sha256=pLcz252IF95YKWYemF1Vw75efmyUxDKuoF7ZG8n_9zk,824
+interviewprep/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+interviewprep/commands/add.py,sha256=LnifcXLkX5dtserMaKcb3a9VhPhqj-R_1rK8XMydAD4,688
+interviewprep/commands/dashboard.py,sha256=o1xM81-1Zj3OAKbxWCSNCgB2JC0LXRP_Fm0PEl6Mhjg,2853
+interviewprep/commands/delete.py,sha256=Et_xXwkqfTgQ27oWCoXTxsUa0ozcUaVwLti7dOiIh4w,711
+interviewprep/commands/edit.py,sha256=kneqWkCjNDlXFYl5qiO0k1MIHL6aRA35eFR2VYG79bY,595
+interviewprep/commands/export.py,sha256=ZESzAKCDCG23_znTL-NQH3NmrCk92csxMJDKaR7a3cE,496
+interviewprep/commands/import_problems.py,sha256=Vf8lyp32jXRTRF2tNCDfTWxGkBnmqHIrIwbg_yO3y5g,1061
+interviewprep/commands/list.py,sha256=uP8eJR9VGN5p3lz2UKrtOKcsRzRc3cksyvUSXfeMNzo,869
+interviewprep/commands/review.py,sha256=h5hHjQchyYYAMRCynHgFOGFaM0O0AduLyHyPxFnEJK0,942
+interviewprep/commands/today.py,sha256=QlB3vYJGNn1Lo9gE3HQxYyQVsVn8xgmiDquZKio_tAw,2985
+interviewprep/commands/view.py,sha256=fqPbE2dk56kQCKgMKrs8qNS5d-oRRpm2f2-nQA3Bv6s,1004
+interviewprep_cli-0.1.0.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+interviewprep_cli-0.1.0.dist-info/METADATA,sha256=6nYxiBI9d_c0GdQ0KB7gz3M_EF3CpGHlBFA3KXgxhiY,8189
+interviewprep_cli-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+interviewprep_cli-0.1.0.dist-info/entry_points.txt,sha256=xlGEpbeaOTx1yQdUPbDMPNuXs-ZcGUJ1CR1zmCtUM6c,57
+interviewprep_cli-0.1.0.dist-info/top_level.txt,sha256=4HP-BJCvgDU4X_mqHhPlW3YRCqFj_odKR7d_YTInY08,14
+interviewprep_cli-0.1.0.dist-info/RECORD,,

interviewprep_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

interviewprep_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+interviewprep = interviewprep.cli:main

interviewprep_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+interviewprep