doclogs-cli 0.1.0__py3-none-any.whl

commands/capture.py

@@ -0,0 +1,51 @@
+import typer
+from typing import Optional
+
+from helper.capture import build_capture_entry, merge_notes
+from helper.capture_prompts import iter_interactive_tasks
+from helper.entry import save_entry
+from helper.git_collector import find_git_root
+
+
+def _print_summary(entry, path) -> None:
+    typer.echo(f"\n📥 Captured to {path}")
+    typer.echo(f"   branch: {entry.branch or 'n/a'}")
+    typer.echo(f"   commits today: {len(entry.commits)}")
+
+
+def register(app: typer.Typer):
+
+    @app.command("capture", help="Capture today's engineering work into local storage.")
+    def capture(
+        notes: Optional[str] = typer.Option(None, "-n", "--notes", help="Optional notes (skips interactive prompts)."),
+        no_interactive: bool = typer.Option(False, "--no-interactive", help="Skip questions; git-only capture."),
+        include_terminal: bool = typer.Option(False, help="Include optional terminal history evidence."),
+        include_tickets: bool = typer.Option(False, help="Include optional ticket IDs or issue references."),
+    ) -> None:
+        if find_git_root() is None:
+            typer.echo("⚠️  Not inside a git repo — git evidence will be empty.")
+
+        # Interactive: multiple tasks in one session
+        if not no_interactive and notes is None:
+            path = None
+            entry = None
+            saved_any = False
+
+            for batch, replace in iter_interactive_tasks():
+                entry = build_capture_entry(notes=batch, replace_notes=replace)
+                path = save_entry(entry)
+                saved_any = True
+                typer.echo("   ✓ Task saved" if not replace else "   ✓ Task updated")
+
+            if not saved_any:
+                entry = build_capture_entry(notes=None)
+                path = save_entry(entry)
+
+            _print_summary(entry, path)
+            return
+
+        # Non-interactive: git only or single --notes
+        final_notes = merge_notes(notes)
+        entry = build_capture_entry(notes=final_notes)
+        path = save_entry(entry)
+        _print_summary(entry, path)

commands/config.py

@@ -0,0 +1,28 @@
+import typer
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+from helper.paths import config_path, ensure_config
+
+
+def load_config(path: Path | None = None) -> dict[str, object]:
+    config_file = path or ensure_config()
+    if not config_file.exists():
+        raise typer.Exit(code=1, message=f"Config file not found: {config_file}")
+    with config_file.open("r", encoding="utf-8") as stream:
+        return yaml.safe_load(stream) or {}
+
+
+def register(app: typer.Typer):
+
+    @app.command("config", help="Show the active DocLogs configuration.")
+    def config(
+        path: Optional[Path] = typer.Option(None, "-c", "--config", help="Path to the config file."),
+    ) -> None:
+        """Print the active DocLogs configuration."""
+        active = path or ensure_config()
+        settings = load_config(active)
+        typer.echo(f"Active DocLogs configuration ({active}):")
+        typer.echo(settings)

commands/generate.py

@@ -0,0 +1,49 @@
+import re
+
+import typer
+from typing import Optional
+
+from helper.generate import build_prompt
+from helper.paths import posts_dir
+from helper.story import find_story_text
+
+
+def slugify(text: str) -> str:
+    text = text.strip().lower()
+    text = re.sub(r"[^\w\s-]", "", text)
+    return re.sub(r"[-\s]+", "-", text).strip("-")
+
+
+def register(app: typer.Typer):
+
+    @app.command("generate", help="Generate a reusable artifact from a captured story.")
+    def generate(
+        artifact_type: str = typer.Argument(..., help="blog, linkedin, resume, interview, changelog"),
+        title: Optional[str] = typer.Option(None, "-t", "--title", help="Story title from doclog weekly."),
+        days: int = typer.Option(7, help="Days back to search for the story."),
+    ) -> None:
+        if not title:
+            typer.echo("Pass a story title: doclog generate blog -t \"Phase 0 completed\"")
+            raise typer.Exit(code=1)
+
+        story = find_story_text(title, days=days)
+        if not story:
+            typer.echo(f"Story not found: {title!r}")
+            typer.echo("Run doclog weekly to see available titles.")
+            raise typer.Exit(code=1)
+
+        prompt, findings, flags = build_prompt(artifact_type, story)
+
+        if flags:
+            typer.echo("⚠️  Sensitive patterns flagged — review before sending to an LLM:")
+            for flag in flags:
+                typer.echo(f"  - [{flag.kind}] {flag.matched[:60]}")
+
+        output_dir = posts_dir()
+        output_dir.mkdir(parents=True, exist_ok=True)
+        out = output_dir / f"{slugify(title)}-{artifact_type}.md"
+        out.write_text(prompt, encoding="utf-8")
+
+        typer.echo(f"✨ Prompt saved to {out}")
+        if findings:
+            typer.echo(f"   ({len(findings)} item(s) redacted in evidence)")

