agent-migration-toolkit 0.1.0__py3-none-any.whl

agent_migration_toolkit/__init__.py

@@ -0,0 +1,5 @@
+"""Shared hub toolkit for the agent-migration program."""
+
+from importlib.metadata import version
+
+__version__ = version("agent-migration-toolkit")

agent_migration_toolkit/cli.py

@@ -0,0 +1,122 @@
+"""Command line entry points: thin wrappers over the pure core."""
+
+from __future__ import annotations
+
+import argparse
+import math
+import sys
+from pathlib import Path
+from typing import Any, NoReturn
+
+import tomli_w
+
+from agent_migration_toolkit.gap import compute_gaps
+from agent_migration_toolkit.schema import ValidationError, load_table
+from agent_migration_toolkit.sources import (
+    DEFAULT_TIMEOUT,
+    Fetcher,
+    load_all,
+    parse_sources,
+    urllib_fetcher,
+)
+from agent_migration_toolkit.timeline import build_timeline
+
+USER_ERRORS = (ValidationError, OSError, UnicodeDecodeError)
+EXIT_ERROR = 1
+EXIT_PARTIAL = 2
+
+
+class _Parser(argparse.ArgumentParser):
+    """argparse exits with 2 on bad arguments; use 1 so 2 only means a partial timeline."""
+
+    def error(self, message: str) -> NoReturn:
+        self.print_usage(sys.stderr)
+        self.exit(EXIT_ERROR, f"error: {message}\n")
+
+
+def gap_main(argv: list[str] | None = None) -> int:
+    """gap-analysis-creator: process table -> gap table (R-GAP-004)."""
+    parser = _Parser(
+        prog="gap-analysis-creator", description="Create a gap table from a process table"
+    )
+    parser.add_argument("process_table", type=Path, help="path to process-table.toml")
+    _add_output(parser)
+    args = parser.parse_args(argv)
+    try:
+        rows = load_table(_read_text(args.process_table))
+        _write({"gap": compute_gaps(rows)}, args.output)
+    except USER_ERRORS as exc:
+        return _fail(exc)
+    return 0
+
+
+def timeline_main(argv: list[str] | None = None, fetcher: Fetcher = urllib_fetcher) -> int:
+    """critical-path-timeline: source list -> program timeline (R-TIME-009)."""
+    parser = _Parser(
+        prog="critical-path-timeline",
+        description="Build the critical path timeline across department process tables",
+    )
+    parser.add_argument("sources", type=Path, help="path to the department source list (TOML)")
+    _add_output(parser)
+    parser.add_argument(
+        "--timeout",
+        type=_positive_seconds,
+        default=DEFAULT_TIMEOUT,
+        help=f"seconds per fetch (default: {DEFAULT_TIMEOUT})",
+    )
+    args = parser.parse_args(argv)
+    try:
+        sources = parse_sources(_read_text(args.sources))
+        loaded = load_all(
+            sources, fetcher=fetcher, base_dir=args.sources.parent, timeout=args.timeout
+        )
+        timeline = build_timeline(loaded)
+        if not timeline["department"]:
+            raise ValidationError(f"no department could be processed: {_reasons(timeline)}")
+        _write(timeline, args.output)
+    except USER_ERRORS as exc:
+        return _fail(exc)
+    for failure in timeline["failure"]:
+        sys.stderr.write(f"warning: {failure['department']}: {failure['reason']}\n")
+    return EXIT_PARTIAL if timeline["failure"] else 0
+
+
+def _positive_seconds(text: str) -> float:
+    value = float(text)
+    if not math.isfinite(value) or value <= 0:
+        raise argparse.ArgumentTypeError(f"must be a positive number of seconds, got {text!r}")
+    return value
+
+
+def _reasons(timeline: dict[str, Any]) -> str:
+    return "; ".join(f"{f['department']}: {f['reason']}" for f in timeline["failure"]) or "none"
+
+
+def _read_text(path: Path) -> str:
+    try:
+        return path.read_text(encoding="utf-8")
+    except UnicodeDecodeError as exc:
+        raise ValidationError(f"{path}: not UTF-8 text") from exc
+
+
+def _fail(exc: Exception) -> int:
+    """Print a one-line error to stderr and return exit code 1 (NFR-03)."""
+    message = " ".join(str(exc).split())
+    sys.stderr.write(f"error: {message}\n")
+    return EXIT_ERROR
+
+
+def _add_output(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "-o", "--output", type=Path, default=None, help="output path (default: stdout)"
+    )
+
+
+def _write(data: dict[str, Any], output: Path | None) -> None:
+    text = tomli_w.dumps(data)
+    if output is None:
+        sys.stdout.flush()
+        sys.stdout.buffer.write(text.encode("utf-8"))
+        sys.stdout.buffer.flush()
+    else:
+        output.write_text(text, encoding="utf-8")

