digital-brain 0.1.7 → 1.0.5

package/scripts/digital_brain_relationship_extractor.py

@@ -3,6 +3,7 @@ import argparse
 import json
 import math
 import re
+import time
 from collections import Counter, defaultdict
 from datetime import datetime, timezone
 from pathlib import Path
@@ -17,26 +18,36 @@ SLANG = {"lol", "lmao", "haha", "hahaha", "bro", "bruh", "wtf", "omg", "ngl", "i
 def main():
     args = parse_args()
     vault = args.vault.resolve()
-    whatsapp = vault / "08 Sources" / "WhatsApp"
-    output_dir = whatsapp / "Analysis"
+    sources = vault / "08 Sources"
+    output_dir = sources / "Analysis"
     output_dir.mkdir(parents=True, exist_ok=True)
-    messages = load_messages(whatsapp / "Raw", args.days)
+    messages = load_messages(sources, args.days)
     profiles = build_profiles(messages, args.min_messages)
-    (output_dir / "relationship_profiles.json").write_text(json.dumps(profiles, indent=2, ensure_ascii=False), encoding="utf-8")
+    people = build_people(profiles)
+    write_json_atomic(output_dir / "relationship_profiles.json", profiles)
+    write_json_atomic(output_dir / "person_identity_map.json", people)
     write_markdown(output_dir / "Relationship Map.md", profiles, args.days)
+    write_people_memory(vault / "06 AI Memory" / "Person Context Index.md", people, args.days)
+    write_legacy_whatsapp_outputs(vault, output_dir)
     print(f"Analyzed {len(messages)} messages.")
     print(f"Wrote {len(profiles)} relationship profiles.")
+    print(f"Wrote {len(people)} canonical person records.")
 
 
-def load_messages(raw_dir, days):
+def load_messages(sources_dir, days):
     cutoff = datetime.now(timezone.utc).timestamp() - days * 24 * 60 * 60 if days else None
     messages = []
-    for path in sorted(raw_dir.glob("*.jsonl")):
+    raw_files = sorted(sources_dir.glob("*/Raw/*.jsonl"))
+    for path in raw_files:
         with path.open("r", encoding="utf-8") as f:
             for line in f:
                 if not line.strip():
                     continue
-                record = json.loads(line)
+                try:
+                    record = json.loads(line)
+                except json.JSONDecodeError:
+                    print(f"Skipping corrupt JSONL line in {path}")
+                    continue
                 dt = datetime.fromisoformat(record["timestamp"].replace("Z", "+00:00"))
                 if cutoff and dt.timestamp() < cutoff:
                     continue
@@ -48,13 +59,15 @@ def load_messages(raw_dir, days):
 def build_profiles(messages, min_messages):
     by_chat = defaultdict(list)
     for message in messages:
-        by_chat[message.get("chatName") or "Unknown Chat"].append(message)
-    profiles = [profile_chat(name, items) for name, items in by_chat.items() if len(items) >= min_messages]
+        key = f"{message.get('sourceSystem') or source_system(message)}::{message.get('chatName') or 'Unknown Chat'}"
+        by_chat[key].append(message)
+    profiles = [profile_chat(key, items) for key, items in by_chat.items() if len(items) >= min_messages]
     profiles.sort(key=lambda p: (p["messageCount"], p["lastSeen"]), reverse=True)
     return profiles
 
 
-def profile_chat(chat_name, messages):
+def profile_chat(chat_key, messages):
+    source, chat_name = split_chat_key(chat_key)
     count = len(messages)
     outbound = sum(1 for m in messages if m.get("fromMe"))
     inbound = count - outbound
@@ -72,8 +85,15 @@ def profile_chat(chat_name, messages):
     sentiment = normalized_sentiment(positive, negative, count)
     tags = infer_tags(any(m.get("isGroup") for m in messages), count, inbound, outbound, warmth, friction, operational, work, logistics, text.count("?"))
     guess = infer_relationship(tags, count, warmth, friction, operational, work, outbound / count)
+    identity = infer_identity(source, chat_name, messages)
     return {
         "chatName": chat_name,
+        "sourceSystem": source,
+        "displayName": f"{chat_name} ({source})",
+        "identityName": identity["name"],
+        "canonicalPersonKey": identity["key"],
+        "identityConfidence": identity["confidence"],
+        "identityEvidence": identity["evidence"],
         "messageCount": count,
         "inbound": inbound,
         "outbound": outbound,
@@ -130,12 +150,110 @@ def infer_relationship(tags, count, warmth, friction, operational, work, balance
     return "general relationship, needs human labeling"
 
 
+def infer_identity(source, chat_name, messages):
+    is_group = any(m.get("isGroup") for m in messages)
+    if is_group:
+        return {
+            "name": chat_name,
+            "key": f"group::{source.lower()}::{normalize_identity(chat_name)}",
+            "confidence": "medium",
+            "evidence": "group chat kept source-specific",
+        }
+    candidates = []
+    if source in {"Slack", "LinkedIn"}:
+        candidates.extend((m.get("author") or "").strip() for m in messages if not m.get("fromMe"))
+    if source == "LinkedIn":
+        candidates.extend((m.get("to") or "").split(",")[0].strip() for m in messages if m.get("fromMe"))
+    candidates.append(chat_name)
+    name = best_identity_name(candidates) or chat_name
+    key = f"person::{normalize_identity(name)}"
+    confidence = "medium" if normalize_identity(name) == normalize_identity(chat_name) else "low"
+    if source in {"Slack", "LinkedIn"} and normalize_identity(name) != normalize_identity(chat_name):
+        confidence = "medium"
+    return {
+        "name": name,
+        "key": key,
+        "confidence": confidence,
+        "evidence": f"{source} direct chat identity",
+    }
+
+
+def best_identity_name(candidates):
+    cleaned = [candidate for candidate in candidates if usable_identity_name(candidate)]
+    if not cleaned:
+        return ""
+    counts = Counter(normalize_identity(candidate) for candidate in cleaned)
+    best_key, _ = counts.most_common(1)[0]
+    for candidate in cleaned:
+        if normalize_identity(candidate) == best_key:
+            return candidate
+    return cleaned[0]
+
+
+def usable_identity_name(value):
+    if not value:
+        return False
+    normalized = normalize_identity(value)
+    if not normalized or normalized in {"me", "you", "unknown", "unknown chat", "imessage"}:
+        return False
+    return True
+
+
+def normalize_identity(value):
+    text = str(value or "").lower()
+    text = re.sub(r"<[^>]+>", " ", text)
+    text = re.sub(r"https?://\S+", " ", text)
+    text = re.sub(r"[^a-z0-9@+]+", " ", text)
+    return " ".join(text.split())
+
+
+def build_people(profiles):
+    grouped = defaultdict(list)
+    for profile in profiles:
+        key = profile.get("canonicalPersonKey")
+        if key and not key.startswith("group::"):
+            grouped[key].append(profile)
+    people = []
+    for key, items in grouped.items():
+        items.sort(key=lambda item: (item["messageCount"], item["lastSeen"]), reverse=True)
+        sources = sorted({item["sourceSystem"] for item in items})
+        names = [item.get("identityName") or item["chatName"] for item in items]
+        people.append({
+            "canonicalPersonKey": key,
+            "displayName": names[0],
+            "aliases": sorted({name for name in names if name}),
+            "sources": sources,
+            "sourceProfiles": [
+                {
+                    "sourceSystem": item["sourceSystem"],
+                    "chatName": item["chatName"],
+                    "displayName": item["displayName"],
+                    "messageCount": item["messageCount"],
+                    "firstSeen": item["firstSeen"],
+                    "lastSeen": item["lastSeen"],
+                    "relationshipGuess": item["relationshipGuess"],
+                    "typingStyle": item["typingStyle"],
+                    "identityConfidence": item["identityConfidence"],
+                    "identityEvidence": item["identityEvidence"],
+                }
+                for item in items
+            ],
+            "totalMessages": sum(item["messageCount"] for item in items),
+            "firstSeen": min(item["firstSeen"] for item in items),
+            "lastSeen": max(item["lastSeen"] for item in items),
+        })
+    people.sort(key=lambda person: (len(person["sources"]), person["totalMessages"], person["lastSeen"]), reverse=True)
+    return people
+
+
 def write_markdown(path, profiles, days):
     lines = ["# Relationship Map", "", f"Window: last {days} days", "", "Generated signals. Treat as editable working notes.", ""]
     for profile in profiles:
         lines.extend([
-            f"## {profile['chatName']}",
+            f"## {profile['displayName']}",
             "",
+            f"- Source: {profile['sourceSystem']}",
+            f"- Canonical person: {profile['identityName']} ({profile['canonicalPersonKey']})",
             f"- Guess: {profile['relationshipGuess']}",
             f"- Messages: {profile['messageCount']} ({profile['inbound']} inbound, {profile['outbound']} outbound)",
             f"- Dates: {profile['firstSeen']} to {profile['lastSeen']}",
@@ -144,7 +262,66 @@ def write_markdown(path, profiles, days):
             f"- Typing style: {typing_style_summary(profile['typingStyle'])}",
             "",
         ])
-    path.write_text("\n".join(lines), encoding="utf-8")
+    write_text_atomic(path, "\n".join(lines))
+
+
+def write_people_memory(path, people, days):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    lines = ["# Person Context Index", "", f"Window: last {days} days", "", "Canonical people matched across sources. Treat matches as provisional unless manually confirmed.", ""]
+    for person in people:
+        lines.extend([
+            f"## {person['displayName']}",
+            "",
+            f"- Canonical key: `{person['canonicalPersonKey']}`",
+            f"- Aliases: {', '.join(person['aliases'])}",
+            f"- Sources: {', '.join(person['sources'])}",
+            f"- Messages: {person['totalMessages']}",
+            f"- Dates: {person['firstSeen']} to {person['lastSeen']}",
+            "- Source-specific context:",
+        ])
+        for source in person["sourceProfiles"]:
+            style = typing_style_summary(source.get("typingStyle", {}))
+            lines.append(f"  - {source['sourceSystem']} / {source['chatName']}: {source['relationshipGuess']}; {source['messageCount']} messages; style {style}")
+        lines.append("")
+    write_text_atomic(path, "\n".join(lines) + "\n")
+
+
+def write_legacy_whatsapp_outputs(vault, output_dir):
+    legacy_dir = vault / "08 Sources" / "WhatsApp" / "Analysis"
+    legacy_dir.mkdir(parents=True, exist_ok=True)
+    for name in ("relationship_profiles.json", "person_identity_map.json", "Relationship Map.md"):
+        source = output_dir / name
+        target = legacy_dir / name
+        if source.exists():
+            write_text_atomic(target, source.read_text(encoding="utf-8"))
+
+
+def write_json_atomic(path, data):
+    write_text_atomic(path, json.dumps(data, indent=2, ensure_ascii=False))
+
+
+def write_text_atomic(path, content):
+    temp = path.with_name(f"{path.name}.{time.time_ns()}.tmp")
+    temp.write_text(content, encoding="utf-8")
+    temp.replace(path)
+
+
+def source_system(message):
+    source = message.get("source") or ""
+    if "Slack" in source:
+        return "Slack"
+    if "LinkedIn" in source:
+        return "LinkedIn"
+    if "WhatsApp" in source:
+        return "WhatsApp"
+    return "Unknown"
+
+
+def split_chat_key(key):
+    if "::" not in key:
+        return "Unknown", key
+    source, chat_name = key.split("::", 1)
+    return source, chat_name
 
 
 def score(words, lexicon):

package/scripts/digital_brain_relationship_interpreter.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 import argparse
 import json
+import time
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -19,26 +20,38 @@ ROLE_KEYWORDS = [
 def main():
     args = parse_args()
     vault = args.vault.resolve()
-    whatsapp = vault / "08 Sources" / "WhatsApp"
-    profile_path = whatsapp / "Analysis" / "relationship_profiles.json"
+    sources = vault / "08 Sources"
+    whatsapp = sources / "WhatsApp"
+    analysis = sources / "Analysis"
+    profile_path = analysis / "relationship_profiles.json"
+    if not profile_path.exists():
+        profile_path = whatsapp / "Analysis" / "relationship_profiles.json"
     profiles = json.loads(profile_path.read_text(encoding="utf-8"))
-    overrides = load_json(whatsapp / "relationship_overrides.json", {})
-    out_dir = whatsapp / "Analysis" / "Interpreted"
-    people_dir = vault / "04 People" / "Interpreted Relationships"
+    people_path = analysis / "person_identity_map.json"
+    people = load_json(people_path, [])
+    overrides = load_overrides(sources)
+    out_dir = analysis / "Interpreted"
+    legacy_out_dir = whatsapp / "Analysis" / "Interpreted"
+    drafts_dir = vault / "06 AI Memory" / "Generated Relationship Drafts"
     out_dir.mkdir(parents=True, exist_ok=True)
-    people_dir.mkdir(parents=True, exist_ok=True)
+    legacy_out_dir.mkdir(parents=True, exist_ok=True)
+    drafts_dir.mkdir(parents=True, exist_ok=True)
 
     models = []
     for profile in profiles:
-        model = build_model(profile, overrides.get(profile["chatName"], {}))
+        override = overrides.get(profile_key(profile), overrides.get(profile["chatName"], {}))
+        model = build_model(profile, override)
         note = render_note(model)
-        filename = safe_filename(profile["chatName"]) + ".md"
-        (out_dir / filename).write_text(note, encoding="utf-8")
-        (people_dir / filename).write_text(note, encoding="utf-8")
+        filename = safe_filename(profile.get("displayName") or profile["chatName"]) + ".md"
+        write_text_atomic(out_dir / filename, note)
+        write_text_atomic(legacy_out_dir / filename, note)
+        write_text_atomic(drafts_dir / filename, note)
         models.append(model)
 
-    (whatsapp / "Analysis" / "interpreted_relationship_models.json").write_text(json.dumps(models, indent=2, ensure_ascii=False), encoding="utf-8")
+    write_json_atomic(analysis / "interpreted_relationship_models.json", models)
+    write_json_atomic(whatsapp / "Analysis" / "interpreted_relationship_models.json", models)
     write_index(vault / "06 AI Memory" / "Interpreted Relationship Memory.md", models)
+    write_person_reply_index(vault / "06 AI Memory" / "Person Reply Context.md", people, models)
     print(f"Wrote interpreted notes: {len(models)}")
 
 
@@ -130,16 +143,17 @@ def infer_boundaries(role, difficulty):
 
 
 def render_note(model):
-    return f"""# {model['chatName']}
+    return f"""# {model.get('displayName') or model['chatName']}
 
 Generated: {datetime.now(timezone.utc).isoformat()}
+Source: {model.get('sourceSystem', 'Unknown')}
 Role: {model['role']}
 Role confidence: {model['roleConfidence']}
 Closeness: {model['closeness']}
 Conversation difficulty: {model['conversationDifficulty']}
 Typing style: {model['typingStyle'].get('signature', 'unknown')}
 
-These are private working notes. Edit them where wrong.
+Generated draft, not truth. These are private working notes. Edit them where wrong.
 
 ## Role / Relationship Label
 - {model['role']} ({model['roleConfidence']} confidence).
@@ -173,8 +187,62 @@ def write_index(path, models):
     lines = ["# Interpreted Relationship Memory", "", "Generated working notes. Treat as editable, not truth.", ""]
     for model in models:
         style = model.get("typingStyle", {}).get("signature", "unknown style")
-        lines.append(f"- [[{safe_filename(model['chatName'])}]]: {model['role']} ({model['roleConfidence']}), closeness {model['closeness']}, difficulty {model['conversationDifficulty']}, style {style}")
-    path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+        display = model.get("displayName") or model["chatName"]
+        lines.append(f"- [[{safe_filename(display)}]]: {model['role']} ({model['roleConfidence']}), closeness {model['closeness']}, difficulty {model['conversationDifficulty']}, style {style}")
+    write_text_atomic(path, "\n".join(lines) + "\n")
+
+
+def write_person_reply_index(path, people, models):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    models_by_key = {}
+    for model in models:
+        key = model.get("canonicalPersonKey")
+        if key:
+            models_by_key.setdefault(key, []).append(model)
+    if not people:
+        people = synthesize_people(models_by_key)
+    lines = [
+        "# Person Reply Context",
+        "",
+        "Use this first when responding to a specific person. It merges confirmed-looking matches across sources while keeping each source visible.",
+        "",
+    ]
+    for person in people:
+        key = person.get("canonicalPersonKey")
+        linked_models = sorted(models_by_key.get(key, []), key=lambda model: (model["messageCount"], model["lastSeen"]), reverse=True)
+        if not linked_models:
+            continue
+        lines.extend([
+            f"## {person.get('displayName') or linked_models[0].get('identityName') or linked_models[0]['chatName']}",
+            "",
+            f"- Canonical key: `{key}`",
+            f"- Aliases: {', '.join(person.get('aliases') or [])}",
+            f"- Sources: {', '.join(sorted({model['sourceSystem'] for model in linked_models}))}",
+            f"- Total messages: {sum(model['messageCount'] for model in linked_models)}",
+            "- Source-specific guidance:",
+        ])
+        for model in linked_models:
+            lines.extend([
+                f"  - {model['sourceSystem']} / {model['chatName']}: {model['role']} ({model['roleConfidence']}), closeness {model['closeness']}, difficulty {model['conversationDifficulty']}.",
+                f"    Style: {model.get('typingStyle', {}).get('signature', 'unknown')}.",
+                f"    Reply: {' '.join(model.get('replyStyle', [])[:2])}",
+            ])
+        lines.append("")
+    write_text_atomic(path, "\n".join(lines) + "\n")
+
+
+def synthesize_people(models_by_key):
+    people = []
+    for key, models in models_by_key.items():
+        if key.startswith("group::"):
+            continue
+        names = [model.get("identityName") or model["chatName"] for model in models]
+        people.append({
+            "canonicalPersonKey": key,
+            "displayName": names[0],
+            "aliases": sorted(set(names)),
+        })
+    return people
 
 
 def bullets(items):
@@ -229,6 +297,27 @@ def load_json(path, fallback):
     return json.loads(path.read_text(encoding="utf-8"))
 
 
+def write_json_atomic(path, data):
+    write_text_atomic(path, json.dumps(data, indent=2, ensure_ascii=False))
+
+
+def write_text_atomic(path, content):
+    temp = path.with_name(f"{path.name}.{time.time_ns()}.tmp")
+    temp.write_text(content, encoding="utf-8")
+    temp.replace(path)
+
+
+def load_overrides(sources):
+    merged = {}
+    for path in sorted(sources.glob("*/relationship_overrides.json")):
+        merged.update(load_json(path, {}))
+    return merged
+
+
+def profile_key(profile):
+    return f"{profile.get('sourceSystem') or 'Unknown'}::{profile.get('chatName') or 'Unknown Chat'}"
+
+
 def parse_args():
     parser = argparse.ArgumentParser()
     parser.add_argument("--vault", type=Path, required=True)

package/scripts/digital_brain_slack_export_import.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import tempfile
+import zipfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def main():
+    args = parse_args()
+    with unpack(args.input) as source:
+        import_export(args.vault.resolve(), source, args.days)
+
+
+def import_export(vault, source, days):
+    slack = vault / "08 Sources" / "Slack"
+    raw_dir = slack / "Raw"
+    chats_dir = slack / "ChatsByMonth"
+    state_dir = slack / ".sync-state"
+    for directory in (raw_dir, chats_dir, state_dir):
+        directory.mkdir(parents=True, exist_ok=True)
+
+    users = load_users(source / "users.json")
+    conversations = load_conversations(source)
+    seen_path = state_dir / "slack-seen-message-ids.json"
+    seen = load_seen(seen_path)
+    cutoff = datetime.now(timezone.utc).timestamp() - days * 24 * 60 * 60 if days else None
+    added = 0
+
+    for folder in sorted(path for path in source.iterdir() if path.is_dir()):
+        conversation = conversations.get(folder.name, {"name": folder.name, "is_group": True})
+        chat_name = conversation.get("name") or folder.name
+        is_group = conversation.get("is_group", True)
+        for file in sorted(folder.glob("*.json")):
+            for item in load_json(file, []):
+                if "ts" not in item or not item.get("text"):
+                    continue
+                timestamp = float(item["ts"])
+                if cutoff and timestamp < cutoff:
+                    continue
+                record = slack_record(item, users, chat_name, is_group, folder.name)
+                if record["id"] in seen:
+                    continue
+                append_jsonl(raw_dir, record)
+                append_markdown(chats_dir, record)
+                seen.add(record["id"])
+                added += 1
+
+    save_seen(seen_path, seen)
+    print(f"Imported {added} Slack messages.")
+
+
+def slack_record(item, users, chat_name, is_group, conversation_id):
+    user_id = item.get("user") or item.get("bot_id") or "unknown"
+    author = users.get(user_id, user_id)
+    timestamp = datetime.fromtimestamp(float(item["ts"]), tz=timezone.utc).isoformat()
+    return {
+        "id": f"slack-{conversation_id}-{item['ts']}",
+        "source": "Slack export",
+        "sourceSystem": "Slack",
+        "timestamp": timestamp,
+        "chatName": chat_name,
+        "chatId": conversation_id,
+        "isGroup": is_group,
+        "fromMe": False,
+        "author": author,
+        "authorId": user_id,
+        "body": item.get("text") or "",
+    }
+
+
+def load_users(path):
+    users = {}
+    for item in load_json(path, []):
+        user_id = item.get("id")
+        if not user_id:
+            continue
+        profile = item.get("profile") or {}
+        users[user_id] = profile.get("real_name") or profile.get("display_name") or item.get("name") or user_id
+    return users
+
+
+def load_conversations(source):
+    conversations = {}
+    for filename in ("channels.json", "groups.json", "dms.json", "mpims.json"):
+        for item in load_json(source / filename, []):
+            conversation_id = item.get("id") or item.get("name")
+            if not conversation_id:
+                continue
+            conversations[conversation_id] = {
+                "name": item.get("name") or item.get("name_normalized") or conversation_id,
+                "is_group": not filename == "dms.json",
+            }
+    return conversations
+
+
+def append_jsonl(raw_dir, record):
+    with (raw_dir / f"{record['timestamp'][:10]}.jsonl").open("a", encoding="utf-8") as f:
+        f.write(json.dumps(record, ensure_ascii=False) + "\n")
+
+
+def append_markdown(chats_dir, record):
+    directory = chats_dir / record["timestamp"][:7]
+    directory.mkdir(parents=True, exist_ok=True)
+    file_path = directory / f"{safe_filename(record['chatName'])}.md"
+    if not file_path.exists():
+        file_path.write_text(f"# {record['chatName']}\n\nSynced from Slack export.\n\n", encoding="utf-8")
+    body = " ".join((record.get("body") or "").split())
+    with file_path.open("a", encoding="utf-8") as f:
+        f.write(f"- {record['timestamp']} | {record['author']}: {body}\n")
+
+
+def load_json(path, fallback):
+    if not path.exists():
+        return fallback
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def load_seen(path):
+    if not path.exists():
+        return set()
+    try:
+        return set(json.loads(path.read_text(encoding="utf-8")))
+    except Exception:
+        return set()
+
+
+def save_seen(path, seen):
+    path.write_text(json.dumps(sorted(seen), indent=2), encoding="utf-8")
+
+
+def safe_filename(value):
+    cleaned = "".join("-" if char in '/:\\?%*"<>|' else char for char in value)
+    return (" ".join(cleaned.split()).strip() or "Unknown Chat")[:120]
+
+
+def unpack(input_path):
+    input_path = input_path.resolve()
+    if input_path.is_dir():
+        return NullContext(input_path)
+    temp = tempfile.TemporaryDirectory()
+    with zipfile.ZipFile(input_path) as archive:
+        archive.extractall(temp.name)
+    return TempContext(Path(temp.name), temp)
+
+
+class NullContext:
+    def __init__(self, path):
+        self.path = path
+
+    def __enter__(self):
+        return self.path
+
+    def __exit__(self, *_):
+        return False
+
+
+class TempContext:
+    def __init__(self, path, temp):
+        self.path = path
+        self.temp = temp
+
+    def __enter__(self):
+        return self.path
+
+    def __exit__(self, *_):
+        self.temp.cleanup()
+        return False
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--vault", type=Path, required=True)
+    parser.add_argument("--input", type=Path, required=True)
+    parser.add_argument("--days", type=int, default=365)
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    main()