commands/sanitize.py

@@ -0,0 +1,33 @@
+import typer
+from typing import *
+
+from helper.entry import entry_path_for, load_entry
+from helper.sanitize import redact, sanitize_with_review, text_from_entry
+
+
+def register(app: typer.Typer):
+
+    @app.command("sanitize",  help="Sanitize content before sending to an LLM.")
+    def sanitize(
+        source: Optional[str] = typer.Argument(None, help="Text to sanitize. If omitted, uses today's capture."),
+    ) -> None:
+        if source:
+            text = source
+        else:
+            entry = load_entry(entry_path_for())
+            if not entry:
+                typer.echo("No capture for today. Run: doclog capture")
+                raise typer.Exit(code=1)
+            text = text_from_entry(entry)
+        sanitized, findings, flags = sanitize_with_review(text)
+        typer.echo("🔒 Sanitized output:\n")
+        typer.echo(sanitized)
+        if findings:
+            typer.echo(f"\n({len(findings)} item(s) redacted)")
+        else:
+            typer.echo("\n(no sensitive patterns detected)")
+        if flags:
+            typer.echo("\n⚠️  Review before sending to LLM:")
+            for flag in flags:
+                snippet = flag.matched[:60] + ("..." if len(flag.matched) > 60 else "")
+                typer.echo(f"  - [{flag.kind}] {snippet}")

commands/weekly.py

@@ -0,0 +1,27 @@
+from ast import Return
+import typer
+from typing import *
+from helper.weekly import build_story_candidates, load_entries_for_days
+
+
+def register(app: typer.Typer):
+
+    @app.command("weekly", help="run workflows")
+    def weekly(
+        limit: int = typer.Option(5, help="Maximum number of story candidates to display."),
+        days: int = typer.Option(7, help="How many days back to review.")
+        ) -> None:
+        """Summarize the week and surface candidate stories for expansion."""
+        entries = load_entries_for_days(days)
+        if not entries:
+            typer.echo(f"📅 No captures found in the last {days} days.")
+            typer.echo('Run: doclog capture --notes "what you worked on today"')
+            return
+        typer.echo(f"📅 Weekly summary ({len(entries)} day(s) captured)")
+        candidates = build_story_candidates(entries, limit=limit)
+
+        if not candidates:
+            typer.echo("No story candidates yet.")
+            return
+        for i, story in enumerate(candidates, start=1):
+            typer.echo(f"{i}. [{story.source}] {story.title} ({story.date})")

doclogs_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: doclogs-cli
+Version: 0.1.0
+Summary: CLI for capturing engineering work and turning it into career artifacts.
+Author: Mridul Tiwari
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/MridulTi/DocLogs
+Project-URL: Repository, https://github.com/MridulTi/DocLogs
+Project-URL: Issues, https://github.com/MridulTi/DocLogs/issues
+Keywords: cli,engineering,career,devlog,documentation,resume
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.10.0
+Requires-Dist: PyYAML>=6.0
+Dynamic: license-file
+
+# DocLogs
+
+DocLogs is an engineer career operating system for capturing and reusing technical work.
+
+## What it solves
+
+Engineers do valuable work every day: incident response, CI/CD and platform debugging, automation, infrastructure changes, PR reviews, and migrations. Most of that work is forgotten when it matters most: performance reviews, promotion packets, interviews, and professional storytelling.
+
+DocLogs helps you turn day-to-day engineering activity into durable artifacts by:
+
+- capturing evidence automatically from git, branches, PRs, and optional histories
+- summarizing weekly progress and surfacing strong stories
+- generating markdown artifacts for blog posts, LinkedIn, resumes, and interview prep
+- keeping model usage provider-agnostic and safe with sanitization
+
+## Core commands
+
+- `doclog capture`
+  - collect commits, repository activity, PR titles, tickets, and optional notes
+  - store structured daily entries in local storage
+- `doclog weekly`
+  - review weekly work
+  - surface candidate stories worth expanding
+- `doclog generate <type>`
+  - create reusable artifacts such as `blog`, `linkedin`, `resume`, `interview`, or `changelog`
+- `doclog sanitize`
+  - sanitize captured content before any LLM request
+  - redact internal URLs, tokens, IP addresses, and other sensitive details
+
+## Recommended repository structure
+
+```
+./
+├── README.md
+├── config.yaml
+├── commands/
+│   ├── capture.py
+│   └── config.py
+├── docs/
+│   ├── vision.md
+│   └── architecture.md
+├── doclog/
+│   ├── entries/
+│   ├── posts/
+│   └── cache/
+├── prompts/
+│   ├── blog.md
+│   ├── linkedin.md
+│   └── resume.md
+└── .copilot
+```
+
+## Architecture overview
+
+DocLogs keeps the capture layer local and the generation layer model-agnostic. It is intentionally not a scheduler; use OS-level schedulers like `cron`, `systemd --user`, `launchd`, or Task Scheduler to invoke `doclog capture` at reminder times.
+
+For implementation, start by focusing on:
+
+1. evidence collection and local storage
+2. weekly summaries and story selection
+3. safe prompt generation
+4. provider adapters for OpenAI, Ollama, Anthropic, Gemini, or other APIs
+
+## Getting started
+
+### Install from PyPI
+
+```bash
+pip install doclogs-cli
+doclog --help
+```
+
+### Install from source (development)
+
+```bash
+git clone https://github.com/MridulTi/DocLogs.git
+cd DocLogs
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+doclog --help
+```
+
+### First run
+
+Data is stored under `~/.doclog/` (entries, posts, config). On first use, a default `config.yaml` is created there.
+
+To keep using a project-local folder instead:
+
+```bash
+export DOCLOG_HOME="$PWD/doclog"
+doclog capture
+```
+
+### Daily use
+
+1. Configure `~/.doclog/config.yaml` with your preferred LLM provider (created automatically on first run).
+2. Add a scheduler entry outside the CLI to invoke `doclog capture` at your preferred check-in time.
+3. Capture daily progress and generate reusable career artifacts from the same captured story.
+
+## Publish to PyPI (GitHub Actions)
+
+Publishing runs via GitHub Actions — no local `twine upload` needed.
+
+1. Configure [trusted publishing](docs/publishing.md) on PyPI (leave Environment blank)
+2. Push a version tag:
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+The workflow uploads to PyPI automatically.
+
+See [docs/publishing.md](docs/publishing.md) for full setup.