agent_migration_toolkit/gap.py

@@ -0,0 +1,29 @@
+"""Gap analysis: sub-processes whose interface is not yet an OpenAPI contract (R-GAP)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+GAP_DESCRIPTIONS = {
+    "none": "no artifact defined yet - needs artifact definition first",
+    "manual": "manual handoff - needs schema and an OpenAPI endpoint",
+    "file": "file-based handoff - needs an OpenAPI wrap or bridge",
+}
+CARRIED_FIELDS = ("effort_days", "depends_on")
+
+
+def compute_gaps(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Return one gap row per validated row whose interface_type is not openapi."""
+    return [_gap_row(row) for row in rows if row["interface_type"] != "openapi"]
+
+
+def _gap_row(row: dict[str, Any]) -> dict[str, Any]:
+    gap = {
+        "department": row["department"],
+        "process": row["process"],
+        "sub_process": row["sub_process"],
+        "current_interface": row["interface_type"],
+        "gap": GAP_DESCRIPTIONS[row["interface_type"]],
+    }
+    gap.update({field: row[field] for field in CARRIED_FIELDS if field in row})
+    return gap

agent_migration_toolkit/schema.py

@@ -0,0 +1,115 @@
+"""Process-table data contract: parsing and validation (R-SCHEMA)."""
+
+from __future__ import annotations
+
+import math
+import tomllib
+from typing import Any
+
+
+class ValidationError(ValueError):
+    """Raised when a process table or source list breaks the contract."""
+
+
+def parse_toml(text: str) -> dict[str, Any]:
+    """Parse TOML text, turning syntax errors into ValidationError."""
+    try:
+        return tomllib.loads(text)
+    except tomllib.TOMLDecodeError as exc:
+        raise ValidationError(f"not valid TOML: {exc}") from exc
+
+
+def parse_table(text: str) -> list[dict[str, Any]]:
+    """Parse TOML text into the list of [[sub_process]] rows (R-SCHEMA-001)."""
+    rows = parse_toml(text).get("sub_process")
+    if not isinstance(rows, list) or not all(isinstance(row, dict) for row in rows):
+        raise ValidationError("process table must contain a [[sub_process]] array of tables")
+    return rows
+
+
+REQUIRED_FIELDS = (
+    "department",
+    "process",
+    "sub_process",
+    "automation_grade",
+    "output_artifact",
+    "interface_type",
+)
+
+VALID_GRADES = ("full", "partial", "manual")
+VALID_INTERFACE_TYPES = ("openapi", "file", "manual", "none")
+ENUM_FIELDS = {"automation_grade": VALID_GRADES, "interface_type": VALID_INTERFACE_TYPES}
+
+
+def _label(index: int, row: dict[str, Any]) -> str:
+    return f"row {index + 1} ({row.get('department', '?')}/{row.get('sub_process', '?')})"
+
+
+def validate_table(rows: list[dict[str, Any]]) -> list[str]:
+    """Return every contract violation in the table, one message per problem."""
+    names_by_department: dict[str, set[str]] = {}
+    for row in rows:
+        names_by_department.setdefault(_text(row, "department"), set()).add(
+            _text(row, "sub_process")
+        )
+    errors: list[str] = []
+    seen: set[tuple[str, str]] = set()
+    for index, row in enumerate(rows):
+        key = (_text(row, "department"), _text(row, "sub_process"))
+        problems = ["duplicate department and sub_process"] if key in seen else []
+        seen.add(key)
+        problems += _row_problems(row, names_by_department[key[0]])
+        errors.extend(f"{_label(index, row)}: {problem}" for problem in problems)
+    return errors
+
+
+def _text(row: dict[str, Any], field: str) -> str:
+    """Hashable text form of a field, used for lookups before types are checked."""
+    value = row.get(field)
+    return value if isinstance(value, str) else repr(value)
+
+
+def _row_problems(row: dict[str, Any], known: set[str]) -> list[str]:
+    """Every problem of one row; checks run on whatever fields are present (F-11)."""
+    problems: list[str] = []
+    missing = [field for field in REQUIRED_FIELDS if field not in row]
+    if missing:
+        problems.append(f"missing fields {missing}")
+    not_text = [f for f in REQUIRED_FIELDS if f in row and not isinstance(row[f], str)]
+    if not_text:
+        problems.append(f"fields must be strings: {not_text}")
+    problems += [
+        f"invalid {field} {row[field]!r}"
+        for field, allowed in ENUM_FIELDS.items()
+        if isinstance(row.get(field), str) and row[field] not in allowed
+    ]
+    if "effort_days" in row and not _is_non_negative_number(row["effort_days"]):
+        problems.append(f"effort_days must be a finite non-negative number, got {row['effort_days']!r}")
+    if "depends_on" in row:
+        problems += _depends_on_problems(row["depends_on"], known)
+    return problems
+
+
+def _depends_on_problems(depends_on: Any, known: set[str]) -> list[str]:
+    if not isinstance(depends_on, list) or not all(isinstance(n, str) for n in depends_on):
+        return [f"depends_on must be a list of sub_process names, got {depends_on!r}"]
+    return [
+        f"depends_on {name!r} is not a sub_process of the same department"
+        for name in depends_on
+        if name not in known
+    ]
+
+
+def _is_non_negative_number(value: Any) -> bool:
+    if not isinstance(value, int | float) or isinstance(value, bool):
+        return False
+    return math.isfinite(value) and value >= 0
+
+
+def load_table(text: str) -> list[dict[str, Any]]:
+    """Parse and validate a process table; raise ValidationError listing every problem."""
+    rows = parse_table(text)
+    errors = validate_table(rows)
+    if errors:
+        raise ValidationError("; ".join(errors))
+    return rows

