backlogops-cli 0.1__py3-none-any.whl

backlogops_cli/__init__.py

@@ -0,0 +1,6 @@
+#! /usr/local/bin/python3
+"""Command line interface for library with backlog operations."""
+# PYTHON_ARGCOMPLETE_OK
+
+# Copyright (c) 2026, Tom Björkholm
+# MIT License

backlogops_cli/__main__.py

@@ -0,0 +1,12 @@
+#! /usr/local/bin/python3
+"""Run backlogops_cli without a command by listing the commands."""
+# PYTHON_ARGCOMPLETE_OK
+
+# Copyright (c) 2026, Tom Björkholm
+# MIT License
+
+from backlogops_cli.list import main
+
+
+if __name__ == '__main__':  # pragma: no cover
+    main()

backlogops_cli/_command_io.py

@@ -0,0 +1,220 @@
+#! /usr/local/bin/python3
+"""Shared command helpers for resolving output configs and writing.
+
+The helpers here are used by more than one command (for example by the
+``convert`` command and the ``demo_backlog`` command). The leading
+underscore in the module name keeps it out of the command listing.
+"""
+# PYTHON_ARGCOMPLETE_OK
+
+# Copyright (c) 2026, Tom Björkholm
+# MIT License
+
+import argparse
+import sys
+from collections.abc import Callable
+from typing import Optional
+import argcomplete
+from backlogops import (
+    BacklogReleases, FormatRules, InputFormatConfig, OutputFormatConfig,
+    ReleaseChanges, ReleaseDateChanges, format_content_changes,
+    format_date_changes, read_available_teams, read_backlog_releases,
+    resolve_input_config, resolve_output_config, write_backlog_releases,
+    write_content_changes, write_date_changes)
+
+
+def parsed_args(parser: argparse.ArgumentParser,
+                args: Optional[list[str]]) -> argparse.Namespace:
+    """Enable shell completion and parse the command line arguments."""
+    argcomplete.autocomplete(parser)
+    return parser.parse_args(args)
+
+
+def add_input_args(parser: argparse.ArgumentParser) -> None:
+    """Add the input-file and input-config arguments."""
+    parser.add_argument('-i', '--input', dest='input', required=True,
+                        help='Input data file to read.')
+    parser.add_argument('-I', '--input-config', dest='input_config',
+                        help='Input format: a config file or a preset name.')
+
+
+def _input_presets(io_config: Optional[str]
+                   ) -> Optional[dict[str, InputFormatConfig]]:
+    """Return the named input presets from a presets file, if given."""
+    if io_config is None:
+        return None
+    return read_available_teams(io_config, sys.stderr).input_configs
+
+
+def read_input(parsed: argparse.Namespace) -> BacklogReleases:
+    """Read and validate the backlog and releases from the input file.
+
+    The input format is resolved from the ``--input-config`` value, which
+    may be empty (inferred from the file name), a preset name looked up in
+    the presets file given by ``--io-config``, or a config file path.
+
+    Args:
+        parsed: Parsed command line arguments holding the input options
+            added by :func:`add_input_args` and, optionally, the
+            ``--io-config`` option added by :func:`add_output_args`.
+
+    Returns:
+        The validated backlog and releases read from the input file.
+    """
+    io_config = getattr(parsed, 'io_config', None)
+    presets = _input_presets(io_config)
+    config = resolve_input_config(parsed.input_config, data_file=parsed.input,
+                                  presets=presets)
+    data = read_backlog_releases(parsed.input, config)
+    data.check_consistency(sys.stderr)
+    return data
+
+
+def add_output_args(parser: argparse.ArgumentParser) -> None:
+    """Add the output-file, output-config and ordering arguments."""
+    parser.add_argument('-o', '--output', dest='output', required=True,
+                        help='Output data file to create.')
+    parser.add_argument('-O', '--output-config', dest='output_config',
+                        help='Output format: a config file or a preset name.')
+    parser.add_argument('--io-config', dest='io_config',
+                        help='Configuration file holding the named presets '
+                        '(by default the teams configuration file).')
+    parser.add_argument('--releases-first', dest='releases_first',
+                        action='store_true',
+                        help='Write the releases before the backlog.')
+
+
+def _output_presets(io_config: Optional[str]
+                    ) -> Optional[dict[str, OutputFormatConfig]]:
+    """Return the named output presets from a presets file, if given."""
+    if io_config is None:
+        return None
+    return read_available_teams(io_config, sys.stderr).output_configs
+
+
+def _write_output(parsed: argparse.Namespace, data: BacklogReleases) -> None:
+    """Write the backlog and releases to the configured output file."""
+    presets = _output_presets(parsed.io_config)
+    config = resolve_output_config(parsed.output_config,
+                                   data_file=parsed.output, presets=presets)
+    rules = FormatRules(backlog_first=not parsed.releases_first)
+    write_backlog_releases(data, parsed.output, config, rules)
+
+
+def run_write(parsed: argparse.Namespace,
+              data_source: Callable[[], BacklogReleases]) -> int:
+    """Build the data, write it to the output file, and report the result.
+
+    Args:
+        parsed: Parsed command line arguments holding the output options
+            added by :func:`add_output_args`.
+        data_source: Callable that returns the backlog and releases to
+            write. It is called inside the error handling so that reading
+            failures are reported like writing failures.
+
+    Returns:
+        ``0`` on success, ``1`` when the data cannot be built or written.
+    """
+    try:
+        _write_output(parsed, data_source())
+    except (ValueError, TypeError, KeyError, OSError) as error:
+        print(f'Could not write {parsed.output}: {error}', file=sys.stderr)
+        return 1
+    print(f'Wrote {parsed.output}')
+    return 0
+
+
+DEFAULT_BUFFER_DAYS = 5
+"""Default slack in calendar days added when fitting dates."""
+
+
+def add_buffer_arg(parser: argparse.ArgumentParser) -> None:
+    """Add the buffer-days argument with the default slack."""
+    parser.add_argument('--buffer-days', dest='buffer_days', type=int,
+                        default=DEFAULT_BUFFER_DAYS, metavar='DAYS',
+                        help='Slack in calendar days kept against the planned '
+                        f'dates (default {DEFAULT_BUFFER_DAYS}). Must not be '
+                        'negative.')
+
+
+def add_changes_arg(parser: argparse.ArgumentParser) -> None:
+    """Add the optional file to also save the list of changes to."""
+    parser.add_argument('--changes-file', dest='changes_file', metavar='FILE',
+                        help='Also save the list of changes to a TableIO '
+                        'file. Without it the changes are only printed to '
+                        'stdout.')
+
+
+def build_change_parser(description: str) -> argparse.ArgumentParser:
+    """Build a parser with input, buffer, output and changes arguments."""
+    parser = argparse.ArgumentParser(description=description)
+    add_input_args(parser)
+    add_buffer_arg(parser)
+    add_output_args(parser)
+    add_changes_arg(parser)
+    return parser
+
+
+def date_report(changes: ReleaseDateChanges
+                ) -> tuple[str, Optional[Callable[[str], None]]]:
+    """Return the date change listing and a writer, None when empty."""
+    writer = None if not changes else \
+        (lambda path: write_date_changes(changes, path))
+    return format_date_changes(changes), writer
+
+
+def content_report(changes: ReleaseChanges
+                   ) -> tuple[str, Optional[Callable[[str], None]]]:
+    """Return the content change listing and a writer, None when empty."""
+    writer = None if not changes else \
+        (lambda path: write_content_changes(changes, path))
+    return format_content_changes(changes), writer
+
+
+def run_change_command(parsed: argparse.Namespace,
+                       produce: Callable[[BacklogReleases], tuple[
+                           str, Optional[Callable[[str], None]]]]) -> int:
+    """Read, change, write the data, and emit the list of changes.
+
+    The input is read and validated, ``produce`` changes it in place and
+    returns the change listing as text together with a callback that
+    writes the same changes to a file. The changed data is written to the
+    output file, the listing is printed to stdout, and, when
+    ``--changes-file`` is given, the changes are also written to that file.
+
+    Args:
+        parsed: Parsed command line arguments holding the input, output
+            and ``--changes-file`` options.
+        produce: Callable that changes the data and returns the change
+            listing text and a writer for the change file.
+
+    Returns:
+        ``0`` on success, ``1`` when any step fails.
+    """
+    try:
+        data = read_input(parsed)
+        listing, write_changes = produce(data)
+        _write_output(parsed, data)
+        print(f'Wrote {parsed.output}')
+        print(listing)
+        _save_changes(parsed, write_changes)
+    except (ValueError, TypeError, KeyError, OSError) as error:
+        print(f'Could not complete: {error}', file=sys.stderr)
+        return 1
+    return 0
+
+
+def _save_changes(parsed: argparse.Namespace,
+                  write_changes: Optional[Callable[[str], None]]) -> None:
+    """Save the changes to ``--changes-file`` when one is requested.
+
+    A ``write_changes`` of None means there were no changes, so nothing is
+    written and a short note is printed instead.
+    """
+    if parsed.changes_file is None:
+        return
+    if write_changes is None:
+        print('No changes to write.')
+        return
+    write_changes(parsed.changes_file)
+    print(f'Wrote {parsed.changes_file}')