doclogs_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+main.py,sha256=jTskRCW2BEl8GBNzN7PM8QgoQmTsMsiwYrOnHidOdpE,643
+commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+commands/capture.py,sha256=5pXv5wUwv_yvAa6W6HVOeqEOKXbkiedshKMGWNBuWeI,2067
+commands/config.py,sha256=KEwcFrcW_SpXvoI3B4Hq6ejIoGRoZcoHqYbxX2Lobug,928
+commands/generate.py,sha256=Af4YQC0mNwqgRukE6k4QunE-Jx6wM9LL_lRCSf75xNU,1796
+commands/sanitize.py,sha256=2P9NwDPxcfkw_uHZRE7DtFgW2t_wU9_99YhdezSD1_k,1275
+commands/weekly.py,sha256=iorqg59_KHbLQOtZ7BtleOxYJPMi93pNNP4nxIw6zwo,1112
+doclogs_cli-0.1.0.dist-info/licenses/LICENSE,sha256=Qt8MKT0gY0r-pDAO1zEWfB7YHPycn9Bsy7YUDwF8daQ,1070
+helper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+helper/capture.py,sha256=pWYNYLFsLZ2I5QvujB-spRVSxAYMnDOKr5_x-5bDwjM,1101
+helper/capture_prompts.py,sha256=OdGZXZKUufC5GuXYhpGBWbxN7VSJGzt5_0heQSyp8q0,3309
+helper/entry.py,sha256=MpZJWtfIgE0cgbVXFoKfDu1vy2ZbQZwGfZ-DaT8KDcU,3055
+helper/generate.py,sha256=1KN8NXEaYwjoiojyADTlU18G65GuNo29fMKFp1pPIPM,503
+helper/git_collector.py,sha256=h494_kU8IrjuK-P-mnXt_5u363sOWe7CfBLjZtImqeI,2056
+helper/paths.py,sha256=R2DtaomwTTwk72_5coPrsiezTwK4qYmy74SbTFPq_iM,1252
+helper/prompts.py,sha256=wpDeHI3LFkPmtPkJ82BDUK5RRcp6ppnkFzIRmIoQIoc,581
+helper/sanitize.py,sha256=GlBvw1XHJ5N7-LGrdUcuYpPmxtYaat4uPWeWewf_V2g,2576
+helper/story.py,sha256=gBbKvRDRw4mWW4xYyh2uU53TLkTNvr9btW6vPPp-YOc,1039
+helper/task_notes.py,sha256=LTPlgmcCzP3jGuIvIFEUB-_p-_Nc7L-j3b2VK4p2JDQ,2155
+helper/weekly.py,sha256=W1dNO1nKzrmScf7xFQg1ZyDfYnqLH4W6rKthKMzulL0,1815
+helper/templates/blog.md,sha256=W5sWQNpt11AqjS98KBKP89y5_pyJgWOKrtA3CgklWt4,304
+helper/templates/changelog.md,sha256=L-xYIIljpT-05LOUxNvbZCKaVyZI6pdN5ftZm2isqiQ,245
+helper/templates/config.yaml,sha256=zCCz1OHFyslfmEy-wJDx5ozDlTdINKTg-phoR4RNmws,299
+helper/templates/interview.md,sha256=CyiCFBH0FRH7_5oUFIyEgMTVFIcrc1gjzgB8x6S9xVM,266
+helper/templates/linkedin.md,sha256=IjQGUl6D_87DTGukattkEVSbTe5UV-Rqo0G1hXz9q7s,273
+helper/templates/resume.md,sha256=oiodoV7cwGqutfUTaHH9S03ThhUrNPR9GEL_Rzwz_Vw,252
+doclogs_cli-0.1.0.dist-info/METADATA,sha256=_QaR81UqPseuFAeXkYCMkjbzu4fEyesGaI-mgdzsJb0,4488
+doclogs_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+doclogs_cli-0.1.0.dist-info/entry_points.txt,sha256=YqI5Rro1m2_IyiYM1Jass0Bi9JCjHP3efl6DodoYtYQ,36
+doclogs_cli-0.1.0.dist-info/top_level.txt,sha256=FrdyAb6CbIi41Ma541tC-chBEt2lsWjGA__Tff-wWhc,21
+doclogs_cli-0.1.0.dist-info/RECORD,,