agent_migration_toolkit/sources.py

@@ -0,0 +1,111 @@
+"""Department source list and fetching of process tables (R-SRC)."""
+
+from __future__ import annotations
+
+import urllib.request
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+from urllib.error import URLError
+from urllib.parse import urlsplit
+
+from agent_migration_toolkit.schema import ValidationError, load_table, parse_toml
+
+ALLOWED_HOST = "raw.githubusercontent.com"
+DEFAULT_TIMEOUT = 10.0
+
+Fetcher = Callable[[str, float], str]
+
+
+@dataclass(frozen=True)
+class Source:
+    department: str
+    url: str | None = None
+    path: str | None = None
+
+
+def parse_sources(text: str) -> list[Source]:
+    """Parse the TOML source list into one Source per [[department]] entry (R-SRC-001)."""
+    entries = parse_toml(text).get("department")
+    if not isinstance(entries, list) or not all(isinstance(e, dict) for e in entries):
+        raise ValidationError("source list must contain a [[department]] array of tables")
+    return [_source(index, entry) for index, entry in enumerate(entries)]
+
+
+def _source(index: int, entry: dict[str, Any]) -> Source:
+    name = entry.get("name")
+    if not isinstance(name, str) or not name:
+        raise ValidationError(f"source entry {index + 1}: missing name")
+    url, path = entry.get("url"), entry.get("path")
+    if (url is None) == (path is None):
+        raise ValidationError(f"source {name!r}: needs exactly one of url or path")
+    if url is not None and not _is_allowed_url(url):
+        raise ValidationError(f"source {name!r}: url must be https://{ALLOWED_HOST}/...")
+    return Source(name, url=url, path=path)
+
+
+def _is_allowed_url(url: Any) -> bool:
+    if not isinstance(url, str):
+        return False
+    parts = urlsplit(url)
+    return parts.scheme == "https" and parts.hostname == ALLOWED_HOST
+
+
+class _SameHostRedirect(urllib.request.HTTPRedirectHandler):
+    """Follow redirects only when they stay on the allowed https host (R-SRC-003)."""
+
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        if not _is_allowed_url(newurl):
+            raise URLError(f"refused redirect to {newurl}")
+        return super().redirect_request(req, fp, code, msg, headers, newurl)
+
+
+_OPENER = urllib.request.build_opener(_SameHostRedirect)
+
+
+def urllib_fetcher(url: str, timeout: float) -> str:
+    """Fetch a URL as UTF-8 text. Callers pass only urls checked by _is_allowed_url."""
+    with _OPENER.open(url, timeout=timeout) as response:  # nosec B310
+        return response.read().decode("utf-8")
+
+
+@dataclass(frozen=True)
+class Loaded:
+    department: str
+    rows: list[dict[str, Any]] | None = None
+    error: str | None = None
+
+
+def load_all(
+    sources: list[Source],
+    fetcher: Fetcher,
+    base_dir: Path,
+    timeout: float = DEFAULT_TIMEOUT,
+) -> list[Loaded]:
+    """Load and validate every department's process table."""
+    return [_load_one(source, fetcher, base_dir, timeout) for source in sources]
+
+
+def _load_one(source: Source, fetcher: Fetcher, base_dir: Path, timeout: float) -> Loaded:
+    try:
+        rows = load_table(_read(source, fetcher, base_dir, timeout))
+    except (TimeoutError, URLError) as exc:
+        if isinstance(exc, TimeoutError) or isinstance(exc.reason, TimeoutError):
+            return Loaded(source.department, error=f"timeout after {timeout} s")
+        return Loaded(source.department, error=f"fetch failed: {exc.reason}")
+    except (OSError, UnicodeDecodeError, ValidationError) as exc:
+        return Loaded(source.department, error=str(exc))
+    foreign = sorted({row["department"] for row in rows} - {source.department})
+    if foreign:
+        return Loaded(
+            source.department,
+            error=f"table contains department(s) {foreign}, expected {source.department!r}",
+        )
+    return Loaded(source.department, rows=rows)
+
+
+def _read(source: Source, fetcher: Fetcher, base_dir: Path, timeout: float) -> str:
+    if source.url is not None:
+        return fetcher(source.url, timeout)
+    return (base_dir / str(source.path)).read_text(encoding="utf-8")

