cb-dsa 0.1.0__py3-none-any.whl

cb_dsa/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

cb_dsa/commands/create.py

@@ -0,0 +1,341 @@
+import os
+import sys
+import json
+import re
+import datetime
+import subprocess
+
+from cb_dsa.core.utils import (
+    LANG_EXTENSIONS, get_session_cookie, get_csrf_token, fetch_problem_data, 
+    fetch_submission_details, get_slug_from_id, get_last_category, save_last_category,
+    get_switch_topic, reset_switch_topic, get_metadata, clean_code, multiline_input
+)
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.table import Table
+from rich import print as rprint
+
+console = Console()
+
+def get_clipboard_text():
+    try:
+        import tkinter as tk
+        root = tk.Tk()
+        root.withdraw()
+        clip = root.clipboard_get()
+        root.destroy()
+        return clip
+    except Exception:
+        return ""
+
+def create_problem():
+    base_dir = os.getcwd()
+    console.print(Panel.fit(" [bold blue]Create New DSA Problem[/bold blue] ", border_style="blue"))
+    
+    categories = [d for d in os.listdir(base_dir) if os.path.isdir(os.path.join(base_dir, d)) and not d.startswith('.')]
+    category_map = {c.lower(): c for c in categories}
+    category_map['array'] = 'Arrays'
+    category_map['hash table'] = 'HashMaps'
+    category_map['dynamic programming'] = 'DP'
+    
+    clip_text = get_clipboard_text().strip()
+    match = re.search(r'leetcode\.com/problems/([a-zA-Z0-9\-]+)', clip_text)
+    
+    lc_data = None
+    num = None
+    submission_link = ""
+    custom_code = ""
+    question_link = ""
+    lang_ext = ".cpp"
+    
+    if match:
+        slug = match.group(1)
+        console.print(f"[bold green]✓[/bold green] Detected LeetCode URL for [bold cyan]'{slug}'[/bold cyan] in clipboard!")
+        if '/submissions/' in clip_text:
+            submission_link = clip_text
+            console.print("[bold green]✓[/bold green] Detected submission link in clipboard!")
+            
+        with console.status(f"[bold cyan]Fetching data for '{slug}'...[/bold cyan]", spinner="dots"):
+            lc_data = fetch_problem_data(slug)
+        if lc_data:
+            num = lc_data['questionFrontendId']
+            console.print(f"[bold green]✓[/bold green] Fetched data for problem: [bold white]{num}. {lc_data['title']}[/bold white]")
+    
+    if not lc_data:
+        console.print("\n[yellow]⚠ No valid LeetCode link in clipboard.[/yellow]")
+        console.print("1. LeetCode (Input ID)")
+        console.print("2. Other Platform")
+        choice = Prompt.ask("[bold cyan]Choose option[/bold cyan]", choices=["1", "2"], default="1")
+        
+        if choice == "1":
+            while True:
+                num_input = Prompt.ask("[bold cyan]Problem number[/bold cyan]").strip()
+                if num_input:
+                    num = num_input
+                    break
+            slug = get_slug_from_id(num)
+            if slug:
+                with console.status(f"[bold cyan]Fetching data for problem {num}...[/bold cyan]", spinner="dots"):
+                    lc_data = fetch_problem_data(slug)
+            
+    # Process problem data
+    category = None
+    if lc_data:
+        title = lc_data['title']
+        slug = lc_data['titleSlug']
+        difficulty = lc_data['difficulty']
+        
+        try:
+            similar_questions_list = json.loads(lc_data['similarQuestions'])
+            similar_problems = [(q['title'], q['titleSlug']) for q in similar_questions_list]
+        except:
+            similar_problems = []
+            
+        tags = []
+        if 'topicTags' in lc_data and lc_data['topicTags']:
+            for tag in lc_data['topicTags']:
+                name = tag['name']
+                if 'contest' not in name.lower():
+                    tags.append(name)
+        lc_data['filtered_tags'] = tags
+        
+        if tags:
+            switch_topic = get_switch_topic(base_dir)
+            if not switch_topic:
+                last_category = get_last_category(base_dir)
+                
+                # Check if any tag matches the last category
+                if last_category:
+                    for tag in tags:
+                        tag_lower = tag.lower()
+                        mapped_category = category_map.get(tag_lower, category_map.get(tag_lower + 's', tag_lower))
+                        if mapped_category.lower() == last_category.lower() or tag_lower == last_category.lower():
+                            category = last_category
+                            break
+                            
+                # Fallback to primary tag if no match with last_category
+                if not category:
+                    primary_tag = tags[0].lower()
+                    if primary_tag in category_map:
+                        category = category_map[primary_tag]
+                    elif primary_tag + 's' in category_map:
+                        category = category_map[primary_tag + 's']
+                        
+                    # Enforce topic-grinding mode: auto-map ONLY if it matches the last category you worked on
+                    if last_category and category and category.lower() != last_category.lower():
+                        category = None
+                
+        name = title
+    else:
+        console.print("\n[yellow]⚠ Manual Problem Setup[/yellow]")
+        while True:
+            name = Prompt.ask("[bold cyan]Problem name[/bold cyan]").strip()
+            if name:
+                break
+                
+        num_input = Prompt.ask("[bold cyan]Problem number/ID (e.g., 100, CF-123)[/bold cyan]", default="000").strip()
+        num = num_input if num_input else "000"
+        
+        question_link = Prompt.ask("[bold cyan]Question Link[/bold cyan]").strip()
+        submission_link = Prompt.ask("[bold cyan]Submission Link (optional)[/bold cyan]").strip()
+        
+        difficulty = Prompt.ask("[bold cyan]Difficulty[/bold cyan]", choices=["Easy", "Medium", "Hard", "Basic", "School", "Other"], default="Medium").strip()
+        
+        custom_code = multiline_input("\nPaste your code here")
+        
+        ext_input = Prompt.ask("[bold cyan]File extension (e.g., .cpp, .py)[/bold cyan]", default=".cpp").strip()
+        if ext_input:
+            lang_ext = ext_input if ext_input.startswith('.') else '.' + ext_input
+            
+        similar_problems = []
+        tags = []
+        slug = name.lower().replace(' ', '-').replace(':', '')
+        title = name.title()
+
+    # Get Category if not auto-mapped
+    if not category:
+        options = list(categories)
+        if tags:
+            for t in tags:
+                # Add tags that don't already perfectly match an existing folder name
+                if not any(t.lower() == existing.lower() for existing in options):
+                    options.append(t)
+                    
+        console.print("\n[bold yellow]Could not auto-map category. Where should this problem go?[/bold yellow]")
+        
+        table = Table(show_header=False, box=None)
+        table.add_column("Index", style="cyan")
+        table.add_column("Category")
+        for i, opt in enumerate(options):
+            table.add_row(f"{i + 1}.", opt)
+        table.add_row(f"{len(options) + 1}.", "[bold]Create a new category folder[/bold]")
+        console.print(table)
+        
+        while True:
+            category_input = Prompt.ask(f"[bold cyan]Choose one option (1-{len(options) + 1})[/bold cyan]").strip()
+            if category_input.isdigit():
+                idx = int(category_input)
+                if 1 <= idx <= len(options):
+                    category = options[idx - 1]
+                    break
+                elif idx == len(options) + 1:
+                    category = Prompt.ask("[bold cyan]Enter new category name[/bold cyan]").strip()
+                    if category: break
+            elif category_input:
+                category = category_input
+                break
+                
+    save_last_category(base_dir, category)
+    reset_switch_topic(base_dir)
+                
+    category_path = os.path.join(base_dir, category)
+    if not os.path.exists(category_path):
+        os.makedirs(category_path)
+        console.print(f"[bold green]✓ Created new category folder:[/bold green] [cyan]{category}[/cyan]")
+        
+    if not submission_link and lc_data:
+        submission_link = Prompt.ask("[bold cyan]Submission link (optional, press Enter to skip)[/bold cyan]", default="").strip()
+            
+    clean_name = re.sub(r'[^a-zA-Z0-9\s\-]', '', name)
+    formatted_name = clean_name.lower().replace(' ', '_').replace('-', '_')
+    folder_name = f"{num}_{formatted_name}"
+    folder_path = os.path.join(category_path, folder_name)
+    
+    if lc_data:
+        question_link = f"https://leetcode.com/problems/{slug}/"
+    elif not question_link:
+        question_link = f"https://example.com/problems/{slug}/"
+    
+    if not os.path.exists(folder_path):
+        os.makedirs(folder_path)
+        
+    # Attempt to fetch code if submission link is provided
+    code_content = custom_code if not lc_data else ""
+    if lc_data and submission_link:
+        sub_id_match = re.search(r'submissions/(?:detail/)?(\d+)', submission_link)
+        if sub_id_match:
+            sub_id = sub_id_match.group(1)
+            session_cookie = get_session_cookie(base_dir, prompt_if_missing=True)
+            
+            if session_cookie:
+                with console.status(f"[bold cyan]Fetching code for submission {sub_id}...[/bold cyan]", spinner="dots"):
+                    csrf_token = get_csrf_token(session_cookie)
+                    details = fetch_submission_details(sub_id, session_cookie, csrf_token)
+                if details:
+                    code_content = details.get('code', '')
+                    lang_name = details.get('lang', {}).get('name', '')
+                    lang_ext = LANG_EXTENSIONS.get(lang_name, f".{lang_name}")
+                    console.print(f"[bold green]✓ Successfully fetched {lang_name} code![/bold green]")
+                else:
+                    console.print("[bold red]✗ Could not retrieve submission code (possibly expired or invalid cookie).[/bold red]")
+                    
+    if not code_content:
+        if lang_ext in ['.py', '.rb']:
+            code_content = f"# {num}. {title}\n\n"
+        else:
+            code_content = f"// {num}. {title}\n\n"
+            
+    meta = get_metadata(code_content, interactive=True)
+    code_content = clean_code(code_content)
+            
+    suffix = ""
+    counter = 1
+    while True:
+        code_file_name = f"{folder_name}_soln{suffix}{lang_ext}"
+        code_file_path = os.path.join(folder_path, code_file_name)
+        
+        md_file_name = f"{folder_name}_doc{suffix}.md"
+        md_file_path = os.path.join(folder_path, md_file_name)
+        
+        if not os.path.exists(code_file_path) and not os.path.exists(md_file_path):
+            break
+            
+        suffix = str(counter)
+        counter += 1
+        
+    with open(code_file_path, 'w', encoding='utf-8') as f:
+        f.write(code_content)
+    
+    current_date = datetime.datetime.now().strftime("%Y-%m-%d")
+    
+    md_content = f"# [{num}. {title}]({question_link})\n\n"
+    md_content += f"## Date\n{current_date}\n\n"
+    md_content += f"## Difficulty\n{difficulty}\n\n"
+    
+    md_content += f"## Topics\n"
+    if tags:
+        for t in tags:
+            md_content += f"- {t}\n"
+    else:
+        md_content += f"- {category}\n"
+    md_content += f"\n---\n\n"
+    
+    md_content += f"## Idea\n\n"
+    if submission_link:
+        if lc_data:
+            md_content += f"[View Submission on LeetCode]({submission_link})\n\n"
+        else:
+            md_content += f"[View Submission]({submission_link})\n\n"
+        
+    if meta.get('idea'):
+        md_content += f"{meta['idea']}\n\n"
+        
+    md_content += f"---\n\n"
+    md_content += f"## Time Complexity\n\n{meta['time']}\n\n## Space Complexity\n\n{meta['space']}\n\n---\n\n"
+    
+    if meta.get('learning'):
+        md_content += f"## Key Learning\n\n{meta['learning']}\n\n---\n\n"
+        
+    if meta.get('mistakes'):
+        md_content += f"## Mistakes Made\n\n{meta['mistakes']}\n\n---\n\n"
+    
+    if similar_problems:
+        md_content += f"## Similar Problems\n\n"
+        for sp_title, sp_slug in similar_problems:
+            md_content += f"- [{sp_title}](https://leetcode.com/problems/{sp_slug}/)\n"
+    else:
+        md_content += f"## Similar Problems\n\n- \n"
+        
+    with open(md_file_path, 'w', encoding='utf-8') as f:
+        f.write(md_content)
+
+    console.print("\n")
+    success_panel = Panel(
+        f"[bold]Folder:[/bold] {os.path.relpath(folder_path, base_dir)}\n"
+        f"[bold]Code:[/bold]   {os.path.relpath(code_file_path, base_dir)}\n"
+        f"[bold]Doc:[/bold]    {os.path.relpath(md_file_path, base_dir)}",
+        title="[bold green]Success! Created Files[/bold green]",
+        border_style="green",
+        expand=False
+    )
+    console.print(success_panel)
+    
+    with console.status("[bold cyan]Updating README statistics...[/bold cyan]", spinner="dots"):
+        from cb_dsa.commands.generate import update_readme
+        update_readme()
+        console.print("[bold green]✓ README updated![/bold green]")
+
+    console.print("\n[bold magenta]" + "="*40 + "[/bold magenta]")
+    console.print("[bold white]Files have been generated and README updated![/bold white]")
+    
+    ans = Prompt.ask("\n[bold cyan]Press Enter to commit and push, or type any character to skip[/bold cyan]", default="")
+    if ans == '':
+        try:
+            with console.status("[bold cyan]Committing to Git...[/bold cyan]", spinner="dots"):
+                subprocess.run(["git", "add", folder_path, "README.md", "docs/data.js", "docs/index.html"], check=True, capture_output=True)
+                commit_message = f"{num}. {title}"
+                subprocess.run(["git", "commit", "-m", commit_message], check=True, capture_output=True)
+                console.print(f"[bold green]✓ Successfully committed to Git:[/bold green] '{commit_message}'")
+                
+            console.print("[bold cyan]Pushing to GitHub...[/bold cyan]")
+            subprocess.run(["git", "push", "origin", "main"], check=True)
+            console.print("[bold green]✓ Successfully pushed to GitHub![/bold green]")
+        except Exception as e:
+            console.print(f"[bold red]✗ Failed to auto-commit or push:[/bold red] {e}")
+    else:
+        console.print("[yellow]Skipped commit and push.[/yellow]")
+
+if __name__ == "__main__":
+    create_problem()

