devcommit 0.1.5.4__py3-none-any.whl → 0.1.5.6__py3-none-any.whl

devcommit/app/changelog.py

@@ -2,11 +2,28 @@
 """Generate changelog files from git diffs using AI"""
 
 import os
+import re
 from datetime import datetime
+from typing import List, Tuple
 
 from devcommit.app.ai_providers import get_ai_provider
+from devcommit.utils.git import get_current_branch
 from devcommit.utils.logger import config
 
+PLACEHOLDER_LINES = {
+    "list new features",
+    "list changes to existing functionality",
+    "list bug fixes",
+    "list removed features",
+    "none",
+    "n/a",
+    "na",
+    "no changes",
+}
+
+DEFAULT_CHANGELOG_MODE = "timestamped"
+BRANCH_CHANGELOG_MODES = {"branch", "branch_single", "single", "per_branch"}
+
 
 def generate_changelog_prompt() -> str:
     """Generate the prompt for changelog creation"""
@@ -19,25 +36,295 @@ Follow these guidelines:
 4. Group related changes together
 5. Focus on what changed from a user/developer perspective
 6. Be concise but informative
+7. Include only sections that have real content
+8. Use ## [Unreleased] only when it contains at least one non-empty subsection
 
 Format:
 # Changelog
 
-## [Unreleased]
+## [Unreleased] (optional)
+
+### Added (optional)
+- Describe added features (only if any)
+
+### Changed (optional)
+- Describe changed behavior (only if any)
+
+Do not include empty section headings or placeholders."""
+
+
+def _strip_fences(content: str) -> str:
+    lines = content.strip().splitlines()
+    if len(lines) >= 2 and lines[0].strip().startswith("```"):
+        if lines[-1].strip() == "```":
+            return "\n".join(lines[1:-1]).strip()
+    return content.strip()
+
+
+def _split_by_heading(
+    lines: List[str], level: int
+) -> Tuple[List[str], List[Tuple[str, List[str]]]]:
+    """Split content by markdown heading level."""
+    heading_prefix = "#" * level + " "
+    preamble: List[str] = []
+    sections: List[Tuple[str, List[str]]] = []
+    current_heading: str | None = None
+    current_body: List[str] = []
+
+    for line in lines:
+        if line.startswith(heading_prefix):
+            if current_heading is not None:
+                sections.append((current_heading.strip(), current_body))
+            current_heading = line
+            current_body = []
+            continue
+
+        if current_heading is None:
+            preamble.append(line)
+        else:
+            current_body.append(line)
+
+    if current_heading is not None:
+        sections.append((current_heading.strip(), current_body))
+
+    return preamble, sections
+
+
+def _strip_blank_edges(lines: List[str]) -> List[str]:
+    start = 0
+    end = len(lines)
+
+    while start < end and not lines[start].strip():
+        start += 1
+    while end > start and not lines[end - 1].strip():
+        end -= 1
+
+    return lines[start:end]
+
+
+def _is_placeholder_line(line: str) -> bool:
+    stripped = line.strip()
+    if not stripped:
+        return True
+    if stripped in {"-", "*", "+"}:
+        return True
+
+    candidate = stripped
+    for marker in ("- ", "* ", "+ "):
+        if candidate.startswith(marker):
+            candidate = candidate[len(marker) :].strip()
+            break
+
+    candidate_lower = candidate.lower().rstrip(".")
+    if candidate_lower in PLACEHOLDER_LINES:
+        return True
+
+    if re.fullmatch(r"(none|no changes|n/?a)\.?$", candidate_lower):
+        return True
+
+    return False
+
+
+def _has_informative_content(lines: List[str]) -> bool:
+    for line in lines:
+        stripped = line.strip()
+        if not stripped:
+            continue
+        if stripped.startswith("#"):
+            continue
+        if _is_placeholder_line(stripped):
+            continue
+        return True
+    return False
+
+
+def _clean_second_level_body(lines: List[str]) -> List[str]:
+    intro, subsections = _split_by_heading(lines, 3)
+    cleaned: List[str] = []
+    kept_subsections: List[Tuple[str, List[str]]] = []
+
+    for heading, body in subsections:
+        body = _strip_blank_edges(body)
+        if _has_informative_content(body):
+            kept_subsections.append((heading, body))
+
+    intro = _strip_blank_edges(intro)
+    keep_intro = _has_informative_content(intro)
+    if not keep_intro and not kept_subsections:
+        return []
+
+    if keep_intro:
+        cleaned.extend(intro)
+
+    for index, (heading, body) in enumerate(kept_subsections):
+        if cleaned:
+            cleaned.append("")
+        cleaned.append(heading)
+        cleaned.extend(body)
+        if index < len(kept_subsections) - 1:
+            cleaned.append("")
+
+    return cleaned
+
+
+def normalize_changelog_content(content: str) -> str:
+    """Normalize AI output and remove empty sections/placeholders."""
+    content = _strip_fences(content)
+    raw_lines = _strip_blank_edges(content.splitlines())
+    if not raw_lines:
+        return "# Changelog"
+
+    title = "# Changelog"
+    body_lines = raw_lines
+    if raw_lines[0].startswith("# "):
+        title = raw_lines[0].strip()
+        body_lines = _strip_blank_edges(raw_lines[1:])
+
+    _, sections = _split_by_heading(body_lines, 2)
+    rebuilt_lines: List[str] = [title]
+
+    if sections:
+        kept_sections: List[Tuple[str, List[str]]] = []
+        for heading, body in sections:
+            cleaned_body = _clean_second_level_body(body)
+            if cleaned_body:
+                kept_sections.append((heading, cleaned_body))
+
+        if kept_sections:
+            rebuilt_lines.append("")
+            for index, (heading, body) in enumerate(kept_sections):
+                rebuilt_lines.append(heading)
+                rebuilt_lines.extend(body)
+                if index < len(kept_sections) - 1:
+                    rebuilt_lines.append("")
+    else:
+        body_lines = _strip_blank_edges(body_lines)
+        if _has_informative_content(body_lines):
+            rebuilt_lines.append("")
+            rebuilt_lines.extend(body_lines)
+
+    return "\n".join(_strip_blank_edges(rebuilt_lines)) + "\n"
+
 
-### Added
-- List new features
+def _to_section_name(heading: str) -> str:
+    return heading.removeprefix("###").strip()
 
-### Changed
-- List changes to existing functionality
 
-### Fixed
-- List bug fixes
+def _extract_category_blocks(content: str) -> List[Tuple[str, List[str]]]:
+    """Extract non-empty category blocks from normalized changelog content."""
+    lines = _strip_blank_edges(content.splitlines())
+    if lines and lines[0].startswith("# "):
+        lines = _strip_blank_edges(lines[1:])
 
-### Removed
-- List removed features
+    _, sections = _split_by_heading(lines, 2)
+    category_items: List[Tuple[str, List[str]]] = []
 
-Only include sections that have changes. Do not add empty sections."""
+    for _, section_body in sections:
+        section_intro, subsections = _split_by_heading(section_body, 3)
+        if subsections:
+            for heading, body in subsections:
+                body = _strip_blank_edges(body)
+                if _has_informative_content(body):
+                    category_items.append((_to_section_name(heading), body))
+            continue
+
+        section_intro = _strip_blank_edges(section_intro)
+        if _has_informative_content(section_intro):
+            category_items.append(("Changed", section_intro))
+
+    if category_items:
+        preferred_order = [
+            "Added",
+            "Changed",
+            "Fixed",
+            "Removed",
+            "Deprecated",
+            "Security",
+        ]
+        ordered: List[Tuple[str, List[str]]] = []
+        used_indices: set[int] = set()
+
+        for name in preferred_order:
+            for idx, item in enumerate(category_items):
+                if idx in used_indices:
+                    continue
+                category_name, _ = item
+                if category_name.lower() == name.lower():
+                    ordered.append(item)
+                    used_indices.add(idx)
+
+        for idx, item in enumerate(category_items):
+            if idx not in used_indices:
+                ordered.append(item)
+
+        return ordered
+
+    return category_items
+
+
+def _strip_top_heading(content: str) -> str:
+    lines = _strip_blank_edges(content.splitlines())
+    if lines and lines[0].startswith("# "):
+        return "\n".join(_strip_blank_edges(lines[1:]))
+    return "\n".join(lines)
+
+
+def _save_timestamped_changelog(
+    content: str, directory: str, branch_name: str, now: datetime
+) -> str:
+    year_directory = now.strftime("%Y")
+    month_directory = now.strftime("%m")
+    day_directory = now.strftime("%d")
+    target_directory = os.path.join(
+        directory, branch_name, year_directory, month_directory, day_directory
+    )
+    os.makedirs(target_directory, exist_ok=True)
+
+    filename = now.strftime("%H-%M-%S.md")
+    filepath = os.path.join(target_directory, filename)
+
+    with open(filepath, "w", encoding="utf-8") as file:
+        file.write(content)
+
+    return filepath
+
+
+def _save_branch_changelog(
+    content: str, directory: str, branch_name: str, now: datetime
+) -> str:
+    os.makedirs(directory, exist_ok=True)
+    filepath = os.path.join(directory, f"{branch_name}.md")
+
+    timestamp = now.strftime("%Y-%m-%d %H:%M:%S")
+    categories = _extract_category_blocks(content)
+    entry_lines: List[str] = [f"## [{timestamp}]"]
+
+    if categories:
+        for section_name, section_lines in categories:
+            entry_lines.append("")
+            entry_lines.append(f"### {section_name}")
+            entry_lines.extend(section_lines)
+    else:
+        content_body = _strip_top_heading(content)
+        if content_body.strip():
+            entry_lines.append("")
+            entry_lines.extend(content_body.splitlines())
+
+    new_entry = "\n".join(_strip_blank_edges(entry_lines)).strip()
+
+    previous_body = ""
+    if os.path.exists(filepath):
+        with open(filepath, "r", encoding="utf-8") as file:
+            previous_body = _strip_top_heading(file.read()).strip()
+
+    output_lines = ["# Changelog", "", new_entry]
+    if previous_body:
+        output_lines.extend(["", previous_body])
+
+    with open(filepath, "w", encoding="utf-8") as file:
+        file.write("\n".join(_strip_blank_edges(output_lines)) + "\n")
+
+    return filepath
 
 
 def generate_changelog(diff: str) -> str:
@@ -58,7 +345,7 @@ def generate_changelog(diff: str) -> str:
         diff, prompt, max_tokens
     )
 
-    return changelog_content
+    return normalize_changelog_content(changelog_content)
 
 
 def save_changelog(content: str, directory: str = None) -> str:
@@ -74,18 +361,18 @@ def save_changelog(content: str, directory: str = None) -> str:
     if directory is None:
         directory = config("CHANGELOG_DIR", default="changelogs")
 
-    now = datetime.now()
-    year_directory = now.strftime("%Y")
-    month_directory = now.strftime("%m")
-    target_directory = os.path.join(directory, year_directory, month_directory)
-
-    # Create the year/month directory structure if it doesn't exist
-    os.makedirs(target_directory, exist_ok=True)
-
-    filename = now.strftime("%Y-%m-%d_%H-%M-%S.md")
-    filepath = os.path.join(target_directory, filename)
+    changelog_mode = (
+        config("CHANGELOG_MODE", default=DEFAULT_CHANGELOG_MODE).strip().lower()
+    )
+    normalized_content = normalize_changelog_content(content)
 
-    with open(filepath, "w", encoding="utf-8") as f:
-        f.write(content)
+    now = datetime.now()
+    branch_name = get_current_branch().replace("/", "-")
+    if changelog_mode in BRANCH_CHANGELOG_MODES:
+        return _save_branch_changelog(
+            normalized_content, directory, branch_name, now
+        )
 