backlogops_cli/adjust_release_content.py

@@ -0,0 +1,55 @@
+#! /usr/local/bin/python3
+"""Adjust release content to fit the planned release dates.
+
+The command reads an already estimated backlog and its releases, then
+moves each backlog item to the earliest release whose planned date is on
+or after the item's estimated ready date plus a slack buffer, as
+documented for :func:`backlogops.adjust_release_content`. The adjusted
+backlog and the releases are written to the output file, and the list of
+content changes is printed to stdout, or also saved to a file when
+``--changes-file`` is given.
+"""
+
+# PYTHON_ARGCOMPLETE_OK
+# Copyright (c) 2026, Tom Björkholm
+# MIT License
+
+import argparse
+import sys
+from datetime import timedelta
+from typing import Callable, Optional
+from backlogops import BacklogReleases
+from backlogops_cli._command_io import (
+    build_change_parser, content_report, parsed_args, run_change_command)
+
+DESCRIPTION = 'Adjust release content to fit the planned release dates'
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the command line parser for the adjust-content command."""
+    return build_change_parser(DESCRIPTION)
+
+
+def _adjust(parsed: argparse.Namespace, data: BacklogReleases
+            ) -> tuple[str, Optional[Callable[[str], None]]]:
+    """Adjust the release content and return the change report."""
+    changes = data.adjust_release_content(timedelta(days=parsed.buffer_days))
+    return content_report(changes)
+
+
+def main(args: Optional[list[str]] = None) -> int:
+    """Adjust the release content and write the output file.
+
+    Args:
+        args: Optional replacement for ``sys.argv[1:]``, mainly for tests.
+
+    Returns:
+        ``0`` on success, ``1`` when the data cannot be read, adjusted or
+        written.
+    """
+    parsed = parsed_args(build_parser(), args)
+    return run_change_command(parsed, lambda data: _adjust(parsed, data))
+
+
+if __name__ == '__main__':  # pragma: no cover
+    sys.exit(main())

backlogops_cli/convert.py

@@ -0,0 +1,47 @@
+#! /usr/local/bin/python3
+"""Read a backlog and releases from one file and write them to another.
+
+The command reads a backlog, releases, or both from an input file and
+writes them to an output file, possibly in another format and with other
+column names. The input and output formats are inferred from the file
+name extensions, but can be overridden by a configuration file or by a
+named preset stored in the teams configuration file.
+"""
+
+# PYTHON_ARGCOMPLETE_OK
+# Copyright (c) 2026, Tom Björkholm
+# MIT License
+
+import argparse
+import sys
+from typing import Optional
+from backlogops_cli._command_io import (
+    add_input_args, add_output_args, parsed_args, read_input, run_write)
+
+DESCRIPTION = 'Convert a backlog and releases between table file formats'
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the command line parser for the convert command."""
+    parser = argparse.ArgumentParser(description=DESCRIPTION)
+    add_input_args(parser)
+    add_output_args(parser)
+    return parser
+
+
+def main(args: Optional[list[str]] = None) -> int:
+    """Convert a backlog and releases from the input to the output file.
+
+    Args:
+        args: Optional replacement for ``sys.argv[1:]``, mainly for tests.
+
+    Returns:
+        ``0`` on success, ``1`` when the data cannot be read, validated
+        or written.
+    """
+    parsed = parsed_args(build_parser(), args)
+    return run_write(parsed, lambda: read_input(parsed))
+
+
+if __name__ == '__main__':  # pragma: no cover
+    sys.exit(main())

