chronicle-log 0.1.0__tar.gz

chronicle_log-0.1.0/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: chronicle-log
+Version: 0.1.0
+Summary: A CLI logbook for founders, builders, and creators.
+Author-email: Your Name <you@example.com>
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9
+Requires-Dist: rich>=13
+
+# Chronicle 📖
+
+> Log the journey. Tell the story.
+
+Chronicle is a minimal CLI logbook built for founders, builders, and solo makers.
+Log your ideas, wins, failures, and progress — with accurate timestamps — as you build.
+
+## Install
+
+pip install chronicle-log
+
+## Usage
+
+chronicle log "Had a breakthrough on the auth flow" -c build
+chronicle idea "What if we added voice logging via whisper?"
+chronicle win "First real user signed up"
+chronicle fail "Shipped a bug that deleted sessions. Lesson: always backup."
+chronicle show --limit 20
+chronicle stats
+chronicle export --format markdown
+
+## Why?
+
+Built by a founder, for founders. Every entry you make today
+becomes the raw material of the story you'll tell tomorrow.
+
+## License
+
+MIT — free forever.

chronicle_log-0.1.0/README.md

@@ -0,0 +1,29 @@
+# Chronicle 📖
+
+> Log the journey. Tell the story.
+
+Chronicle is a minimal CLI logbook built for founders, builders, and solo makers.
+Log your ideas, wins, failures, and progress — with accurate timestamps — as you build.
+
+## Install
+
+pip install chronicle-log
+
+## Usage
+
+chronicle log "Had a breakthrough on the auth flow" -c build
+chronicle idea "What if we added voice logging via whisper?"
+chronicle win "First real user signed up"
+chronicle fail "Shipped a bug that deleted sessions. Lesson: always backup."
+chronicle show --limit 20
+chronicle stats
+chronicle export --format markdown
+
+## Why?
+
+Built by a founder, for founders. Every entry you make today
+becomes the raw material of the story you'll tell tomorrow.
+
+## License
+
+MIT — free forever.

chronicle_log-0.1.0/chronicle/__init__.py

@@ -0,0 +1,3 @@
+# chronicle/__init__.py
+__version__ = "0.1.0"
+__author__ = "Pratyay Mukherjee"

chronicle_log-0.1.0/chronicle/db.py

@@ -0,0 +1,78 @@
+# chronicle/db.py
+import sqlite3
+import os
+from pathlib import Path
+from datetime import datetime
+
+DB_DIR = Path.home() / ".chronicle"
+DB_PATH = DB_DIR / "logbook.db"
+
+def get_connection():
+    DB_DIR.mkdir(exist_ok=True)
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+def init_db():
+    conn = get_connection()
+    conn.executescript("""
+        CREATE TABLE IF NOT EXISTS entries (
+            id        INTEGER PRIMARY KEY AUTOINCREMENT,
+            timestamp TEXT NOT NULL,
+            category  TEXT NOT NULL DEFAULT 'general',
+            title     TEXT,
+            content   TEXT NOT NULL,
+            mood      TEXT,
+            tags      TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_timestamp ON entries(timestamp);
+        CREATE INDEX IF NOT EXISTS idx_category  ON entries(category);
+    """)
+    conn.commit()
+    conn.close()
+
+def add_entry(content: str, category: str = "general",
+              title: str = None, mood: str = None, tags: list = None):
+    conn = get_connection()
+    timestamp = datetime.now().isoformat(sep=" ", timespec="seconds")
+    tags_str = ",".join(tags) if tags else None
+    conn.execute(
+        "INSERT INTO entries (timestamp, category, title, content, mood, tags) "
+        "VALUES (?, ?, ?, ?, ?, ?)",
+        (timestamp, category, title, content, mood, tags_str)
+    )
+    conn.commit()
+    conn.close()
+
+def get_entries(limit: int = 20, category: str = None,
+                search: str = None, date: str = None):
+    conn = get_connection()
+    query = "SELECT * FROM entries WHERE 1=1"
+    params = []
+    if category:
+        query += " AND category = ?"
+        params.append(category)
+    if search:
+        query += " AND (content LIKE ? OR title LIKE ? OR tags LIKE ?)"
+        params += [f"%{search}%", f"%{search}%", f"%{search}%"]
+    if date:
+        query += " AND timestamp LIKE ?"
+        params.append(f"{date}%")
+    query += " ORDER BY timestamp DESC LIMIT ?"
+    params.append(limit)
+    rows = conn.execute(query, params).fetchall()
+    conn.close()
+    return rows
+
+def get_stats():
+    conn = get_connection()
+    stats = {}
+    stats["total"] = conn.execute("SELECT COUNT(*) FROM entries").fetchone()[0]
+    stats["by_category"] = conn.execute(
+        "SELECT category, COUNT(*) as n FROM entries GROUP BY category"
+    ).fetchall()
+    stats["first_entry"] = conn.execute(
+        "SELECT timestamp FROM entries ORDER BY timestamp ASC LIMIT 1"
+    ).fetchone()
+    conn.close()
+    return stats