cb_dsa/commands/generate.py

@@ -0,0 +1,242 @@
+import os
+import re
+import datetime
+import json
+import urllib.parse
+from rich.console import Console
+
+console = Console()
+
+def normalize_topic(topic):
+    mapping = {
+        'arrays': 'Array',
+        'hashmaps': 'Hash Table',
+        'hash map': 'Hash Table',
+        'dp': 'Dynamic Programming'
+    }
+    return mapping.get(topic.lower().strip(), topic.strip())
+
+def parse_doc_file(filepath, category):
+    with open(filepath, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    # Extract Title and Link
+    title_match = re.search(r'# \[([a-zA-Z0-9\-]+)\.\s+(.*?)\]\((.*?)\)', content)
+    if not title_match:
+        title_match = re.search(r'# ([a-zA-Z0-9\-]+)\.\s+(.*)', content)
+        if title_match:
+            num = title_match.group(1)
+            title = title_match.group(2).strip()
+            link = ""
+        else:
+            return None
+    else:
+        num = title_match.group(1)
+        title = title_match.group(2).strip()
+        link = title_match.group(3).strip()
+
+    # Extract Difficulty
+    difficulty_match = re.search(r'## Difficulty\s*\n\s*(Easy|Medium|Hard)', content, re.IGNORECASE)
+    difficulty = difficulty_match.group(1).capitalize() if difficulty_match else "Unknown"
+
+    # Extract Date
+    date_match = re.search(r'## Date\s*\n\s*(\d{4}-\d{2}-\d{2})', content)
+    if date_match:
+        date_solved = date_match.group(1)
+    else:
+        ctime = os.path.getctime(filepath)
+        date_solved = datetime.datetime.fromtimestamp(ctime).strftime("%Y-%m-%d")
+
+    # Extract Topics
+    topics_match = re.search(r'## Topics\s*\n(.*?)(?=\n##|\Z)', content, re.DOTALL)
+    topics = []
+    if topics_match:
+        for line in topics_match.group(1).split('\n'):
+            line = line.strip()
+            if line.startswith('- '):
+                topic = line[2:].strip()
+                if topic:
+                    norm_topic = normalize_topic(topic)
+                    if norm_topic not in topics:
+                        topics.append(norm_topic)
+    if not topics:
+        topics.append(normalize_topic(category))
+
+    return {
+        'num': num,
+        'title': title,
+        'link': link,
+        'difficulty': difficulty,
+        'category': category,
+        'topics': topics,
+        'date': date_solved,
+        'folder_path': os.path.dirname(filepath)
+    }
+
+def update_readme():
+    base_dir = os.getcwd()
+    problems = []
+    
+    categories = [d for d in os.listdir(base_dir) if os.path.isdir(os.path.join(base_dir, d)) and not d.startswith('.') and d not in ['cb-dsa', 'docs', '__pycache__']]
+    
+    for category in categories:
+        category_path = os.path.join(base_dir, category)
+        
+        for item in os.listdir(category_path):
+            item_path = os.path.join(category_path, item)
+            if not os.path.isdir(item_path):
+                continue
+                
+            doc_files = [f for f in os.listdir(item_path) if f.endswith('_doc.md') or f.endswith('_doc1.md') or '_doc' in f and f.endswith('.md')]
+            
+            if not doc_files:
+                continue
+                
+            doc_file = doc_files[0]
+            doc_path = os.path.join(item_path, doc_file)
+            
+            problem_data = parse_doc_file(doc_path, category)
+            if problem_data:
+                problems.append(problem_data)
+
+    def sort_key(x):
+        num_str = str(x['num'])
+        m = re.match(r'(\d+)(.*)', num_str)
+        if m:
+            return (int(m.group(1)), m.group(2))
+        return (float('inf'), num_str)
+        
+    problems.sort(key=sort_key)
+
+    total_problems = len(problems)
+    difficulty_counts = {'Easy': 0, 'Medium': 0, 'Hard': 0, 'Unknown': 0}
+    category_stats = {}
+    topic_stats = {}
+
+    for p in problems:
+        diff = p['difficulty']
+        cat = p['category']
+        
+        difficulty_counts[diff] = difficulty_counts.get(diff, 0) + 1
+        
+        if cat not in category_stats:
+            category_stats[cat] = {'Total': 0, 'Easy': 0, 'Medium': 0, 'Hard': 0, 'Unknown': 0}
+        
+        category_stats[cat]['Total'] += 1
+        if diff in category_stats[cat]:
+            category_stats[cat][diff] += 1
+        else:
+            category_stats[cat]['Unknown'] += 1
+            
+        for t in p['topics']:
+            if t not in topic_stats:
+                topic_stats[t] = 0
+            topic_stats[t] += 1
+
+    def get_bar(count, total, length=20):
+        if total == 0: return '░' * length
+        filled = int(round((count / total) * length))
+        return '█' * filled + '░' * (length - filled)
+
+    easy_count = difficulty_counts.get('Easy', 0)
+    medium_count = difficulty_counts.get('Medium', 0)
+    hard_count = difficulty_counts.get('Hard', 0)
+    
+    easy_pct = (easy_count / total_problems * 100) if total_problems else 0
+    medium_pct = (medium_count / total_problems * 100) if total_problems else 0
+    hard_pct = (hard_count / total_problems * 100) if total_problems else 0
+
+    stats_content = f"**Total Problems Solved:** {total_problems}\n\n"
+    stats_content += "### Difficulty Breakdown\n"
+    stats_content += f"- 🟢 **Easy** ({easy_pct:.1f}%): `{get_bar(easy_count, total_problems)}` ({easy_count})\n"
+    stats_content += f"- 🟡 **Medium** ({medium_pct:.1f}%): `{get_bar(medium_count, total_problems)}` ({medium_count})\n"
+    stats_content += f"- 🔴 **Hard** ({hard_pct:.1f}%): `{get_bar(hard_count, total_problems)}` ({hard_count})\n\n"
+    
+    stats_content += "### Topic Breakdown\n\n"
+    stats_content += "| Topic | Total | 🟢 Easy | 🟡 Medium | 🔴 Hard |\n"
+    stats_content += "|---|---|---|---|---|\n"
+    
+    for cat, stats in sorted(category_stats.items(), key=lambda item: item[1]['Total'], reverse=True):
+        stats_content += f"| **{cat}** | {stats['Total']} | {stats['Easy']} | {stats['Medium']} | {stats['Hard']} |\n"
+
+    table_content = "| # | Title | Difficulty | Topic | Solution |\n"
+    table_content += "|---|---|---|---|---|\n"
+    
+    for p in problems:
+        rel_folder = os.path.relpath(p['folder_path'], base_dir).replace('\\', '/')
+        encoded_folder = urllib.parse.quote(rel_folder)
+        
+        p['rel_folder'] = rel_folder
+        p['encoded_folder'] = encoded_folder
+        
+        title_link = f"[{p['title']}]({p['link']})" if p['link'] else p['title']
+        
+        diff_emoji = ""
+        if p['difficulty'] == 'Easy': diff_emoji = "🟢 Easy"
+        elif p['difficulty'] == 'Medium': diff_emoji = "🟡 Medium"
+        elif p['difficulty'] == 'Hard': diff_emoji = "🔴 Hard"
+        else: diff_emoji = p['difficulty']
+        
+        folder_link = f"[Code & Doc](./{encoded_folder})"
+        
+        table_content += f"| {p['num']} | {title_link} | {diff_emoji} | {p['category']} | {folder_link} |\n"
+
+    readme_path = os.path.join(base_dir, "README.md")
+    
+    if os.path.exists(readme_path):
+        with open(readme_path, 'r', encoding='utf-8') as f:
+            readme_text = f.read()
+    else:
+        readme_text = "# [DSA Practice Repository](https://cibidharan-rv.github.io/dsa/)\n\n## 📊 Statistics\n\n<!-- STATS:START -->\n<!-- STATS:END -->\n\n---\n\n## 📝 Problem Index\n\n<!-- TABLE:START -->\n<!-- TABLE:END -->\n"
+
+    stats_pattern = r'<!-- STATS:START -->.*?<!-- STATS:END -->'
+    stats_replacement = f"<!-- STATS:START -->\n{stats_content}\n<!-- STATS:END -->"
+    if re.search(stats_pattern, readme_text, re.DOTALL):
+        readme_text = re.sub(stats_pattern, stats_replacement, readme_text, flags=re.DOTALL)
+    else:
+        readme_text += f"\n\n## 📊 Statistics\n\n{stats_replacement}"
+        
+    table_pattern = r'<!-- TABLE:START -->.*?<!-- TABLE:END -->'
+    table_replacement = f"<!-- TABLE:START -->\n{table_content}\n<!-- TABLE:END -->"
+    if re.search(table_pattern, readme_text, re.DOTALL):
+        readme_text = re.sub(table_pattern, table_replacement, readme_text, flags=re.DOTALL)
+    else:
+        readme_text += f"\n\n## 📝 Problem Index\n\n{table_replacement}"
+
+    with open(readme_path, 'w', encoding='utf-8') as f:
+        f.write(readme_text)
+        
+    docs_dir = os.path.join(base_dir, "docs")
+    if not os.path.exists(docs_dir):
+        os.makedirs(docs_dir)
+        
+    dashboard_data = {
+        'total': total_problems,
+        'difficulty': difficulty_counts,
+        'categories': category_stats,
+        'topic_stats': topic_stats,
+        'problems': problems
+    }
+    
+    js_content = f"const dsaData = {json.dumps(dashboard_data, indent=2)};"
+    with open(os.path.join(docs_dir, "data.js"), 'w', encoding='utf-8') as f:
+        f.write(js_content)
+        
+    import time
+    index_path = os.path.join(docs_dir, "index.html")
+    if os.path.exists(index_path):
+        with open(index_path, 'r', encoding='utf-8') as f:
+            index_content = f.read()
+        
+        timestamp = int(time.time())
+        index_content = re.sub(r'data\.js(\?v=\d+)?', f'data.js?v={timestamp}', index_content)
+        index_content = re.sub(r'app\.js(\?v=\d+)?', f'app.js?v={timestamp}', index_content)
+        index_content = re.sub(r'styles\.css(\?v=\d+)?', f'styles.css?v={timestamp}', index_content)
+        
+        with open(index_path, 'w', encoding='utf-8') as f:
+            f.write(index_content)
+            
+    console.print(f"[bold green]✓ Successfully updated README.md and docs/data.js with {total_problems} problems.[/bold green]")
+
+if __name__ == "__main__":
+    update_readme()

cb_dsa/commands/sync.py

@@ -0,0 +1,233 @@
+import os
+import sys
+import json
+import re
+import time
+import datetime
+from rich.console import Console
+
+from cb_dsa.core.utils import (
+    LANG_EXTENSIONS, get_session_cookie, get_csrf_token,
+    fetch_problem_data, fetch_submission_details, fetch_submissions,
+    get_metadata, clean_code
+)
+from cb_dsa.commands.generate import update_readme
+
+console = Console()
+
+def sync_leetcode():
+    base_dir = os.getcwd()
+    console.print("[bold blue]=== LeetCode Sync ===[/bold blue]")
+    console.print("This script will download your past Accepted submissions.")
+    
+    session_cookie = get_session_cookie(base_dir, prompt_if_missing=True)
+    if not session_cookie:
+        console.print("[bold red]Session cookie is required. Exiting.[/bold red]")
+        return
+        
+    console.print("\nFetching CSRF token...")
+    csrf_token = get_csrf_token(session_cookie)
+    
+    console.print("Fetching submissions (this may take a minute)...")
+    offset = 0
+    limit = 40
+    
+    # slug -> { lang: submission_id }
+    accepted_problems = {} 
+    
+    while True:
+        data = fetch_submissions(session_cookie, offset, limit)
+        if not data:
+            break
+            
+        submissions = data.get('submissions_dump', [])
+        if not submissions:
+            break
+            
+        for sub in submissions:
+            if sub['status_display'] == "Accepted":
+                slug = sub['title_slug']
+                lang = sub['lang']
+                if slug not in accepted_problems:
+                    accepted_problems[slug] = {}
+                # Only keep the most recent per language
+                if lang not in accepted_problems[slug]:
+                    accepted_problems[slug][lang] = {'id': sub['id'], 'timestamp': sub.get('timestamp', time.time())}
+                    
+        if not data.get('has_next'):
+            break
+            
+        offset += limit
+        console.print(f"Scanned {offset} total submissions...")
+        time.sleep(2.5) # Rate limit protection
+        
+    console.print(f"\n[bold green]Found {len(accepted_problems)} unique accepted problems.[/bold green]")
+    
+    if not accepted_problems:
+        console.print("No accepted submissions found. Exiting.")
+        return
+        
+    categories = [d for d in os.listdir(base_dir) if os.path.isdir(os.path.join(base_dir, d)) and not d.startswith('.') and d not in ['cb-dsa', 'docs', '__pycache__']]
+    category_map = {c.lower(): c for c in categories}
+    category_map['array'] = 'Arrays'
+    category_map['hash table'] = 'HashMaps'
+    category_map['dynamic programming'] = 'DP'
+    
+    success_count = 0
+    
+    for slug, langs_dict in accepted_problems.items():
+        console.print(f"\nProcessing '{slug}'...")
+        lc_data = fetch_problem_data(slug, session_cookie, csrf_token)
+        if not lc_data:
+            console.print(f"[bold red]Failed to fetch problem metadata for {slug}. Skipping.[/bold red]")
+            continue
+            
+        num = lc_data['questionFrontendId']
+        title = lc_data['title']
+        difficulty = lc_data['difficulty']
+        
+        # Tags logic
+        tags = []
+        if 'topicTags' in lc_data and lc_data['topicTags']:
+            for tag in lc_data['topicTags']:
+                name = tag['name']
+                if 'contest' not in name.lower():
+                    tags.append(name)
+                    
+        category = "Other"
+        if tags:
+            primary_tag = tags[0].lower()
+            if primary_tag in category_map:
+                category = category_map[primary_tag]
+            elif primary_tag + 's' in category_map:
+                category = category_map[primary_tag + 's']
+                
+        category_path = os.path.join(base_dir, category)
+        if not os.path.exists(category_path):
+            os.makedirs(category_path)
+            
+        clean_name = re.sub(r'[^a-zA-Z0-9\s\-]', '', title)
+        formatted_name = clean_name.lower().replace(' ', '_').replace('-', '_')
+        folder_name = f"{num}_{formatted_name}"
+        folder_path = os.path.join(category_path, folder_name)
+        
+        # If problem already exists locally, patch it instead of skipping
+        exists = False
+        existing_folder_path = None
+        for cat in os.listdir(base_dir):
+            if os.path.isdir(os.path.join(base_dir, cat)) and not cat.startswith('.'):
+                if os.path.exists(os.path.join(base_dir, cat, folder_name)):
+                    exists = True
+                    existing_folder_path = os.path.join(base_dir, cat, folder_name)
+                    break
+        
+        most_recent_timestamp = max([info['timestamp'] for info in langs_dict.values()])
+        most_recent_sub_id = [info['id'] for info in langs_dict.values() if info['timestamp'] == most_recent_timestamp][0]
+        true_date = datetime.datetime.fromtimestamp(most_recent_timestamp).strftime("%Y-%m-%d")
+        sub_link_md = f"[View Submission on LeetCode](https://leetcode.com/submissions/detail/{most_recent_sub_id}/)"
+        
+        if exists:
+            # Patch existing file
+            doc_files = [f for f in os.listdir(existing_folder_path) if f.endswith('.md')]
+            if doc_files:
+                doc_path = os.path.join(existing_folder_path, doc_files[0])
+                with open(doc_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                
+                # Update Date
+                if re.search(r'## Date\s*\n\s*\d{4}-\d{2}-\d{2}', content):
+                    content = re.sub(r'## Date\s*\n\s*\d{4}-\d{2}-\d{2}', f'## Date\n{true_date}', content)
+                else:
+                    content += f'\n\n## Date\n{true_date}\n'
+                
+                # Add submission link if not present
+                if 'leetcode.com/submissions/detail' not in content:
+                    if '## Idea\n' in content:
+                        content = content.replace('## Idea\n', f'## Idea\n\n{sub_link_md}\n')
+                    else:
+                        content += f'\n\n## Submission\n{sub_link_md}\n'
+                        
+                # Clean up the old submission link format if the new one exists
+                if 'View Submission on LeetCode' in content and 'Click here to see the submission' in content:
+                    content = re.sub(r'\[Click here to see the submission\]\(.*?\)\s*\n?', '', content)
+                        
+                with open(doc_path, 'w', encoding='utf-8') as f:
+                    f.write(content)
+                    
+            console.print(f"[bold yellow]Problem {num} already exists. Patched true date and submission link.[/bold yellow]")
+            success_count += 1
+            continue
+            
+        os.makedirs(folder_path)
+        
+        # Fetch actual code for each language
+        console.print(f"Fetching source code for {len(langs_dict)} language(s)...")
+        meta = {'idea': '', 'time': 'O(?)', 'space': 'O(?)'}
+        for lang, sub_info in langs_dict.items():
+            sub_id = sub_info['id']
+            details = fetch_submission_details(sub_id, session_cookie, csrf_token)
+            code = details.get('code') if details else None
+            
+            if not code:
+                code = f"// Failed to fetch code automatically."
+                
+            ext = LANG_EXTENSIONS.get(lang, f".{lang}")
+            file_name = f"{folder_name}_soln{ext}"
+            
+            # Format header appropriately depending on language extension
+            if ext in ['.py', '.rb']:
+                header = f"# {num}. {title}\n\n"
+            else:
+                header = f"// {num}. {title}\n\n"
+                
+            code = clean_code(code)
+            with open(os.path.join(folder_path, file_name), 'w', encoding='utf-8') as f:
+                f.write(header + code + "\n")
+                
+            if sub_id == most_recent_sub_id:
+                meta = get_metadata(code, interactive=False)
+            
+        # Write doc
+        md_file_name = f"{folder_name}_doc.md"
+        leet_link = f"https://leetcode.com/problems/{slug}/"
+        
+        md_content = f"# [{num}. {title}]({leet_link})\n\n"
+        md_content += f"## Date\n{true_date}\n\n"
+        md_content += f"## Difficulty\n{difficulty}\n\n"
+        md_content += f"## Topics\n"
+        if tags:
+            for t in tags: md_content += f"- {t}\n"
+        else:
+            md_content += f"- {category}\n"
+        md_content += f"\n---\n\n## Idea\n\n{sub_link_md}\n\n"
+        if meta.get('idea'):
+            md_content += f"{meta['idea']}\n\n"
+        md_content += f"---\n\n"
+        md_content += f"## Time Complexity\n\n{meta.get('time', 'O(?)')}\n\n## Space Complexity\n\n{meta.get('space', 'O(?)')}\n\n---\n\n"
+        md_content += f"## Key Learning\n\n\n\n---\n\n## Mistakes Made\n\n\n\n---\n\n"
+        
+        try:
+            similar_questions_list = json.loads(lc_data['similarQuestions'])
+            similar_problems = [q['title'] for q in similar_questions_list]
+        except:
+            similar_problems = []
+            
+        md_content += f"## Similar Problems\n\n"
+        if similar_problems:
+            for sp in similar_problems: md_content += f"- {sp}\n"
+        else:
+            md_content += f"- \n"
+            
+        with open(os.path.join(folder_path, md_file_name), 'w', encoding='utf-8') as f:
+            f.write(md_content)
+            
+        success_count += 1
+        time.sleep(1) # Protect against rate limiting
+        
+    console.print(f"\n[bold green]Done! Successfully imported {success_count} problems.[/bold green]")
+    if success_count > 0:
+        console.print("Updating README statistics...")
+        update_readme()
+
+if __name__ == "__main__":
+    sync_leetcode()

cb_dsa/config.py

@@ -0,0 +1,34 @@
+import json
+import os
+from pathlib import Path
+from typing import Dict, Any
+
+CONFIG_FILE_NAME = "dsa-config.json"
+
+DEFAULT_CONFIG = {
+    "default_language": ".py",
+    "structure": "category",  # flat or category
+    "folder_format": "{id}_{name}",
+    "file_name_format": "{id}_{name}_soln",
+    "doc_name_format": "{id}_{name}_doc"
+}
+
+def load_config(base_dir: str) -> Dict[str, Any]:
+    config_path = os.path.join(base_dir, CONFIG_FILE_NAME)
+    if not os.path.exists(config_path):
+        return DEFAULT_CONFIG.copy()
+    
+    with open(config_path, "r", encoding="utf-8") as f:
+        try:
+            user_config = json.load(f)
+            # Merge with default config to ensure all keys exist
+            config = DEFAULT_CONFIG.copy()
+            config.update(user_config)
+            return config
+        except json.JSONDecodeError:
+            return DEFAULT_CONFIG.copy()
+
+def save_config(base_dir: str, config: Dict[str, Any]):
+    config_path = os.path.join(base_dir, CONFIG_FILE_NAME)
+    with open(config_path, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=4)

cb_dsa/core/utils.py

@@ -0,0 +1,356 @@
+import os
+import urllib.request
+import json
+import ssl
+import time
+
+from rich.console import Console
+from rich.prompt import Prompt
+
+console = Console()
+
+LANG_EXTENSIONS = {
+    'cpp': '.cpp', 'python': '.py', 'python3': '.py', 'java': '.java',
+    'c': '.c', 'csharp': '.cs', 'javascript': '.js', 'typescript': '.ts',
+    'golang': '.go', 'rust': '.rs', 'ruby': '.rb', 'swift': '.swift',
+    'kotlin': '.kt', 'php': '.php'
+}
+
+def get_session_cookie(base_dir, prompt_if_missing=True):
+    env_path = os.path.join(base_dir, ".env")
+    session_cookie = ""
+    if os.path.exists(env_path):
+        with open(env_path, 'r', encoding='utf-8') as f:
+            for line in f:
+                if line.startswith("LEETCODE_SESSION="):
+                    session_cookie = line.strip().split('=', 1)[1]
+    
+    if not session_cookie and prompt_if_missing:
+        session_cookie = Prompt.ask("\n[bold cyan]Paste your LEETCODE_SESSION cookie (will be saved to .env)[/bold cyan]").strip()
+        if session_cookie:
+            with open(env_path, 'a', encoding='utf-8') as f:
+                f.write(f"LEETCODE_SESSION={session_cookie}\n")
+    return session_cookie
+
+def get_last_category(base_dir):
+    env_path = os.path.join(base_dir, ".env")
+    if os.path.exists(env_path):
+        with open(env_path, 'r', encoding='utf-8') as f:
+            for line in f:
+                if line.startswith("LAST_CATEGORY="):
+                    return line.strip().split('=', 1)[1]
+    return None
+
+def save_last_category(base_dir, category):
+    env_path = os.path.join(base_dir, ".env")
+    lines = []
+    found = False
+    if os.path.exists(env_path):
+        with open(env_path, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+            
+    with open(env_path, 'w', encoding='utf-8') as f:
+        for line in lines:
+            if line.startswith("LAST_CATEGORY="):
+                f.write(f"LAST_CATEGORY={category}\n")
+                found = True
+            else:
+                f.write(line)
+        if not found:
+            f.write(f"LAST_CATEGORY={category}\n")
+
+def get_switch_topic(base_dir):
+    env_path = os.path.join(base_dir, ".env")
+    if os.path.exists(env_path):
+        with open(env_path, 'r', encoding='utf-8') as f:
+            for line in f:
+                if line.startswith("SWITCH_TOPIC="):
+                    return line.strip().split('=', 1)[1].lower() == 'true'
+    return False
+
+def reset_switch_topic(base_dir):
+    env_path = os.path.join(base_dir, ".env")
+    lines = []
+    found = False
+    if os.path.exists(env_path):
+        with open(env_path, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+            
+    with open(env_path, 'w', encoding='utf-8') as f:
+        for line in lines:
+            if line.startswith("SWITCH_TOPIC="):
+                f.write("SWITCH_TOPIC=false\n")
+                found = True
+            else:
+                f.write(line)
+        if not found:
+            f.write("SWITCH_TOPIC=false\n")
+
+def get_csrf_token(session_cookie):
+    context = ssl._create_unverified_context()
+    req = urllib.request.Request("https://leetcode.com/", headers={'Cookie': f'LEETCODE_SESSION={session_cookie}', 'User-Agent': 'Mozilla/5.0'})
+    try:
+        response = urllib.request.urlopen(req, context=context)
+        for header, value in response.getheaders():
+            if header.lower() == 'set-cookie' and 'csrftoken' in value:
+                return value.split('csrftoken=')[1].split(';')[0]
+    except:
+        pass
+    return "csrftoken_placeholder"
+
+def fetch_graphql(query, variables, session_cookie=None, csrf_token=None, retries=3):
+    context = ssl._create_unverified_context()
+    graphql_url = "https://leetcode.com/graphql/"
+    payload = {"query": query, "variables": variables}
+    
+    headers = {
+        'Content-Type': 'application/json',
+        'User-Agent': 'Mozilla/5.0'
+    }
+    
+    if session_cookie and csrf_token:
+        headers['Cookie'] = f'LEETCODE_SESSION={session_cookie}; csrftoken={csrf_token}'
+        headers['X-CSRFToken'] = csrf_token
+        
+    req = urllib.request.Request(graphql_url, data=json.dumps(payload).encode('utf-8'), headers=headers)
+    
+    for attempt in range(retries):
+        try:
+            response = urllib.request.urlopen(req, context=context, timeout=10)
+            return json.loads(response.read())
+        except Exception as e:
+            if attempt < retries - 1:
+                time.sleep(2)
+            else:
+                console.print(f"[bold red]GraphQL request failed after {retries} attempts: {e}[/bold red]")
+                return None
+
+def fetch_problem_data(slug, session_cookie=None, csrf_token=None):
+    query = """
+    query questionData($titleSlug: String!) {
+      question(titleSlug: $titleSlug) {
+        questionId
+        questionFrontendId
+        title
+        titleSlug
+        difficulty
+        similarQuestions
+        note
+        topicTags {
+          name
+        }
+      }
+    }
+    """
+    res = fetch_graphql(query, {"titleSlug": slug}, session_cookie, csrf_token)
+    if res and 'data' in res:
+        return res['data'].get('question')
+    return None
+
+def fetch_submission_details(submission_id, session_cookie, csrf_token):
+    query = """
+    query submissionDetails($submissionId: Int!) {
+      submissionDetails(submissionId: $submissionId) {
+        code
+        lang {
+          name
+        }
+      }
+    }
+    """
+    res = fetch_graphql(query, {"submissionId": int(submission_id)}, session_cookie, csrf_token)
+    if res and 'data' in res and res['data'].get('submissionDetails'):
+        return res['data']['submissionDetails']
+    return None
+
+def fetch_submissions(session_cookie, offset, limit, retries=5):
+    context = ssl._create_unverified_context()
+    url = f"https://leetcode.com/api/submissions/?offset={offset}&limit={limit}"
+    req = urllib.request.Request(url, headers={'Cookie': f'LEETCODE_SESSION={session_cookie}', 'User-Agent': 'Mozilla/5.0'})
+    for attempt in range(retries):
+        try:
+            response = urllib.request.urlopen(req, context=context, timeout=30)
+            return json.loads(response.read())
+        except Exception as e:
+            if attempt < retries - 1:
+                console.print(f"[yellow]Timeout at offset {offset}. Retrying ({attempt+1}/{retries})...[/yellow]")
+                time.sleep(5)
+            else:
+                console.print(f"[bold red]Failed to fetch submissions at offset {offset}: {e}[/bold red]")
+                return None
+
+def get_slug_from_id(question_id):
+    context = ssl._create_unverified_context()
+    all_url = "https://leetcode.com/api/problems/all/"
+    req = urllib.request.Request(all_url, headers={'User-Agent': 'Mozilla/5.0'})
+    try:
+        response = urllib.request.urlopen(req, context=context)
+        data = json.loads(response.read())
+    except Exception as e:
+        console.print(f"[bold red]Failed to fetch problems list: {e}[/bold red]")
+        return None
+        
+    for p in data.get('stat_status_pairs', []):
+        if str(p['stat']['frontend_question_id']) == str(question_id):
+            return p['stat']['question__title_slug']
+            
+    console.print(f"[bold yellow]Could not find a problem with ID {question_id}[/bold yellow]")
+    return None
+
+import re
+
+def get_clipboard_text():
+    try:
+        import tkinter as tk
+        root = tk.Tk()
+        root.withdraw()
+        clip = root.clipboard_get()
+        root.destroy()
+        return clip
+    except Exception:
+        return ""
+
+def extract_metadata(code_content):
+    """
+    Extracts idea, time, space, learning, and mistakes from code comments.
+    Supports both old format ($t: <time>) and new block format ($t <time> $$).
+    """
+    if code_content is None:
+        code_content = ""
+        
+    metadata = {'idea': None, 'time': None, 'space': None, 'learning': None, 'mistakes': None}
+    
+    def extract_block(tag):
+        # Look for $tag ... $$
+        pattern = r'\$' + tag + r'\s*(.*?)\$\$'
+        match = re.search(pattern, code_content, re.DOTALL | re.IGNORECASE)
+        if match:
+            raw_text = match.group(1)
+            cleaned_lines = []
+            for line in raw_text.split('\n'):
+                # remove leading comment chars
+                clean = re.sub(r'^(\s*\*\s*|\s*//\s*|\s*#\s*)', '', line)
+                cleaned_lines.append(clean)
+            return '\n'.join(cleaned_lines).strip()
+        return None
+
+    metadata['idea'] = extract_block('i')
+    metadata['time'] = extract_block('t')
+    metadata['space'] = extract_block('s')
+    metadata['learning'] = extract_block('l')
+    metadata['mistakes'] = extract_block('m')
+    
+    # Fallback for old format if $$ block not found
+    if not metadata['idea']:
+        idea_match = re.search(r'\$i\s*\n(.*?)(?=\$t:|\$s:|\*/|\Z)', code_content, re.DOTALL | re.IGNORECASE)
+        if idea_match:
+            raw_idea = idea_match.group(1)
+            cleaned_lines = []
+            for line in raw_idea.split('\n'):
+                clean = re.sub(r'^(\s*\*\s*|\s*//\s*|\s*#\s*)', '', line)
+                cleaned_lines.append(clean)
+            metadata['idea'] = '\n'.join(cleaned_lines).strip()
+            
+    if not metadata['time']:
+        time_match = re.search(r'\$t:\s*(.*)', code_content, re.IGNORECASE)
+        if time_match:
+            metadata['time'] = time_match.group(1).strip()
+            
+    if not metadata['space']:
+        space_match = re.search(r'\$s:\s*(.*)', code_content, re.IGNORECASE)
+        if space_match:
+            metadata['space'] = space_match.group(1).strip()
+            
+    return metadata
+
+def multiline_input(prompt):
+    console.print(f"[bold cyan]{prompt}[/bold cyan]")
+    console.print("[dim](Press ENTER twice on an empty line to finish)[/dim]")
+    lines = []
+    consecutive_empty = 0
+    
+    while True:
+        try:
+            line = input()
+        except EOFError:
+            break
+            
+        if line == "":
+            consecutive_empty += 1
+            if consecutive_empty >= 2:
+                ans = Prompt.ask("[bold cyan]Continue typing?[/bold cyan]", choices=["y", "n", ""], default="").strip().lower()
+                if ans == 'y':
+                    consecutive_empty = 0
+                    continue
+                else:
+                    break
+        else:
+            consecutive_empty = 0
+            
+        lines.append(line)
+        
+    return '\n'.join(lines).strip()
+
+def get_metadata(code_content, interactive=True):
+    meta = extract_metadata(code_content)
+    
+    if interactive:
+        if not meta.get('idea'):
+            console.print("\n[bold yellow]Idea not found in code comments.[/bold yellow]")
+            console.print("1. Read docs block from clipboard")
+            console.print("2. Paste docs block manually")
+            console.print("3. Skip / Default")
+            choice = Prompt.ask("[bold cyan]Choose option[/bold cyan]", choices=["1", "2", "3"], default="1")
+            
+            raw_docs = ""
+            if choice == "1":
+                raw_docs = get_clipboard_text()
+                if raw_docs:
+                    console.print("[bold green]✓ Read docs from clipboard![/bold green]")
+                else:
+                    console.print("[bold red]✗ Could not read from clipboard or clipboard is empty.[/bold red]")
+                    raw_docs = multiline_input("\nPaste your docs block here")
+            elif choice == "2":
+                raw_docs = multiline_input("\nPaste your docs block here")
+                
+            if raw_docs:
+                new_meta = extract_metadata(raw_docs)
+                for k, v in new_meta.items():
+                    if v:
+                        meta[k] = v
+
+        if not meta.get('time'):
+            meta['time'] = Prompt.ask("[bold cyan]Enter Time Complexity (e.g., O(n))[/bold cyan]", default="O(n)").strip()
+        if not meta.get('space'):
+            meta['space'] = Prompt.ask("[bold cyan]Enter Space Complexity (e.g., O(1))[/bold cyan]", default="O(n)").strip()
+            
+    if not meta.get('idea'): meta['idea'] = ""
+    if not meta.get('time'): meta['time'] = "O(n)"
+    if not meta.get('space'): meta['space'] = "O(n)"
+    
+    return meta
+
+def clean_code(code_content):
+    # Strip C++/Java/JS block comments
+    code_content = re.sub(r'/\*\s*\$i.*?\*/\s*', '', code_content, flags=re.DOTALL | re.IGNORECASE)
+    # Strip Python block strings
+    code_content = re.sub(r'\"\"\"\s*\$i.*?\"\"\"\s*', '', code_content, flags=re.DOTALL | re.IGNORECASE)
+    code_content = re.sub(r"'''\s*\$i.*?'''\s*", '', code_content, flags=re.DOTALL | re.IGNORECASE)
+    
+    # Strip contiguous Python '#' comments if one contains $i
+    lines = code_content.split('\n')
+    cleaned_lines = []
+    in_idea_block = False
+    for line in lines:
+        is_comment = bool(re.match(r'^\s*#', line))
+        if is_comment and '$i' in line.lower():
+            in_idea_block = True
+            continue
+        if in_idea_block:
+            if is_comment:
+                continue # Skip all contiguous comment lines
+            else:
+                in_idea_block = False # Block ended
+        cleaned_lines.append(line)
+        
+    return '\n'.join(cleaned_lines).strip()

cb_dsa/main.py

@@ -0,0 +1,24 @@
+import typer
+from rich.console import Console
+
+from cb_dsa.commands.create import create_problem
+from cb_dsa.commands.generate import update_readme
+from cb_dsa.commands.sync import sync_leetcode
+
+app = typer.Typer(help="cb-dsa: A CLI to automate your LeetCode and DSA workflow.")
+console = Console()
+
+@app.command()
+def init():
+    """
+    Initialize cb-dsa configuration in the current directory.
+    """
+    console.print("[bold green]Initializing cb-dsa...[/bold green]")
+    # TODO: Implement config generation
+
+app.command(name="create")(create_problem)
+app.command(name="generate")(update_readme)
+app.command(name="sync")(sync_leetcode)
+
+if __name__ == "__main__":
+    app()

cb_dsa-0.1.0.dist-info/METADATA

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: cb-dsa
+Version: 0.1.0
+Summary: A customizable CLI for automating Data Structures and Algorithms tracking.
+Author-email: Cibidharan <your-email@example.com>
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: beautifulsoup4>=4.12.0
+
+# cb-dsa
+
+A Command Line Interface (CLI) tool for automating your Data Structures and Algorithms (DSA) problem-solving workflow. 
+
+It helps you automatically create problem files, sync your LeetCode submissions, and generate detailed markdown documentation and statistics.
+
+## Installation
+
+```bash
+pip install cb-dsa
+```
+
+## Usage
+
+```bash
+# Initialize inside your project folder
+cb-dsa init
+
+# Sync your recent accepted LeetCode submissions
+cb-dsa sync
+
+# Manually create a new problem template (grabs from clipboard)
+cb-dsa create
+
+# Re-generate the README.md and stats dashboard
+cb-dsa generate
+```

cb_dsa-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+cb_dsa/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+cb_dsa/config.py,sha256=UrH5mRYRjYyqq-sGNYcpJvzUoqeCFlD2W9Q3r6OhFsI,1099
+cb_dsa/main.py,sha256=Ow_3HQkIkdZ00vIa2rNoO0Fv5w1f17pkvlL4kU7oJLE,681
+cb_dsa/commands/create.py,sha256=NRLX0J4hzagf6dvILA3Busn_wHJAE1xBJ11KHGfSI6s,14472
+cb_dsa/commands/generate.py,sha256=qx4a7zXo21euOcb-rPriQbJtyhdDP9ynmszZVCoD6fw,9442
+cb_dsa/commands/sync.py,sha256=-9ozCeci815AckYtpfNLWVh8aQnMBxN-83aDCQM6bTc,9786
+cb_dsa/core/utils.py,sha256=W051IPx3ToOiDWEUEuUGC4VYVCVAiiygxXkeuWz3E7Y,13259
+cb_dsa-0.1.0.dist-info/METADATA,sha256=pzFMlBox_GQzVDvB_kwE7bSxb6cE7vrp4U0dYCZxQ1U,1041
+cb_dsa-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+cb_dsa-0.1.0.dist-info/entry_points.txt,sha256=wyacBe1_TzqgZbhyUJ9Y8EH8yJedvGL942awe1NV28I,43
+cb_dsa-0.1.0.dist-info/top_level.txt,sha256=UPSZ8_24UIszdN6x66Yao_z8ZkLXH_knRr8oScWBc0M,7
+cb_dsa-0.1.0.dist-info/RECORD,,

cb_dsa-0.1.0.dist-info/WHEEL

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

cb_dsa-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cb-dsa = cb_dsa.main:app

cb_dsa-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cb_dsa