backlogops_cli/demo_backlog.py

@@ -0,0 +1,44 @@
+#! /usr/local/bin/python3
+"""Write a demonstration backlog and releases to a file.
+
+The data comes from :func:`backlogops.get_demo_backlog`. The output
+format is inferred from the output file name extension, but can be
+overridden by a configuration file or by a named preset stored in the
+teams configuration file.
+"""
+
+# PYTHON_ARGCOMPLETE_OK
+# Copyright (c) 2026, Tom Björkholm
+# MIT License
+
+import argparse
+import sys
+from typing import Optional
+from backlogops import get_demo_backlog
+from backlogops_cli._command_io import add_output_args, parsed_args, run_write
+
+DESCRIPTION = 'Write a demonstration backlog and releases to a file'
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the command line parser for the demo backlog command."""
+    parser = argparse.ArgumentParser(description=DESCRIPTION)
+    add_output_args(parser)
+    return parser
+
+
+def main(args: Optional[list[str]] = None) -> int:
+    """Write the demonstration backlog and releases to the output file.
+
+    Args:
+        args: Optional replacement for ``sys.argv[1:]``, mainly for tests.
+
+    Returns:
+        ``0`` on success, ``1`` when the data cannot be written.
+    """
+    parsed = parsed_args(build_parser(), args)
+    return run_write(parsed, get_demo_backlog)
+
+
+if __name__ == '__main__':  # pragma: no cover
+    sys.exit(main())

backlogops_cli/estimate_ready_date.py

@@ -0,0 +1,99 @@
+#! /usr/local/bin/python3
+"""Estimate ready dates for a backlog and write the result.
+
+The command reads a backlog and its releases from an input file and
+estimates the ready date of each backlog item from the available teams,
+as documented for :func:`backlogops.estimate_ready_date`. The teams
+configuration (velocity, work hours, vacations and so on) is taken from
+the file given by ``--config`` or, when that is absent, from the
+configured teams file. The backlog with the estimated dates and the
+releases are written to the output file. The input and output formats are
+inferred from the file name extensions, but can be overridden by a
+configuration file or by a named preset.
+"""
+
+# PYTHON_ARGCOMPLETE_OK
+# Copyright (c) 2026, Tom Björkholm
+# MIT License
+
+import argparse
+import sys
+from datetime import date
+from pathlib import Path
+from typing import Callable, Optional
+from backlogops import AvailableTeams, BacklogReleases, get_available_teams
+from backlogops_cli._command_io import (
+    add_changes_arg, add_input_args, add_output_args, date_report,
+    parsed_args, run_change_command)
+
+DESCRIPTION = 'Estimate ready dates for the backlog items'
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the command line parser for the estimate command."""
+    parser = argparse.ArgumentParser(description=DESCRIPTION)
+    add_input_args(parser)
+    parser.add_argument('-c', '--config', dest='config',
+                        help='Teams configuration file (velocity, work '
+                        'hours, vacations). Without -c the file is found '
+                        'from $BACKLOGOPS_CFG, else backlogops.cfg in '
+                        '$BACKLOGOPS_DIR, else $HOME/.backlogops.cfg.')
+    parser.add_argument('-d', '--start-date', dest='start_date',
+                        metavar='ISO_DATE',
+                        help='Day the teams start working (default today).')
+    parser.add_argument('--set-plan', dest='set_plan', action='store_true',
+                        help='Also copy each estimated date to the planned '
+                        'date.')
+    add_output_args(parser)
+    add_changes_arg(parser)
+    return parser
+
+
+def _start_date(parsed: argparse.Namespace) -> Optional[date]:
+    """Return the start date from the command line, or None for today."""
+    if parsed.start_date is None:
+        return None
+    return date.fromisoformat(parsed.start_date)
+
+
+def _load_teams(config: Optional[str]) -> AvailableTeams:
+    """Return the available teams, mapping a missing file to ValueError."""
+    if config is not None and not Path(config).is_file():
+        raise ValueError(f'Teams configuration file not found: {config}')
+    try:
+        return get_available_teams(config)
+    except RuntimeError as error:
+        raise ValueError(str(error)) from error
+
+
+def _estimate(parsed: argparse.Namespace, data: BacklogReleases
+              ) -> tuple[str, Optional[Callable[[str], None]]]:
+    """Estimate the dates and return the release date change report."""
+    teams = _load_teams(parsed.config)
+    changes = data.estimate_ready_date(teams, _start_date(parsed))
+    if parsed.set_plan:
+        data.set_plan_from_estimate()
+    return date_report(changes)
+
+
+def main(args: Optional[list[str]] = None) -> int:
+    """Estimate the ready dates and write the output file.
+
+    The backlog with the estimated dates and the releases are written to
+    the output file. The estimated release dates are updated as well, and
+    the list of release date changes is printed to stdout, or also saved
+    to a file when ``--changes-file`` is given.
+
+    Args:
+        args: Optional replacement for ``sys.argv[1:]``, mainly for tests.
+
+    Returns:
+        ``0`` on success, ``1`` when the data cannot be read, estimated
+        or written.
+    """
+    parsed = parsed_args(build_parser(), args)
+    return run_change_command(parsed, lambda data: _estimate(parsed, data))
+
+
+if __name__ == '__main__':  # pragma: no cover
+    sys.exit(main())