chronicle_log-0.1.0/chronicle/export.py

@@ -0,0 +1,38 @@
+# chronicle/export.py
+from datetime import datetime
+import json
+from pathlib import Path
+
+def export_markdown(entries, filename: str = "chronicle_export") -> str:
+    """Export all entries as a Markdown document — book-ready format."""
+    lines = [
+        "# Chronicle — Founder's Logbook\n",
+        f"*Exported: {datetime.now().strftime('%B %d, %Y at %H:%M')}*\n",
+        "---\n"
+    ]
+    current_date = None
+    for e in reversed(list(entries)):  # Chronological order for export
+        entry_date = e["timestamp"][:10]
+        if entry_date != current_date:
+            current_date = entry_date
+            lines.append(f"\n## {entry_date}\n")
+        if e["title"]:
+            lines.append(f"### {e['title']}\n")
+        lines.append(f"**[{e['category'].upper()}]** — *{e['timestamp'][11:]}*\n")
+        if e["mood"]:
+            lines.append(f"*Mood: {e['mood']}*\n")
+        lines.append(f"\n{e['content']}\n")
+        if e["tags"]:
+            lines.append(f"\n*Tags: {e['tags']}*\n")
+        lines.append("\n---\n")
+
+    path = Path(f"{filename}.md")
+    path.write_text("\n".join(lines), encoding="utf-8")
+    return str(path)
+
+def export_json(entries, filename: str = "chronicle_export") -> str:
+    """Export as structured JSON."""
+    data = [dict(e) for e in entries]
+    path = Path(f"{filename}.json")
+    path.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+    return str(path)

chronicle_log-0.1.0/chronicle/main.py