doclogs_cli-0.1.0.dist-info/WHEEL

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

doclogs_cli-0.1.0.dist-info/entry_points.txt

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

doclogs_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mridul Tiwari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

doclogs_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+commands
+helper
+main

helper/capture.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from helper.entry import (
+    entry_path_for,
+    load_entry,
+    new_empty_entry,
+)
+from helper.git_collector import enrich_entry_from_git
+
+
+def merge_notes(*parts: str | None) -> str | None:
+    chunks = [p.strip() for p in parts if p and p.strip()]
+    if not chunks:
+        return None
+    return "\n\n".join(chunks)
+
+
+def build_capture_entry(notes: str | None = None, *, replace_notes: bool = False):
+    path = entry_path_for()
+    existing = load_entry(path)
+
+    entry = new_empty_entry()
+    entry = enrich_entry_from_git(entry)
+
+    if existing:
+        entry.pr_titles = existing.pr_titles
+        entry.ticket_ids = existing.ticket_ids
+
+    if replace_notes:
+        entry.notes = notes
+        return entry
+
+    if notes:
+        if existing and existing.notes:
+            if notes not in existing.notes:
+                entry.notes = f"{existing.notes}\n\n{notes}"
+            else:
+                entry.notes = existing.notes
+        else:
+            entry.notes = notes
+    elif existing:
+        entry.notes = existing.notes
+
+    return entry

helper/capture_prompts.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import typer
+import re
+
+from helper.entry import entry_path_for, load_entry
+from helper.task_notes import complete_task, list_incomplete_tasks
+
+def maybe_complete_stub() -> str | None:
+    entry = load_entry(entry_path_for())
+    if not entry or not entry.notes:
+        return None
+    pending = list_incomplete_tasks(entry.notes)
+    if not pending:
+        return None
+    typer.echo("\n📝 Incomplete tasks from today:\n")
+    for num, summary in pending:
+        typer.echo(f"  {num}. {summary[:70]}{'...' if len(summary) > 70 else ''}")
+    if not typer.confirm("\nAdd details to one of these?", default=True):
+        return None
+    choice = typer.prompt("Task number", default=str(pending[0][0])).strip()
+    task_num = int(choice)
+    typer.echo("\n--- Completing task ---\n")
+    followup = collect_followup_notes()
+    if not followup:
+        return None
+    return complete_task(entry.notes, task_num, followup)
+
+
+
+# (stored label, prompt shown to user, required)
+CAPTURE_QUESTIONS: list[tuple[str, str, bool]] = [
+    ("worked_on", "What did you work on today?", True),
+    ("impact", "What was the impact or outcome?", False),
+    ("blockers", "Any blockers, incidents, or debugging?", False),
+    ("remember", "Anything worth remembering for later?", False),
+]
+
+FOLLOWUP_QUESTIONS: list[tuple[str, str]] = [
+    ("impact", "What was the impact or outcome?"),
+    ("blockers", "Any blockers, incidents, or debugging?"),
+    ("remember", "Anything worth remembering for later?"),
+]
+
+def collect_followup_notes() -> str | None:
+    lines: list[str] = []
+    for key, prompt in FOLLOWUP_QUESTIONS:
+        answer = typer.prompt(prompt, default="").strip()
+        if answer:
+            lines.append(f"{key}: {answer}")
+    lines.append("status: complete")
+    return "\n".join(lines) if lines else None
+
+def _next_task_number() -> int:
+    entry = load_entry(entry_path_for())
+    if not entry or not entry.notes:
+        return 1
+    nums = [int(n) for n in re.findall(r"### Task (\d+)", entry.notes)]
+    return max(nums, default=0) + 1
+
+
+def iter_interactive_tasks():
+    updated = maybe_complete_stub()
+    if updated:
+        yield updated, True   # ← replace entire notes
+    task_num = _next_task_number()
+    while True:
+        typer.echo(f"\n--- Task {task_num} ---\n")
+        batch = collect_interactive_notes()
+        if batch:
+            yield f"### Task {task_num}\n{batch}", False   # ← append new task
+        if not typer.confirm("Add another task?", default=False):
+            break
+        task_num += 1
+
+def collect_interactive_notes() -> str | None:
+    typer.echo("\n📋 Daily capture — answer briefly (Enter to skip optional questions)\n")
+
+    worked_on = typer.prompt("What did you work on today?", default="").strip()
+    if not worked_on:
+        return None
+
+    lines = [f"worked_on: {worked_on}"]
+
+    if typer.confirm("Add more details later?", default=False):
+        lines.append("status: details_later")
+        return "\n".join(lines)
+
+    for key, prompt, required in CAPTURE_QUESTIONS[1:]:  # skip worked_on, already asked
+        answer = typer.prompt(prompt, default="").strip()
+        if answer:
+            lines.append(f"{key}: {answer}")
+
+    lines.append("status: complete")
+    return "\n".join(lines)