backlogops_cli/extract_keys.py

@@ -0,0 +1,79 @@
+#! /usr/local/bin/python3
+"""Extract the keys of a backlog at the given levels.
+
+The command reads a backlog from an input file and extracts the keys of
+the items at the levels named on the command line, in backlog order, as
+documented for :func:`backlogops.get_keys_in_order`. A level is given by
+name, alias or number. The keys are written to the key list file given by
+``-o``, or to standard output when ``-o`` is omitted.
+"""
+
+# PYTHON_ARGCOMPLETE_OK
+# Copyright (c) 2026, Tom Björkholm
+# MIT License
+
+import argparse
+import sys
+from typing import Optional
+from backlogops import get_keys_in_order, write_key_list
+from backlogops_cli._command_io import add_input_args, parsed_args, read_input
+
+DESCRIPTION = 'Extract backlog keys at the given levels to a key list'
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the command line parser for the extract-keys command."""
+    parser = argparse.ArgumentParser(description=DESCRIPTION)
+    add_input_args(parser)
+    parser.add_argument('-l', '--levels', dest='levels', nargs='+',
+                        required=True, metavar='LEVEL',
+                        help='Levels to extract keys at, by name or number.')
+    parser.add_argument('-o', '--output', dest='output',
+                        help='Key list file to create; stdout if omitted.')
+    parser.add_argument('--io-config', dest='io_config',
+                        help='Configuration file holding the named presets.')
+    return parser
+
+
+def _level_value(text: str) -> int | str:
+    """Return a level token as an int when numeric, else as a name."""
+    try:
+        return int(text)
+    except ValueError:
+        return text
+
+
+def _emit(keys: list[str], output: Optional[str]) -> None:
+    """Write the keys to the output file, or to stdout when none is given."""
+    if output is None:
+        for key in keys:
+            print(key)
+    else:
+        write_key_list(keys, output)
+
+
+def main(args: Optional[list[str]] = None) -> int:
+    """Extract the backlog keys at the given levels and emit them.
+
+    Args:
+        args: Optional replacement for ``sys.argv[1:]``, mainly for tests.
+
+    Returns:
+        ``0`` on success, ``1`` when the backlog cannot be read or the
+        keys cannot be written.
+    """
+    parsed = parsed_args(build_parser(), args)
+    try:
+        data = read_input(parsed)
+        levels = [_level_value(text) for text in parsed.levels]
+        _emit(get_keys_in_order(data.backlog, levels), parsed.output)
+    except (ValueError, TypeError, KeyError, OSError) as error:
+        print(f'Could not extract keys: {error}', file=sys.stderr)
+        return 1
+    if parsed.output is not None:
+        print(f'Wrote {parsed.output}')
+    return 0
+
+
+if __name__ == '__main__':  # pragma: no cover
+    sys.exit(main())

backlogops_cli/list.py

@@ -0,0 +1,63 @@
+#! /usr/local/bin/python3
+"""List the commands available in backlogops_cli."""
+
+# Copyright (c) 2026, Tom Björkholm
+# MIT License
+
+import os
+import pkgutil
+import importlib
+from types import ModuleType
+import backlogops_cli
+
+DESCRIPTION = 'List all commands available in backlogops_cli'
+
+
+def _python_prefix() -> str:
+    """Return the 'python -m' prefix matching the running OS."""
+    runner = 'python' if os.name == 'nt' else 'python3'
+    return f'{runner} -m'
+
+
+def _is_command(module: ModuleType) -> bool:
+    """Tell whether a module is a usable backlogops_cli command."""
+    has_main = callable(getattr(module, 'main', None))
+    description = getattr(module, 'DESCRIPTION', None)
+    return has_main and isinstance(description, str)
+
+
+def command_modules() -> list[tuple[str, ModuleType]]:
+    """Return sorted (name, module) pairs for all command modules."""
+    found: list[tuple[str, ModuleType]] = []
+    for info in pkgutil.iter_modules(backlogops_cli.__path__):
+        if info.ispkg or info.name.startswith('_'):
+            continue
+        module = importlib.import_module(f'backlogops_cli.{info.name}')
+        if _is_command(module):
+            found.append((info.name, module))
+    found.sort(key=lambda item: item[0])
+    return found
+
+
+def _description_lines(description: str) -> list[str]:
+    """Return the description as indented lines, one per text line."""
+    return [f'     {line}' for line in description.splitlines()]
+
+
+def format_listing(commands: list[tuple[str, ModuleType]]) -> str:
+    """Format the command listing for printing to the user."""
+    prefix = _python_prefix()
+    lines: list[str] = []
+    for name, module in commands:
+        lines.append(f'  {prefix} backlogops_cli.{name}')
+        lines.extend(_description_lines(module.DESCRIPTION))
+    return '\n'.join(lines)
+
+
+def main() -> None:
+    """Print the list of available backlogops_cli commands."""
+    print(format_listing(command_modules()))
+
+
+if __name__ == '__main__':  # pragma: no cover
+    main()

backlogops_cli/order_by_deps.py

@@ -0,0 +1,70 @@
+#! /usr/local/bin/python3
+"""Reorder a backlog by its dependencies and write the result.
+
+The command reads a backlog and its releases from an input file and
+reorders the backlog so that a team can start the items in backlog order
+without starting an item before the items it depends on, as documented
+for :func:`backlogops.order_by_dependencies`. The reordered backlog and
+the releases are written to the output file. The input and output formats
+are inferred from the file name extensions, but can be overridden by a
+configuration file or by a named preset.
+"""
+
+# PYTHON_ARGCOMPLETE_OK
+# Copyright (c) 2026, Tom Björkholm
+# MIT License
+
+import argparse
+import sys
+from typing import Optional
+from backlogops import BacklogReleases, DependencyMode
+from backlogops_cli._command_io import (
+    add_input_args, add_output_args, parsed_args, read_input, run_write)
+
+DESCRIPTION = 'Reorder a backlog so that dependencies are fulfilled'
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the command line parser for the order_by_deps command."""
+    parser = argparse.ArgumentParser(description=DESCRIPTION)
+    add_input_args(parser)
+    parser.add_argument('-s', '--space-around', dest='space_around',
+                        action='append', metavar='KEY',
+                        help='Key to keep far from its dependencies. May '
+                        'be given more than once.')
+    parser.add_argument('-L', '--later', dest='later', action='store_true',
+                        help='Push dependent items later instead of pulling '
+                        'prerequisites earlier.')
+    parser.add_argument('-m', '--mode', dest='mode',
+                        choices=[mode.name for mode in DependencyMode],
+                        default=DependencyMode.KEEP.name,
+                        help='Placement of dependency items (default KEEP).')
+    add_output_args(parser)
+    return parser
+
+
+def _ordered(parsed: argparse.Namespace) -> BacklogReleases:
+    """Read the backlog and return it reordered by dependencies."""
+    data = read_input(parsed)
+    data.order_by_dependencies(later=parsed.later,
+                               mode=DependencyMode[parsed.mode],
+                               space_around=parsed.space_around)
+    return data
+
+
+def main(args: Optional[list[str]] = None) -> int:
+    """Reorder the backlog by dependencies and write the output file.
+
+    Args:
+        args: Optional replacement for ``sys.argv[1:]``, mainly for tests.
+
+    Returns:
+        ``0`` on success, ``1`` when the data cannot be read, reordered
+        or written.
+    """
+    parsed = parsed_args(build_parser(), args)
+    return run_write(parsed, lambda: _ordered(parsed))
+
+
+if __name__ == '__main__':  # pragma: no cover
+    sys.exit(main())