agent_migration_toolkit/timeline.py

@@ -0,0 +1,119 @@
+"""Critical path timeline per department and across the program (R-TIME)."""
+
+from __future__ import annotations
+
+from graphlib import CycleError, TopologicalSorter
+from typing import Any
+
+from agent_migration_toolkit.gap import compute_gaps
+from agent_migration_toolkit.schema import ValidationError
+from agent_migration_toolkit.sources import Loaded
+
+GAP_FIELDS = ("process", "sub_process", "current_interface")
+TOLERANCE = 1e-9
+QUICK_RAMP_SHARE = 0.2
+
+
+def find_cycle(rows: list[dict[str, Any]]) -> list[str] | None:
+    """Return the sub_process names of one depends_on cycle, or None (R-TIME-008)."""
+    graph = {row["sub_process"]: row.get("depends_on", []) for row in rows}
+    try:
+        TopologicalSorter(graph).prepare()
+    except CycleError as exc:
+        return exc.args[1]
+    return None
+
+
+def schedule_department(department: str, rows: list[dict[str, Any]]) -> dict[str, Any]:
+    """Schedule the gap rows of one department's validated table."""
+    cycle = find_cycle(rows)
+    if cycle:
+        raise ValidationError(f"depends_on cycle: {' -> '.join(cycle)}")
+    gaps = compute_gaps(rows)
+    estimated = {gap["sub_process"]: gap for gap in gaps if "effort_days" in gap}
+    unestimated = [gap for gap in gaps if "effort_days" not in gap]
+    tasks, length = _schedule(estimated, {gap["sub_process"] for gap in unestimated})
+    critical = sorted((t for t in tasks if t["critical"]), key=lambda t: t["earliest_start"])
+    return {
+        "name": department,
+        "critical_path_days": length,
+        "critical_path": [t["sub_process"] for t in critical],
+        "task": tasks,
+        "unestimated": [_pick(gap) for gap in unestimated],
+    }
+
+
+def _pick(gap: dict[str, Any]) -> dict[str, Any]:
+    return {key: gap[key] for key in GAP_FIELDS}
+
+
+def _schedule(
+    gaps: dict[str, dict[str, Any]], unestimated: set[str]
+) -> tuple[list[dict[str, Any]], float]:
+    """Critical path method over tasks; predecessors that are not tasks are ignored."""
+    preds = {
+        name: [p for p in gap.get("depends_on", []) if p in gaps] for name, gap in gaps.items()
+    }
+    order = list(TopologicalSorter(preds).static_order())
+
+    start: dict[str, float] = {}
+    finish: dict[str, float] = {}
+    for name in order:
+        start[name] = max((finish[p] for p in preds[name]), default=0)
+        finish[name] = start[name] + gaps[name]["effort_days"]
+    length = max(finish.values(), default=0)
+
+    succs: dict[str, list[str]] = {name: [] for name in gaps}
+    for name, names in preds.items():
+        for pred in names:
+            succs[pred].append(name)
+    latest_start: dict[str, float] = {}
+    for name in reversed(order):
+        latest_finish = min((latest_start[s] for s in succs[name]), default=length)
+        latest_start[name] = latest_finish - gaps[name]["effort_days"]
+
+    tasks = []
+    for name, gap in gaps.items():
+        slack = latest_start[name] - start[name]
+        critical = abs(slack) < TOLERANCE
+        tasks.append(
+            {
+                **_pick(gap),
+                "effort_days": gap["effort_days"],
+                "earliest_start": start[name],
+                "earliest_finish": finish[name],
+                "slack_days": 0 if critical else slack,
+                "critical": critical,
+                "block": _block(start[name], length),
+                "waits_on_unestimated": [
+                    p for p in gap.get("depends_on", []) if p in unestimated
+                ],
+            }
+        )
+    return tasks, length
+
+
+def _block(earliest_start: float, length: float) -> str:
+    if length == 0 or earliest_start < QUICK_RAMP_SHARE * length - TOLERANCE:
+        return "quick_ramp"
+    return "hardening"
+
+
+def build_timeline(loaded: list[Loaded]) -> dict[str, Any]:
+    """Schedule every loaded department and summarise the program (R-TIME-001/007)."""
+    departments: list[dict[str, Any]] = []
+    failures: list[dict[str, str]] = []
+    for item in loaded:
+        if item.rows is None:
+            failures.append({"department": item.department, "reason": str(item.error)})
+            continue
+        try:
+            departments.append(schedule_department(item.department, item.rows))
+        except ValidationError as exc:
+            failures.append({"department": item.department, "reason": str(exc)})
+    longest = max(departments, key=lambda d: d["critical_path_days"], default=None)
+    program = {
+        "length_days": longest["critical_path_days"] if longest else 0,
+        "critical_department": longest["name"] if longest else "",
+    }
+    return {"program": program, "department": departments, "failure": failures}

