doclogs-cli 0.1.0__tar.gz

doclogs_cli-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,115 @@
+# 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/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)

doclogs_cli-0.1.0/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)

doclogs_cli-0.1.0/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)")

doclogs_cli-0.1.0/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}")

doclogs_cli-0.1.0/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/doclogs_cli.egg-info/PKG-INFO

@@ -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/doclogs_cli.egg-info/SOURCES.txt

@@ -0,0 +1,34 @@
+LICENSE
+README.md
+main.py
+pyproject.toml
+commands/__init__.py
+commands/capture.py
+commands/config.py
+commands/generate.py
+commands/sanitize.py
+commands/weekly.py
+doclogs_cli.egg-info/PKG-INFO
+doclogs_cli.egg-info/SOURCES.txt
+doclogs_cli.egg-info/dependency_links.txt
+doclogs_cli.egg-info/entry_points.txt
+doclogs_cli.egg-info/requires.txt
+doclogs_cli.egg-info/top_level.txt
+helper/__init__.py
+helper/capture.py
+helper/capture_prompts.py
+helper/entry.py
+helper/generate.py
+helper/git_collector.py
+helper/paths.py
+helper/prompts.py
+helper/sanitize.py
+helper/story.py
+helper/task_notes.py
+helper/weekly.py
+helper/templates/blog.md
+helper/templates/changelog.md
+helper/templates/config.yaml
+helper/templates/interview.md
+helper/templates/linkedin.md
+helper/templates/resume.md

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

@@ -0,0 +1 @@
+

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

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

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

@@ -0,0 +1,2 @@
+typer>=0.10.0
+PyYAML>=6.0

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

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