@@ -0,0 +1,140 @@
+# chronicle/main.py
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from typing import Optional, List
+from chronicle.db import init_db, add_entry, get_entries, get_stats
+from chronicle.export import export_markdown, export_json
+
+app = typer.Typer(
+    name="chronicle",
+    help="📖 Chronicle — Log your founder journey, one entry at a time.",
+    add_completion=False
+)
+console = Console()
+
+CATEGORIES = ["idea", "build", "learn", "fail", "win", "research", "general"]
+MOODS = ["🔥 fire", "😤 grind", "😌 calm", "😩 stuck", "🎯 focused", "🤔 thinking"]
+
+@app.callback(invoke_without_command=True)
+def startup(ctx: typer.Context):
+    init_db()
+    if ctx.invoked_subcommand is None:
+        console.print(Panel(
+            "[bold cyan]Chronicle[/bold cyan] — Your founder's logbook\n"
+            "[dim]Run [bold]chronicle --help[/bold] to see all commands[/dim]",
+            border_style="cyan"
+        ))
+
+@app.command("log")
+def log_entry(
+    content: str = typer.Argument(..., help="Your log entry"),
+    category: str = typer.Option("general", "-c", "--category",
+                                  help=f"Category: {', '.join(CATEGORIES)}"),
+    title: Optional[str] = typer.Option(None, "-t", "--title", help="Optional title"),
+    mood: Optional[str] = typer.Option(None, "-m", "--mood", help="Your mood/energy"),
+    tags: Optional[List[str]] = typer.Option(None, "--tag", help="Add tags (repeat for multiple)")
+):
+    """📝 Log a new entry."""
+    add_entry(content, category=category, title=title, mood=mood, tags=tags)
+    console.print(f"[green]✓[/green] Entry logged under [bold]{category}[/bold]")
+
+@app.command("idea")
+def log_idea(content: str = typer.Argument(..., help="Your idea")):
+    """💡 Quick-log an idea."""
+    add_entry(content, category="idea")
+    console.print("[yellow]💡[/yellow] Idea captured.")
+
+@app.command("win")
+def log_win(content: str = typer.Argument(..., help="What did you achieve?")):
+    """🏆 Log a win, no matter how small."""
+    add_entry(content, category="win")
+    console.print("[bold green]🏆 WIN logged. Keep going.[/bold green]")
+
+@app.command("fail")
+def log_fail(content: str = typer.Argument(..., help="What went wrong?")):
+    """📉 Log a failure or lesson learned."""
+    add_entry(content, category="fail")
+    console.print("[dim red]📉 Failure logged. This is data, not defeat.[/dim red]")
+
+@app.command("show")
+def show_entries(
+    limit: int = typer.Option(10, "-n", "--limit", help="Number of entries to show"),
+    category: Optional[str] = typer.Option(None, "-c", "--category"),
+    search: Optional[str] = typer.Option(None, "-s", "--search"),
+    date: Optional[str] = typer.Option(None, "-d", "--date", help="Filter by date: YYYY-MM-DD")
+):
+    """📋 Show your log entries."""
+    entries = get_entries(limit=limit, category=category, search=search, date=date)
+    if not entries:
+        console.print("[dim]No entries found.[/dim]")
+        return
+
+    table = Table(show_header=True, header_style="bold cyan",
+                  border_style="dim", expand=True)
+    table.add_column("ID", style="dim", width=4)
+    table.add_column("Timestamp", style="dim", width=20)
+    table.add_column("Category", width=10)
+    table.add_column("Title / Content")
+    table.add_column("Tags", style="dim", width=20)
+
+    CATEGORY_COLORS = {
+        "idea": "yellow", "build": "cyan", "learn": "blue",
+        "fail": "red", "win": "green", "research": "magenta", "general": "white"
+    }
+
+    for e in entries:
+        color = CATEGORY_COLORS.get(e["category"], "white")
+        display = e["title"] if e["title"] else (
+            e["content"][:70] + "..." if len(e["content"]) > 70 else e["content"]
+        )
+        table.add_row(
+            str(e["id"]),
+            e["timestamp"],
+            f"[{color}]{e['category']}[/{color}]",
+            display,
+            e["tags"] or ""
+        )
+    console.print(table)
+
+@app.command("stats")
+def show_stats():
+    """📊 Show your journey statistics."""
+    stats = get_stats()
+    first = stats["first_entry"]["timestamp"] if stats["first_entry"] else "N/A"
+    console.print(Panel(
+        f"[bold]Total Entries:[/bold] {stats['total']}\n"
+        f"[bold]Journey Started:[/bold] {first}",
+        title="[bold cyan]Chronicle Stats[/bold cyan]",
+        border_style="cyan"
+    ))
+    if stats["by_category"]:
+        table = Table(show_header=True, header_style="bold", border_style="dim")
+        table.add_column("Category")
+        table.add_column("Entries", justify="right")
+        for row in stats["by_category"]:
+            table.add_row(row["category"], str(row["n"]))
+        console.print(table)
+
+@app.command("export")
+def export_entries(
+    format: str = typer.Option("markdown", "-f", "--format",
+                                help="Export format: markdown | json"),
+    output: str = typer.Option("chronicle_export", "-o", "--output",
+                                help="Output filename (no extension)")
+):
+    """📤 Export your log to Markdown or JSON."""
+    entries = get_entries(limit=99999)
+    if format == "markdown":
+        path = export_markdown(entries, output)
+    elif format == "json":
+        path = export_json(entries, output)
+    else:
+        console.print("[red]Unknown format. Use 'markdown' or 'json'[/red]")
+        return
+    console.print(f"[green]✓[/green] Exported to [bold]{path}[/bold]")
+
+if __name__ == "__main__":
+    app()