agent_migration_toolkit-0.1.0.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: agent-migration-toolkit
+Version: 0.1.0
+Summary: Shared hub toolkit for the agent-migration program: process tables, gap analysis, critical path timeline
+Keywords: agent-migration,process-table,gap-analysis,critical-path,toml
+Author: roebi
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: tomli-w>=1.0
+Requires-Python: >=3.11
+Project-URL: Homepage, https://github.com/roebi/agent-migration-toolkit
+Project-URL: Repository, https://github.com/roebi/agent-migration-toolkit
+Project-URL: Changelog, https://github.com/roebi/agent-migration-toolkit/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/roebi/agent-migration-toolkit/issues
+Description-Content-Type: text/markdown
+
+# agent-migration-toolkit
+
+Shared hub toolkit for the agent-migration program. Departments describe
+their processes in a TOML process table; the toolkit shows which
+handoffs are not yet clean OpenAPI contracts (gaps) and builds a
+critical path timeline across all departments.
+
+- **`gap-analysis-creator`** - one department: process table -> gap table,
+  with the next step for each gap.
+- **`critical-path-timeline`** - all departments: reads each department's
+  process table (local file or `raw.githubusercontent.com`) and writes
+  the critical path (red thread) per department, the quick ramp /
+  hardening split and the program length.
+- **Schema and templates** - the process-table contract and the
+  collection meeting templates used in every department.
+
+The toolkit only reads process tables and writes local TOML files; it
+never changes anything in a department repo.
+
+## Installation
+
+Python 3.11 or newer.
+
+```console
+$ pip install agent-migration-toolkit
+```
+
+or in a uv project:
+
+```console
+$ uv add agent-migration-toolkit
+```
+
+## Quickstart
+
+The example files are in
+[`docs/examples/`](https://github.com/roebi/agent-migration-toolkit/tree/main/docs/examples).
+
+Gap table for one department:
+
+```console
+$ gap-analysis-creator docs/examples/finance-process-table.toml
+```
+
+Timeline across departments, listed in a source list:
+
+```console
+$ critical-path-timeline docs/examples/sources.toml -o timeline.toml
+```
+
+A source list names each department and where its table lives:
+
+```toml
+[[department]]
+name = "Finance/Billing"
+path = "finance-process-table.toml"
+
+[[department]]
+name = "Legal/Compliance"
+url = "https://raw.githubusercontent.com/<owner>/<repo>/main/process-table.toml"
+```
+
+Exit codes: 0 success, 1 invalid input, 2 timeline written but some
+departments failed.
+
+## Documentation
+
+- [Usage guide](https://github.com/roebi/agent-migration-toolkit/blob/main/docs/usage.md) -
+  process-table fields, source list, output format, exit codes
+- [Process-table schema](https://github.com/roebi/agent-migration-toolkit/blob/main/schema/process-table.schema.toml) -
+  copy it as the start of a department's `process-table.toml`
+- [Collection templates](https://github.com/roebi/agent-migration-toolkit/tree/main/templates)
+- [CHANGELOG.md](https://github.com/roebi/agent-migration-toolkit/blob/main/CHANGELOG.md)
+
+## Development
+
+```console
+$ uv sync
+$ uv run pytest --cov=src --cov-report=term-missing
+$ uv run ruff check src/ tests/
+```
+
+## License
+
+[MIT](https://github.com/roebi/agent-migration-toolkit/blob/main/LICENSE)

agent_migration_toolkit-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+agent_migration_toolkit/__init__.py,sha256=bZZM36LLVnEGkrQiM3kZppiHkSlhCvFNjwPclxx_3QQ,148
+agent_migration_toolkit/cli.py,sha256=WaYA9q4rkIte13RB4T_RPeWwyvhv7rURSAx_E8ZlPNc,4060
+agent_migration_toolkit/gap.py,sha256=OW175CtIiWvXMtMMFCcWipX9R_22wLX2EsAMgdMY-NI,1065
+agent_migration_toolkit/schema.py,sha256=VcWTnjwDeC1KtKfOTVXJS4AaPA7n6xm9ojTL2DUVfTI,4281
+agent_migration_toolkit/sources.py,sha256=wjf2xIZmxXDe5eu1Ya1HxtEMP64_wTv4WUeEbuIZL4o,4067
+agent_migration_toolkit/timeline.py,sha256=PK3n2PzH-St2WUfJ2Y3CTmCtF3tHczNAd5MSWrXv9Y8,4627
+agent_migration_toolkit-0.1.0.dist-info/licenses/LICENSE,sha256=de8OV1f9KfA6SMJEHwW2YCtIFT-JBfOYBASV_QUEWXs,1062
+agent_migration_toolkit-0.1.0.dist-info/WHEEL,sha256=MWx7psoF7KNST9G72pGtiBYuaXRXQXBk9pw5R6FzYko,80
+agent_migration_toolkit-0.1.0.dist-info/entry_points.txt,sha256=4LWFFxY_1mFN_VkCV3I1IY1WCO9Tki-d52t3SATlBrY,146
+agent_migration_toolkit-0.1.0.dist-info/METADATA,sha256=2-dlYP4cNChEenxxJwRdon3ZBdWxnFcDMSfGtIQOX1g,3643
+agent_migration_toolkit-0.1.0.dist-info/RECORD,,

agent_migration_toolkit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.13.7
+Root-Is-Purelib: true
+Tag: py3-none-any

agent_migration_toolkit-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+critical-path-timeline = agent_migration_toolkit.cli:timeline_main
+gap-analysis-creator = agent_migration_toolkit.cli:gap_main
+

agent_migration_toolkit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 roebi
+
+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.