helper/entry.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+from dataclasses import dataclass, field, asdict
+from datetime import date, timezone, datetime, timedelta
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from helper.paths import entries_dir
+
+SCHEMA_VERSION = 1
+
+
+@dataclass
+class GitCommit:
+    hash: str
+    subject: str
+    author: str
+    commited_at: str
+
+@dataclass
+class DailyEntry:
+    date: str  # YYYY-MM-DD
+    captured_at: str  # ISO 8601
+    schema_version: int = SCHEMA_VERSION
+    repository_path: str | None = None
+    branch: str | None = None
+    commits: list[GitCommit] = field(default_factory=list)
+    notes: str | None = None
+    pr_titles: list[str] = field(default_factory=list)
+    ticket_ids: list[str] = field(default_factory=list)
+
+
+def entry_path_for(day:date | None = None) -> Path:
+    day = day or date.today()
+    return entries_dir() / f"{day.isoformat()}.yaml"
+
+def new_empty_entry(notes: str | None = None) -> DailyEntry:
+    IST = timezone(timedelta(hours=5, minutes=30))
+    now = datetime.now(IST).replace(microsecond=0)
+    return DailyEntry(
+        date = now.date().isoformat(),
+        captured_at = now.isoformat(),
+        notes = notes,
+    )
+
+def entry_to_dict(entry: DailyEntry) -> dict[str, Any]:
+    data = asdict(entry)
+    return {
+        "schema_version": data["schema_version"],
+        "date": data["date"],
+        "captured_at": data["captured_at"],
+        "repository": {
+            "path": data["repository_path"],
+            "branch": data["branch"],
+        },
+        "git": {
+            "commits": data["commits"],
+        },
+        "manual": {
+            "notes": data["notes"],
+        },
+        "evidence": {
+            "pr_titles": data["pr_titles"],
+            "ticket_ids": data["ticket_ids"],
+        },
+    }
+
+def save_entry(entry: DailyEntry, path: Path | None = None) -> Path:
+    target = path or entry_path_for()
+    target.parent.mkdir(parents=True, exist_ok=True)
+    with target.open("w", encoding="utf-8") as stream:
+        yaml.safe_dump(
+            entry_to_dict(entry),
+            stream,
+            sort_keys=False,
+            allow_unicode=True,
+        )
+    return target
+
+def load_entry(path: Path | None=None)-> DailyEntry | None:
+    target = path or entry_path_for()
+    if not target.exists():
+        return None
+
+    with target.open('r',encoding='utf-8') as stream:
+        data = yaml.safe_load(stream)
+    if not data:
+        return None
+
+    commits =[
+        GitCommit(**commit)
+        for commit in data.get(f"git",{}).get("commits",[])
+    ]
+
+    return DailyEntry(
+        date=data["date"],
+        captured_at=data["captured_at"],
+        schema_version=data.get("schema_version", SCHEMA_VERSION),
+        repository_path=data.get("repository", {}).get("path"),
+        branch=data.get("repository", {}).get("branch"),
+        commits=commits,
+        notes=data.get("manual", {}).get("notes"),
+        pr_titles=data.get("evidence", {}).get("pr_titles", []),
+        ticket_ids=data.get("evidence", {}).get("ticket_ids", []),
+    )
+

helper/generate.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from helper.prompts import load_prompt
+from helper.sanitize import sanitize_with_review
+
+
+def build_prompt(artifact_type: str, story_text: str) -> tuple[str, list, list]:
+    template = load_prompt(artifact_type)
+    sanitized, findings, flags = sanitize_with_review(story_text)
+
+    final = (
+        f"{template.strip()}\n\n"
+        f"---\n\n"
+        f"## Captured evidence (sanitized)\n\n"
+        f"{sanitized.strip()}\n"
+    )
+    return final, findings, flags