-    return filepath
+    return _save_timestamped_changelog(
+        normalized_content, directory, branch_name, now
+    )

devcommit/create_config.py

@@ -85,6 +85,12 @@ EXCLUDE_FILES = *.lock, dist/*, build/*, node_modules/*
 # Directory for changelog files (default: changelogs)
 # Used when --changelog flag is passed
 CHANGELOG_DIR = changelogs
+
+# Changelog storage mode (default: timestamped)
+# Options:
+#   - timestamped: Create a new changelog file per run (existing behavior)
+#   - branch: Keep one changelog file per branch and prepend new entries
+CHANGELOG_MODE = timestamped
     """
     
     if "VIRTUAL_ENV" in os.environ:

{devcommit-0.1.5.4.dist-info → devcommit-0.1.5.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devcommit
-Version: 0.1.5.4
+Version: 0.1.5.6
 Summary: AI-powered git commit message generator
 License: GNU GENERAL PUBLIC LICENSE
                                 Version 3, 29 June 2007
@@ -782,6 +782,7 @@ A command-line AI tool for autocommits.
    # GEMINI_MODEL / OPENAI_MODEL / GROQ_MODEL / OPENROUTER_MODEL / ANTHROPIC_MODEL / OLLAMA_MODEL / CUSTOM_MODEL
    MODEL_NAME = gemini-2.5-flash
    COMMIT_MODE = auto
+   CHANGELOG_MODE = timestamped
    EOF
    ```
 
@@ -796,6 +797,7 @@ A command-line AI tool for autocommits.
    COMMIT_TYPE = conventional
    MODEL_NAME = gemini-2.0-flash-exp
    COMMIT_MODE = auto
+   CHANGELOG_MODE = timestamped
    EOF
    ```
 
@@ -1150,8 +1152,11 @@ devcommit --stageAll --changelog --files src/
 
 - **With `--stageAll`**: Changelog is generated from unstaged changes **before** staging
 - **Without `--stageAll`**: Changelog is generated from the last commit **after** committing
-- Changelogs are saved as markdown files with datetime-based names inside `year/month` folders (e.g., `changelogs/2026/01/2026-01-28_00-55-30.md`)
-- Default base directory: `changelogs/` (configurable via `CHANGELOG_DIR` in `.dcommit`)
+- Storage mode is controlled by `CHANGELOG_MODE`:
+  - `timestamped` (default): new file per run in `changelogs/<branch>/<year>/<month>/<day>/<time>.md`
+  - `branch`: one file per branch, updated in place at `changelogs/<branch>.md`
+- Default base directory is `changelogs/` (configurable via `CHANGELOG_DIR` in `.dcommit`)
+- Empty sections are automatically removed (including empty `## [Unreleased]`)
 - Uses Keep a Changelog format with AI-generated content
 
 **Example workflow:**
@@ -1163,7 +1168,9 @@ devcommit --stageAll --changelog --files src/
 # Stage all changes and generate changelog before committing
 devcommit --stageAll --changelog
 
-# The changelog file is created in changelogs/<year>/<month>/ directory
+# The changelog file is created based on CHANGELOG_MODE
+# timestamped: changelogs/<branch>/<year>/<month>/<day>/<time>.md
+# branch:      changelogs/<branch>.md
 # Then changes are staged and committed
 ```
 
@@ -1359,6 +1366,7 @@ All configuration can be set via **environment variables** or **`.dcommit` file*
 | `EXCLUDE_FILES` | Files to exclude from diff           | `package-lock.json, pnpm-lock.yaml, yarn.lock, *.lock` | Comma-separated file patterns            |
 | `MAX_TOKENS`    | Maximum tokens for AI response       | `8192`                                                 | Any positive integer                     |
 | `CHANGELOG_DIR` | Directory for changelog files        | `changelogs`                                           | Any directory path                       |
+| `CHANGELOG_MODE` | Changelog file strategy             | `timestamped`                                          | `timestamped`, `branch`                  |
 
 ### Configuration Priority
 

{devcommit-0.1.5.4.dist-info → devcommit-0.1.5.6.dist-info}/RECORD

@@ -2,17 +2,17 @@ devcommit/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 devcommit/__version__.py,sha256=V-XdLtsUi6WXZQjdiIm5Hd_DM77oCPs6tmPghmb3GbQ,226
 devcommit/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devcommit/app/ai_providers.py,sha256=Gqgs03oVfzR830dBSJ_VKn896DpXGWGuaAdsNtvSbI8,11938
-devcommit/app/changelog.py,sha256=6IAhHjDy1LrcEfmzF9kVZgka7zZJt2hGDgkFAdpRrjs,2425
+devcommit/app/changelog.py,sha256=6rxOyiAJ2SyO_4mq1QGWuQZ--tXvurWBsToCzC60GU4,11470
 devcommit/app/gemini_ai.py,sha256=xEn94dt-kKg5fa6Wpxu09eKfN916pfWO_IWEBOGuEQE,3638
 devcommit/app/prompt.py,sha256=isjyLul4UTWJSW8kL6fSVjTBTTej0x93o5BFKW9LsZE,4325
-devcommit/create_config.py,sha256=dbW4nobO046t0dVoLbTZOKHMB4p1dATqH4d0K1MxR5g,3978
+devcommit/create_config.py,sha256=kW3HOSqn_hCTWAD0yiP0OYsupzR4iyzYA_5JE6MiVsM,4215
 devcommit/main.py,sha256=SNjvUFeqrqjcpI9cLXOQanNavH4jUnrwbHBUxzcWmnc,73750
 devcommit/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devcommit/utils/git.py,sha256=o32VbzT-0MT-AgfdtZXqn-H9SUINmVRG6AvYIJdcpDU,26858
 devcommit/utils/logger.py,sha256=HXYOU2Vd3M5O4T6fshcg5FcfWER4kQiKOiJ1vM6_0mw,1597
 devcommit/utils/parser.py,sha256=VXxHPZ75Jx6aILG1o14y1hGNlcvutQUWkoEtR_RR9Zw,2280
-devcommit-0.1.5.4.dist-info/METADATA,sha256=IjyewCUyLs24yjCg5pFPZuJKt0SyfYVOvXLI46sS1uw,67453
-devcommit-0.1.5.4.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
-devcommit-0.1.5.4.dist-info/entry_points.txt,sha256=cTvXe20Iqbeo2Jz0wSHEFLFacH4NkYfmy6Sr1THL1Es,103
-devcommit-0.1.5.4.dist-info/licenses/COPYING,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-devcommit-0.1.5.4.dist-info/RECORD,,
+devcommit-0.1.5.6.dist-info/METADATA,sha256=CM57SVCvyXuwTk-UpwSb4Oy6SXR6-FRyjQjEaBbl6Xw,67930
+devcommit-0.1.5.6.dist-info/WHEEL,sha256=Vz2fHgx6HFtSwhs8KvkHLqH5Ea4w1_rner5uNVGCeIE,88
+devcommit-0.1.5.6.dist-info/entry_points.txt,sha256=cTvXe20Iqbeo2Jz0wSHEFLFacH4NkYfmy6Sr1THL1Es,103
+devcommit-0.1.5.6.dist-info/licenses/COPYING,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+devcommit-0.1.5.6.dist-info/RECORD,,

{devcommit-0.1.5.4.dist-info → devcommit-0.1.5.6.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.3.1
+Generator: poetry-core 2.3.2
 Root-Is-Purelib: true
 Tag: py3-none-any