backlogops_cli/order_by_keys.py

@@ -0,0 +1,59 @@
+#! /usr/local/bin/python3
+"""Reorder a backlog from a key list and write the result.
+
+The command reads a backlog and its releases from an input file, reads a
+key list from another file, and reorders the backlog so that the items
+named by the key list come first, as documented for
+:func:`backlogops.move_keys_first`. The reordered backlog and the
+releases are written to the output file. The input and output formats are
+inferred from the file name extensions, but can be overridden by a
+configuration file or by a named preset.
+"""
+
+# PYTHON_ARGCOMPLETE_OK
+# Copyright (c) 2026, Tom Björkholm
+# MIT License
+
+import argparse
+import sys
+from typing import Optional
+from backlogops import BacklogReleases, read_key_list
+from backlogops_cli._command_io import (
+    add_input_args, add_output_args, parsed_args, read_input, run_write)
+
+DESCRIPTION = 'Reorder a backlog so that key-list items come first'
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the command line parser for the order_by_keys command."""
+    parser = argparse.ArgumentParser(description=DESCRIPTION)
+    add_input_args(parser)
+    parser.add_argument('-k', '--key-list', dest='key_list', required=True,
+                        help='Key list file giving the new leading order.')
+    add_output_args(parser)
+    return parser
+
+
+def _reordered(parsed: argparse.Namespace) -> BacklogReleases:
+    """Read the backlog and key list and return the reordered data."""
+    data = read_input(parsed)
+    data.move_keys_first(read_key_list(parsed.key_list))
+    return data
+
+
+def main(args: Optional[list[str]] = None) -> int:
+    """Reorder the backlog from the key list and write the output file.
+
+    Args:
+        args: Optional replacement for ``sys.argv[1:]``, mainly for tests.
+
+    Returns:
+        ``0`` on success, ``1`` when the data cannot be read, reordered
+        or written.
+    """
+    parsed = parsed_args(build_parser(), args)
+    return run_write(parsed, lambda: _reordered(parsed))
+
+
+if __name__ == '__main__':  # pragma: no cover
+    sys.exit(main())

backlogops_cli/plan_release_dates.py

@@ -0,0 +1,55 @@
+#! /usr/local/bin/python3
+"""Set planned release dates from the estimated release dates.
+
+The command reads a backlog and its releases whose estimated release
+dates are already filled in, then sets each planned release date to the
+estimated release date plus a slack buffer, as documented for
+:func:`backlogops.release_plan_on_estimate`. The backlog and the releases
+with the new planned dates are written to the output file, and the list of
+planned date changes is printed to stdout, or also saved to a file when
+``--changes-file`` is given.
+"""
+
+# PYTHON_ARGCOMPLETE_OK
+# Copyright (c) 2026, Tom Björkholm
+# MIT License
+
+import argparse
+import sys
+from datetime import timedelta
+from typing import Callable, Optional
+from backlogops import BacklogReleases
+from backlogops_cli._command_io import (
+    build_change_parser, date_report, parsed_args, run_change_command)
+
+DESCRIPTION = 'Set planned release dates from the estimated release dates'
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the command line parser for the plan-dates command."""
+    return build_change_parser(DESCRIPTION)
+
+
+def _plan(parsed: argparse.Namespace, data: BacklogReleases
+          ) -> tuple[str, Optional[Callable[[str], None]]]:
+    """Set the planned release dates and return the change report."""
+    changes = data.release_plan_on_estimate(timedelta(days=parsed.buffer_days))
+    return date_report(changes)
+
+
+def main(args: Optional[list[str]] = None) -> int:
+    """Set the planned release dates and write the output file.
+
+    Args:
+        args: Optional replacement for ``sys.argv[1:]``, mainly for tests.
+
+    Returns:
+        ``0`` on success, ``1`` when the data cannot be read, planned or
+        written.
+    """
+    parsed = parsed_args(build_parser(), args)
+    return run_change_command(parsed, lambda data: _plan(parsed, data))
+
+
+if __name__ == '__main__':  # pragma: no cover
+    sys.exit(main())