helper/git_collector.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from datetime import date, timedelta
+from helper.entry import DailyEntry, GitCommit
+
+def _run_git(args: list[str],cwd: Path) -> str:
+    result = subprocess.run(
+        ["git", *args],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        return ""
+    return result.stdout.strip()
+
+def find_git_root(start: Path | None = None) -> Path | None:
+    start = start or Path.cwd()
+    output = _run_git(["rev-parse","--show-toplevel"],start)
+    return Path(output) if output else None
+
+def get_current_branch(repo_root: Path) -> str | None:
+    branch = _run_git(["rev-parse","--abbrev-ref","HEAD"],repo_root)
+    return branch or None
+
+
+def collect_commits_for_day(repo_root: Path, day: date | None=None) -> list[GitCommit]:
+    day = day or date.today()
+    since = f"{day.isoformat()} 00:00:00"
+    until = f"{(day + timedelta(days=1)).isoformat()} 00:00:00"
+    fmt = "%H|%s|%an|%aI"
+
+    output = _run_git(
+        [
+            "log",
+            f"--since={since}",
+            f"--until={until}",
+            f"--pretty=format:{fmt}",
+        ],
+        repo_root,
+    )
+
+    commits: list[GitCommit] =[]
+    for line in output.splitlines():
+        if not line:
+            continue
+        hash_,subject,author,commited_at = line.split("|",3)
+        commits.append(
+            GitCommit(
+                hash=hash_,
+                subject=subject,
+                author=author,
+                commited_at=commited_at
+            )
+        )
+    return commits
+
+def enrich_entry_from_git(entry: DailyEntry, repo_path: Path | None=None)-> DailyEntry:
+    start = repo_path or Path.cwd()
+    repo_root = find_git_root(start)
+    if repo_root is None:
+        return entry
+    entry.repository_path = str(repo_root)
+    entry.branch = get_current_branch(repo_root)
+    entry.commits = collect_commits_for_day(
+        repo_root,
+        date.fromisoformat(entry.date),
+    )
+    return entry

helper/paths.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import os
+import shutil
+from pathlib import Path
+
+PACKAGE_DIR = Path(__file__).resolve().parent
+TEMPLATES_DIR = PACKAGE_DIR / "templates"
+
+
+def doclog_home() -> Path:
+    override = os.environ.get("DOCLOG_HOME")
+    home = Path(override).expanduser() if override else Path.home() / ".doclog"
+    home.mkdir(parents=True, exist_ok=True)
+    return home
+
+
+def entries_dir() -> Path:
+    path = doclog_home() / "entries"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def posts_dir() -> Path:
+    path = doclog_home() / "posts"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def cache_dir() -> Path:
+    path = doclog_home() / "cache"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def prompts_dir() -> Path:
+    return TEMPLATES_DIR
+
+
+def config_path() -> Path:
+    return doclog_home() / "config.yaml"
+
+
+def default_config_path() -> Path:
+    return TEMPLATES_DIR / "config.yaml"
+
+
+def ensure_config() -> Path:
+    path = config_path()
+    if path.exists():
+        return path
+    default = default_config_path()
+    if default.exists():
+        shutil.copy(default, path)
+    else:
+        path.write_text("llm:\n  provider: openai\n", encoding="utf-8")
+    return path

helper/prompts.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from helper.paths import prompts_dir
+
+VALID_TYPES = {"blog", "linkedin", "resume", "interview", "changelog"}
+
+
+def load_prompt(artifact_type: str) -> str:
+    kind = artifact_type.strip().lower()
+    if kind not in VALID_TYPES:
+        raise ValueError(
+            f"Unknown artifact type: {artifact_type}. Choose from: {', '.join(sorted(VALID_TYPES))}"
+        )
+    path = prompts_dir() / f"{kind}.md"
+    if not path.exists():
+        raise FileNotFoundError(f"Prompt template not found: {path}")
+    return path.read_text(encoding="utf-8")

helper/sanitize.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+from dataclasses import dataclass
+import re
+
+from helper.entry import DailyEntry
+
+@dataclass
+class RedactionFinding:
+    kind: str
+    matched: str
+
+@dataclass
+class FlagFinding:
+    kind: str
+    matched: str
+
+
+
+# (name, regex pattern)
+PATTERNS: list[tuple[str, re.Pattern[str]]] = [
+    ("internal_url", re.compile(r"https?://[^\s]*\.(?:internal|corp|local)[^\s]*", re.I)),
+    ("private_ip", re.compile(r"\b(?:10|172\.(?:1[6-9]|2\d|3[01])|192\.168)\.\d{1,3}\.\d{1,3}\b")),
+    ("api_key", re.compile(r"\b(?:sk-[A-Za-z0-9]{20,}|AKIA[0-9A-Z]{16})\b")),
+    ("bearer_token", re.compile(r"\bBearer\s+[A-Za-z0-9\-._~+/]+=*\b", re.I)),
+]
+PLACEHOLDERS = {
+    "internal_url": "[REDACTED:internal_url]",
+    "private_ip": "[REDACTED:private_ip]",
+    "api_key": "[REDACTED:api_key]",
+    "bearer_token": "[REDACTED:token]",
+}
+
+FLAG_PATTERNS: list[tuple[str, re.Pattern[str]]] = [
+    ("email", re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b")),
+    ("password_assignment", re.compile(r"(?i)(password|passwd|secret|token)\s*[:=]\s*\S+")),
+    ("aws_account", re.compile(r"\b\d{12}\b")),  # 12-digit AWS account IDs
+]
+
+
+def redact(text:str)-> tuple(str, list[RedactionFinding]):
+    finding: list[RedactionFinding] = []
+    result = text
+
+    for (kind,pattern) in PATTERNS:
+        for match in pattern.findall(result):
+            finding.append(RedactionFinding(kind=kind, matched=match))
+            placeholder = PLACEHOLDERS.get(kind, "[REDACTED]")
+            result = result.replace(match,placeholder)
+    return result, finding
+
+
+def text_from_entry(entry: DailyEntry) -> str:
+    parts: list[str] = []
+    if entry.notes:
+        parts.append(entry.notes)
+    for commit in entry.commits:
+        parts.append(commit.subject)
+    return "\n".join(parts)
+
+
+def sanitize_entry(entry: DailyEntry) -> tuple[str, list[RedactionFinding]]:
+    return redact(text_from_entry(entry))
+
+def scan_flags(text:str) -> list[FlagFinding]:
+    flags:list[FlagFinding] = []
+    seen: set[str] = set()
+
+    for kind, pattern in FLAG_PATTERNS:
+        for match in pattern.findall(text):
+            matched = match if isinstance(match, str) else match[0]
+            key = matched.lower()
+            if key not in seen:
+                seen.add(key)
+                flags.append(FlagFinding(kind=kind, matched=matched))
+    return flags
+
+
+def sanitize_with_review(text: str) -> tuple(str, list[RedactionFinding], list[FlagFinding]):
+    sanitized, findings = redact(text)
+    flags = scan_flags(text)
+    return sanitized, findings, flags

helper/story.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from helper.task_notes import extract_worked_on, parse_task_blocks
+from helper.weekly import load_entries_for_days
+
+
+def find_story_text(title: str, days: int = 7) -> str | None:
+    needle = title.strip().lower()
+    if not needle:
+        return None
+
+    # Allow matching without [incomplete] suffix from weekly output
+    needle = needle.removesuffix(" [incomplete]").strip()
+
+    entries = load_entries_for_days(days)
+    for entry in entries:
+        for commit in entry.commits:
+            if commit.subject.strip().lower() == needle:
+                return (
+                    f"worked_on: {commit.subject}\n"
+                    f"commit: {commit.hash}\n"
+                    f"author: {commit.author}\n"
+                    f"committed_at: {commit.commited_at}"
+                )
+
+        for block in parse_task_blocks(entry.notes):
+            task_title = extract_worked_on(block)
+            if task_title and task_title.lower() == needle:
+                return block
+
+    return None

helper/task_notes.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import re
+
+DETAILS_LATER = "status: details_later"
+
+
+def parse_task_blocks(notes: str | None) -> list[str]:
+    """Split manual notes into task blocks (legacy block + ### Task N sections)."""
+    if not notes or not notes.strip():
+        return []
+    blocks = re.split(r"(?=### Task \d+)", notes.strip())
+    return [block.strip() for block in blocks if block.strip()]
+
+
+def extract_worked_on(block: str) -> str | None:
+    return _extract_worked_on(block)
+
+
+def list_incomplete_tasks(notes: str | None) -> list[tuple[int, str]]:
+    if not notes:
+        return []
+
+    results: list[tuple[int, str]] = []
+
+    for block in parse_task_blocks(notes):
+        if DETAILS_LATER not in block:
+            continue
+        match = re.search(r"### Task (\d+)", block)
+        task_num = int(match.group(1)) if match else 0
+        summary = _extract_worked_on(block) or (f"Task {task_num}" if task_num else "Incomplete entry")
+        results.append((task_num, summary))
+
+    return results
+
+
+def _extract_worked_on(block: str) -> str | None:
+    match = re.search(
+        r"worked_on:\s*(.+?)(?=\n(?:impact|blockers|remember|status:|### Task|\Z))",
+        block,
+        re.DOTALL,
+    )
+    if not match:
+        return None
+    return " ".join(match.group(1).split())  # flatten multiline YAML
+
+
+def complete_task(notes: str, task_num: int, followup: str) -> str:
+    if task_num == 0:
+        pattern = r"^.*?(status: details_later.*?)(?=\n### Task \d+|\Z)"
+        worked_on = _extract_worked_on(notes) or ""
+        new_block = f"worked_on: {worked_on}\n{followup}"
+    else:
+        pattern = rf"### Task {task_num}\n.*?(?=(?:\n### Task \d+|\Z))"
+        match = re.search(pattern, notes, re.DOTALL)
+        if not match:
+            raise ValueError(f"Task {task_num} not found")
+        worked_on = _extract_worked_on(match.group(0)) or ""
+        new_block = f"### Task {task_num}\nworked_on: {worked_on}\n{followup}"
+
+    match = re.search(pattern, notes, re.DOTALL)
+    if not match:
+        raise ValueError(f"Task {task_num} not found")
+
+    return notes[: match.start()] + new_block + notes[match.end() :]

helper/templates/blog.md

@@ -0,0 +1,9 @@
+# DocLogs Blog Prompt Template
+
+Use this template to turn a captured engineering story into a high-quality markdown blog post.
+
+- start with the problem or incident
+- explain how the issue was diagnosed
+- describe the fix or automation
+- share lessons learned
+- keep the audience technical and practical

helper/templates/changelog.md

@@ -0,0 +1,7 @@
+# DocLogs Changelog Prompt Template
+
+Use this template to write a concise changelog entry from captured engineering work.
+
+- summarize what changed for users or the team
+- group related changes when helpful
+- keep the tone factual and scannable

helper/templates/config.yaml

@@ -0,0 +1,20 @@
+# DocLogs configuration
+
+llm:
+  provider: openai
+
+openai:
+  model: gpt-4o-mini
+  api_key: "${OPENAI_API_KEY}"
+
+ollama:
+  endpoint: http://127.0.0.1:11434
+  model: "local-llm"
+
+anthropic:
+  model: claude-3
+  api_key: "${ANTHROPIC_API_KEY}"
+
+gemini:
+  model: gemini-pro
+  api_key: "${GEMINI_API_KEY}"

helper/templates/interview.md

@@ -0,0 +1,8 @@
+# DocLogs Interview Prompt Template
+
+Use this template to prepare interview talking points from an engineering story.
+
+- describe the situation and constraints
+- explain your specific contribution
+- highlight measurable outcomes
+- note what you would do differently

helper/templates/linkedin.md

@@ -0,0 +1,8 @@
+# DocLogs LinkedIn Prompt Template
+
+Use this template to create a concise, professional LinkedIn update from an engineering story.
+
+- mention the impact or result
+- highlight the challenge and solution
+- keep it human and outcome-focused
+- avoid sensitive internal details

helper/templates/resume.md

@@ -0,0 +1,8 @@
+# DocLogs Resume Prompt Template
+
+Use this template to convert a story into a strong resume or promotion bullet.
+
+- start with the action verb
+- quantify impact when possible
+- emphasize the technical achievement and result
+- keep it concise and clear

helper/weekly.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date, timedelta
+
+from helper.entry import DailyEntry, load_entry
+from helper.paths import entries_dir
+from helper.task_notes import DETAILS_LATER, extract_worked_on, parse_task_blocks
+
+
+@dataclass
+class StoryCandidate:
+    title: str
+    source: str
+    date: str
+
+
+def load_entries_for_days(days: int = 7) -> list[DailyEntry]:
+    entries: list[DailyEntry] = []
+    today = date.today()
+    for offset in range(days):
+        day = today - timedelta(days=offset)
+        path = entries_dir() / f"{day.isoformat()}.yaml"
+        entry = load_entry(path)
+        if entry:
+            entries.append(entry)
+    return entries
+
+
+def build_story_candidates(
+    entries: list[DailyEntry] | None = None,
+    limit: int = 5,
+) -> list[StoryCandidate]:
+    candidates: list[StoryCandidate] = []
+    seen: set[str] = set()
+
+    for entry in entries or []:
+        for commit in entry.commits:
+            title = commit.subject.strip()
+            key = title.lower()
+            if title and key not in seen:
+                seen.add(key)
+                candidates.append(
+                    StoryCandidate(title=title, source="commit", date=entry.date)
+                )
+
+        for block in parse_task_blocks(entry.notes):
+            title = extract_worked_on(block)
+            if not title:
+                continue
+            key = title.lower()
+            if key in seen:
+                continue
+            seen.add(key)
+            if DETAILS_LATER in block:
+                title = f"{title} [incomplete]"
+            candidates.append(
+                StoryCandidate(title=title, source="task", date=entry.date)
+            )
+
+        if len(candidates) >= limit:
+            break
+
+    return candidates[:limit]

main.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from pathlib import Path
+import importlib
+import typer
+
+
+app = typer.Typer(help="DocLogs CLI: capture engineering activity, review weekly progress, and generate reusable career artifacts.")
+
+COMMANDS_DIR = Path(__file__).resolve().parent / "commands"
+
+def discover_commands():
+    for path in COMMANDS_DIR.iterdir():
+        if path.is_file() and path.suffix == ".py" and path.name != "__init__.py":
+            module=importlib.import_module(f"commands.{path.stem}")
+            if hasattr(module,"register"):
+                module.register(app)
+
+discover_commands()
+
+if __name__ == "__main__":
+    app()