chronicle_log-0.1.0/chronicle_log.egg-info/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: chronicle-log
+Version: 0.1.0
+Summary: A CLI logbook for founders, builders, and creators.
+Author-email: Your Name <you@example.com>
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9
+Requires-Dist: rich>=13
+
+# Chronicle 📖
+
+> Log the journey. Tell the story.
+
+Chronicle is a minimal CLI logbook built for founders, builders, and solo makers.
+Log your ideas, wins, failures, and progress — with accurate timestamps — as you build.
+
+## Install
+
+pip install chronicle-log
+
+## Usage
+
+chronicle log "Had a breakthrough on the auth flow" -c build
+chronicle idea "What if we added voice logging via whisper?"
+chronicle win "First real user signed up"
+chronicle fail "Shipped a bug that deleted sessions. Lesson: always backup."
+chronicle show --limit 20
+chronicle stats
+chronicle export --format markdown
+
+## Why?
+
+Built by a founder, for founders. Every entry you make today
+becomes the raw material of the story you'll tell tomorrow.
+
+## License
+
+MIT — free forever.

chronicle_log-0.1.0/chronicle_log.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+chronicle/__init__.py
+chronicle/db.py
+chronicle/export.py
+chronicle/main.py
+chronicle_log.egg-info/PKG-INFO
+chronicle_log.egg-info/SOURCES.txt
+chronicle_log.egg-info/dependency_links.txt
+chronicle_log.egg-info/entry_points.txt
+chronicle_log.egg-info/requires.txt
+chronicle_log.egg-info/top_level.txt
+tests/test_db.py

chronicle_log-0.1.0/chronicle_log.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chronicle_log-0.1.0/chronicle_log.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+chronicle = chronicle.main:app

chronicle_log-0.1.0/chronicle_log.egg-info/requires.txt

@@ -0,0 +1,2 @@
+typer>=0.9
+rich>=13

chronicle_log-0.1.0/chronicle_log.egg-info/top_level.txt

@@ -0,0 +1 @@
+chronicle

chronicle_log-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+# pyproject.toml
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "chronicle-log"
+version = "0.1.0"
+description = "A CLI logbook for founders, builders, and creators."
+authors = [{ name = "Your Name", email = "you@example.com" }]
+license = { text = "MIT" }
+requires-python = ">=3.9"
+dependencies = ["typer>=0.9", "rich>=13"]
+readme = "README.md"
+
+[project.scripts]
+chronicle = "chronicle.main:app"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["chronicle*"]

chronicle_log-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

chronicle_log-0.1.0/tests/test_db.py

@@ -0,0 +1,26 @@
+# tests/test_db.py
+import os, pytest
+from pathlib import Path
+
+# Override DB path for tests
+import chronicle.db as db
+db.DB_PATH = Path("/tmp/test_chronicle.db")
+
+from chronicle.db import init_db, add_entry, get_entries
+
+def setup_function():
+    if db.DB_PATH.exists():
+        db.DB_PATH.unlink()
+    init_db()
+
+def test_add_and_retrieve():
+    add_entry("Test entry", category="build")
+    entries = get_entries(limit=1)
+    assert len(entries) == 1
+    assert entries[0]["content"] == "Test entry"
+    assert entries[0]["category"] == "build"
+
+def test_search():
+    add_entry("Implemented OAuth", category="build", tags=["auth", "security"])
+    entries = get_entries(search="OAuth")
+    assert any("OAuth" in e["content"] for e in entries)