backlogops_cli/teams_wizard.py

@@ -0,0 +1,55 @@
+#! /usr/local/bin/python3
+"""Run the available-teams wizard and store the result to a file."""
+
+# PYTHON_ARGCOMPLETE_OK
+# Copyright (c) 2026, Tom Björkholm
+# MIT License
+
+import argparse
+import sys
+from typing import Optional
+from config_as_json.file_extension import fix_file_extension
+from backlogops import ConsoleYesNoUiBridge, teams_config_wizard
+from backlogops_cli._command_io import parsed_args
+
+DESCRIPTION = 'Create an AvailableTeams configuration file via a wizard'
+CONFIG_EXTENSION = '.cfg'
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the command line parser for the teams wizard command."""
+    parser = argparse.ArgumentParser(description=DESCRIPTION)
+    parser.add_argument('-o', '--output', dest='output', required=True,
+                        help='Configuration file to write; the '
+                        f'{CONFIG_EXTENSION} extension is added if missing.')
+    return parser
+
+
+def main(args: Optional[list[str]] = None) -> int:
+    """Run the interactive wizard and write the workforce configuration.
+
+    The output filename receives the ``.cfg`` extension when it is not
+    already present.
+
+    Args:
+        args: Optional replacement for ``sys.argv[1:]``, mainly for tests.
+
+    Returns:
+        ``0`` on success, ``1`` when the entered workforce is rejected or
+        cannot be written.
+    """
+    parsed = parsed_args(build_parser(), args)
+    output = fix_file_extension(parsed.output, CONFIG_EXTENSION)
+    bridge = ConsoleYesNoUiBridge(sys.stdout, sys.stdin, sys.stderr)
+    try:
+        config = teams_config_wizard(bridge)
+        config.write(to_json_filename=output, stderr_file=sys.stderr)
+    except (ValueError, TypeError, KeyError, EOFError, OSError) as error:
+        print(f'Could not create the configuration: {error}', file=sys.stderr)
+        return 1
+    print(f'Workforce configuration written to {output}')
+    return 0
+
+
+if __name__ == '__main__':  # pragma: no cover
+    sys.exit(main())

backlogops_cli-0.1.dist-info/METADATA

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: backlogops-cli
+Version: 0.1
+Summary: Command line interface for backlog operations.
+Author: Tom Björkholm
+Author-email: Tom Björkholm <klausuler_linnet0q@icloud.com>
+License-Expression: MIT
+Project-URL: Homepage, https://bitbucket.org/tom-bjorkholm/backlog-ops
+Project-URL: Source code, https://bitbucket.org/tom-bjorkholm/backlog-ops
+Project-URL: Documentation, https://bitbucket.org/tom-bjorkholm/backlog-ops/src/master/doc/
+Keywords: backlog,release planning,agile,scrum,scheduling,roadmap,project management,product owner,product management
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Information Technology
+Classifier: Topic :: Office/Business :: Scheduling
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: argcomplete>=3.6.3
+Requires-Dist: backlogops>=0.1
+Dynamic: author
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+
+# backlogops-cli
+
+There are 3 related packages for backlog operations:
+
+- backlogops: a collection of library functions to manipulate backlogs
+
+- backlogops-cli: command line interface to use the functions in the library.
+  This is just a thin wrapper around the library functions. It serves a dual
+  purpose as both an example of how to use the library and as a tool for the
+  user to use the library.
+
+- backlogops-gui: graphical user interface to use the functions in the library.
+  It is based on TkInter. The ambition is to keep it as a thin wrapper around
+  the library.
+
+## Available functionality
+
+The following functionality is available in all 3 packages:
+
+- Reading backlog and releases from file types that TableIO supports reading
+  from (Currently CSV, Excel, and ODS).
+
+- Writing backlog and releases to file types that TableIO supports writing to
+  (Currently CSV, Excel, ODS and 9 other file formats).
+
+- File format is detected from the file extension, but may be overridden.
+
+- Adjust release content to fit the planned release dates.
+
+- Create a demonstration backlog and releases (for exploring the features).
+
+- Estimate ready date for the backlog items based on available teams, team
+  velocity, vacation dates, periods with half time work, etc.
+
+- Extract backlog keys at given backlog item levels.
+
+- Reorder the backlog so that the dependencies are satisfied.
+
+- Reorder the backlog so that items identified by keys in a list come first. If
+  the key is at a higher level it will bring all items it is a parent of in
+  front of it (recursively).
+
+- Set planned release dates from the estimated release dates.
+
+- Calculate the release dates from the backlog items estimated ready dates, with
+  a configurable buffer time.
+
+- Validate the backlog and releases for consistency.
+
+- A wizard to create an available teams configuration.
+
+## The operating model
+
+The operating model that most of the functionality is designed for is that the
+teams work off a single backlog in the order of the backlog. The backlog items
+are ordered by priority and dependencies to allow the teams to work in the
+backlog order. Each backlog item and each release may have a planned ready date,
+that records what has been communicated to the customer. Each backlog item and
+each release may have an estimated ready date, that is calculated from the
+current backlog state, the team velocity, and what we know about the
+availability of the team members.
+
+## The backlog item fields
+
+Each backlog item has the following fields that are used by the algorithms in
+the library:
+
+- key: The key of the backlog item. Required. Must be unique. Must not be empty,
+  must not contain whitespace and must not contain any of the characters , . ; :
+  ( ) \[ \] \{ \}.
+
+- level: The level of the backlog item. Required. Must be an integer.
+
+- title: The title of the backlog item. Required.
+
+- story_points: The story points of the backlog item. Required.
+
+- status: The status of the backlog item. Required.
+
+- parent_key: The key of the parent backlog item. Optional. Must exist as a key
+  in the backlog. Parent keys are used to build the hierarchy of the backlog.
+  The parent key must be at a higher level than the current item. Parent keys
+  introduce implicit dependencies between items: the current item cannot start
+  before the parent item starts, and the parent item cannot finish before all
+  its children have finished.
+
+- release: The release of the backlog item. Optional. Follows the same character
+  rules as the key. Must not be empty string.
+
+- team: The team responsible for the backlog item. Optional. Must not be empty
+  string. Must be a valid team name. If None the item can be done by any team.
+  If not None. the item can only be done by the specified team.
+
+- depends_on_f2s: The list of keys of the backlog items that must have been
+  finished before the current item can start. May be empty.
+
+- depends_on_f2f: The list of keys of the backlog items that must have been
+  finished before the current item can finish. May be empty.
+
+- depends_on_s2s: The list of keys of the backlog items that must have been
+  started before the current item can start. May be empty.
+
+- planned_ready_date: The planned ready date of the backlog item. The date that
+  is communicated to the customer. Optional.
+
+- estimated_ready_date: The estimated ready date of the backlog item. Optional.
+
+Additionally each backlog item can have any number of other fields.
+
+## Installing backlogops-cli
+
+### On macOS and Linux
+
+To install backlogops-cli on macOS and Linux, run the following command:
+
+````sh
+pip3 install --upgrade backlogops-cli
+````
+
+### On Microsoft Windows
+
+To install backlogops-cli on Microsoft Windows, run the following command:
+
+````sh
+pip install --upgrade backlogops-cli
+````
+
+## API documentation
+
+For more detailed code documentation, see the API documentation:
+
+- [Library public API](https://bitbucket.org/tom-bjorkholm/backlog-ops/src/master/doc/backlogops_api.md)
+
+- [Library protected API](https://bitbucket.org/tom-bjorkholm/backlog-ops/src/master/doc/backlogops_protected_api.md)
+
+- [Library public CLI](https://bitbucket.org/tom-bjorkholm/backlog-ops/src/master/doc/backlogops_cli.md)
+
+- [Library protected CLI](https://bitbucket.org/tom-bjorkholm/backlog-ops/src/master/doc/backlogops_protected_cli.md)
+
+- [Library public GUI](https://bitbucket.org/tom-bjorkholm/backlog-ops/src/master/doc/backlogops_gui.md)
+
+- [Library protected GUI](https://bitbucket.org/tom-bjorkholm/backlog-ops/src/master/doc/backlogops_protected_gui.md)
+
+## Command line backlog operations
+
+backlogops_cli serves 2 purposes:
+
+- as a command line utility collection for manipulating backlogs
+
+- as an example of how to write your own programs that use the backlogops library
+
+### Currently available commands
+
+````text
+  python3 -m backlogops_cli.adjust_release_content
+     Adjust release content to fit the planned release dates
+  python3 -m backlogops_cli.convert
+     Convert a backlog and releases between table file formats
+  python3 -m backlogops_cli.demo_backlog
+     Write a demonstration backlog and releases to a file
+  python3 -m backlogops_cli.estimate_ready_date
+     Estimate ready dates for the backlog items
+  python3 -m backlogops_cli.extract_keys
+     Extract backlog keys at the given levels to a key list
+  python3 -m backlogops_cli.list
+     List all commands available in backlogops_cli
+  python3 -m backlogops_cli.order_by_deps
+     Reorder a backlog so that dependencies are fulfilled
+  python3 -m backlogops_cli.order_by_keys
+     Reorder a backlog so that key-list items come first
+  python3 -m backlogops_cli.plan_release_dates
+     Set planned release dates from the estimated release dates
+  python3 -m backlogops_cli.teams_wizard
+     Create an AvailableTeams configuration file via a wizard
+````
+
+## Test summary
+
+- Test result: 1066 passed in 16s
+- No flake8 warnings.
+- No mypy errors found.
+- No python layout warnings.
+- Built version(s): 0.1
+- Build and test using Python 3.14.6

backlogops_cli-0.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+backlogops_cli/__init__.py,sha256=_fQCpIvVjUpxy90m9QHLW13b0KTJXttFRH_P6UrfVD8,168
+backlogops_cli/__main__.py,sha256=3VGp1eTHo0ihcDtJe_702Aub_NeoIEUpUDkMUsAXCJs,268
+backlogops_cli/_command_io.py,sha256=WSfOc7hzcuk79sSTVp3wqr7NApgD_N3WgQj71hd-E6A,9064
+backlogops_cli/adjust_release_content.py,sha256=OO3nTg2puxodGi7-_Yr_-XFMe0v11NN3Zle2p4OUS0s,1914
+backlogops_cli/convert.py,sha256=hqlyXlHV8QPCRBqS6BSJxAEpij1m5aNghcwCMvPMQQM,1510
+backlogops_cli/demo_backlog.py,sha256=nUx4zr49nviQS0cJENCAIe0t0pEUg6Y8UF8sK1Vw86I,1329
+backlogops_cli/estimate_ready_date.py,sha256=2_BA4GqJYR-boXybadbAJVFb0WGdXlM-j7Qmdd4DOR0,3979
+backlogops_cli/extract_keys.py,sha256=pImQ7edlgLap9pg_DS-wjx6ioY62At4FCHKJUr6ACG8,2775
+backlogops_cli/list.py,sha256=N7SDE0asqCKf0B6UStsQuZqN-51YrIez_8pQ7Rf4j8c,2012
+backlogops_cli/order_by_deps.py,sha256=38WyIFI8HtOsamkVotHjTinMcLEquZZ6IEByRr4PkAE,2760
+backlogops_cli/order_by_keys.py,sha256=0J4FnnPCVgOE5XCYfbEyHHwRZJqYdf9Uxv36vTFFXJg,2048
+backlogops_cli/plan_release_dates.py,sha256=SWdV9Jmyn5flOM6hTJf_PWuL1gcIP9UuYuzMs0pzjtQ,1916
+backlogops_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+backlogops_cli/teams_wizard.py,sha256=W5FkAS_hb-CX_FynhaSe6l62dnrKSkntsYLNvNfrMeQ,1962
+backlogops_cli-0.1.dist-info/licenses/LICENSE.txt,sha256=YbzYf1byKHV7rKnb_zN_ouS8n9ttzGcYHpfTdTf-dPk,1072
+backlogops_cli-0.1.dist-info/METADATA,sha256=5-sS5fEbdhForLSCeyooPGN0Xyl_YEUojFrQ0dSwDxY,8358
+backlogops_cli-0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+backlogops_cli-0.1.dist-info/top_level.txt,sha256=6Vp2UR5vFqzujUt9VJ7sE9SkjBBICuS6zTe86Nzwd2w,15
+backlogops_cli-0.1.dist-info/RECORD,,

backlogops_cli-0.1.dist-info/WHEEL

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

backlogops_cli-0.1.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Tom Björkholm
+
+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.
+

backlogops_cli-0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+backlogops_cli