digital-brain 0.1.0

package/examples/sample-vault/08 Sources/WhatsApp/Analysis/interpreted_relationship_models.json

@@ -0,0 +1,109 @@
+[
+  {
+    "chatName": "Mom",
+    "messageCount": 2,
+    "inbound": 1,
+    "outbound": 1,
+    "outboundShare": 0.5,
+    "firstSeen": "2026-01-01",
+    "lastSeen": "2026-01-01",
+    "isGroup": false,
+    "sentimentScore": 0.159,
+    "warmthScore": 0.5,
+    "frictionScore": 0.0,
+    "operationalScore": 1.5,
+    "questionCount": 0,
+    "relationshipGuess": "warm personal relationship",
+    "tags": [
+      "direct-chat",
+      "light",
+      "warm",
+      "logistics-heavy"
+    ],
+    "role": "mother",
+    "roleConfidence": "high",
+    "roleReason": "manual override",
+    "closeness": "medium",
+    "conversationDifficulty": "low",
+    "reciprocity": "balanced",
+    "howToContinue": [
+      "Use warmer language than a work chat.",
+      "Do not make the interaction purely transactional.",
+      "Track open loops, plans, dates, and commitments."
+    ],
+    "boundaries": [
+      "Do not expose private summaries unless asked."
+    ]
+  },
+  {
+    "chatName": "Project Team",
+    "messageCount": 2,
+    "inbound": 1,
+    "outbound": 1,
+    "outboundShare": 0.5,
+    "firstSeen": "2026-01-01",
+    "lastSeen": "2026-01-01",
+    "isGroup": true,
+    "sentimentScore": 0,
+    "warmthScore": 0.0,
+    "frictionScore": 0.0,
+    "operationalScore": 3.0,
+    "questionCount": 1,
+    "relationshipGuess": "group, likely social or mixed context",
+    "tags": [
+      "group-chat",
+      "light",
+      "logistics-heavy",
+      "question-heavy"
+    ],
+    "role": "work collaborator",
+    "roleConfidence": "medium",
+    "roleReason": "matched chat name",
+    "closeness": "low/unclear",
+    "conversationDifficulty": "practical/low-emotional",
+    "reciprocity": "balanced",
+    "howToContinue": [
+      "Lead with context, next steps, and clear asks.",
+      "Keep emotional interpretation light.",
+      "Track open loops, plans, dates, and commitments."
+    ],
+    "boundaries": [
+      "Do not expose private summaries unless asked."
+    ]
+  },
+  {
+    "chatName": "Close Friend",
+    "messageCount": 2,
+    "inbound": 1,
+    "outbound": 1,
+    "outboundShare": 0.5,
+    "firstSeen": "2026-01-01",
+    "lastSeen": "2026-01-01",
+    "isGroup": false,
+    "sentimentScore": 0.159,
+    "warmthScore": 1.0,
+    "frictionScore": 0.0,
+    "operationalScore": 0.5,
+    "questionCount": 0,
+    "relationshipGuess": "warm personal relationship",
+    "tags": [
+      "direct-chat",
+      "light",
+      "warm",
+      "logistics-heavy"
+    ],
+    "role": "operational contact",
+    "roleConfidence": "low",
+    "roleReason": "logistics-heavy communication",
+    "closeness": "medium",
+    "conversationDifficulty": "low",
+    "reciprocity": "balanced",
+    "howToContinue": [
+      "Keep tone neutral until the user labels this relationship.",
+      "Track open loops, plans, dates, and commitments."
+    ],
+    "boundaries": [
+      "Do not expose private summaries unless asked."
+    ]
+  }
+]

package/examples/sample-vault/08 Sources/WhatsApp/Analysis/relationship_profiles.json

@@ -0,0 +1,68 @@
+[
+  {
+    "chatName": "Mom",
+    "messageCount": 2,
+    "inbound": 1,
+    "outbound": 1,
+    "outboundShare": 0.5,
+    "firstSeen": "2026-01-01",
+    "lastSeen": "2026-01-01",
+    "isGroup": false,
+    "sentimentScore": 0.159,
+    "warmthScore": 0.5,
+    "frictionScore": 0.0,
+    "operationalScore": 1.5,
+    "questionCount": 0,
+    "relationshipGuess": "warm personal relationship",
+    "tags": [
+      "direct-chat",
+      "light",
+      "warm",
+      "logistics-heavy"
+    ]
+  },
+  {
+    "chatName": "Project Team",
+    "messageCount": 2,
+    "inbound": 1,
+    "outbound": 1,
+    "outboundShare": 0.5,
+    "firstSeen": "2026-01-01",
+    "lastSeen": "2026-01-01",
+    "isGroup": true,
+    "sentimentScore": 0,
+    "warmthScore": 0.0,
+    "frictionScore": 0.0,
+    "operationalScore": 3.0,
+    "questionCount": 1,
+    "relationshipGuess": "group, likely social or mixed context",
+    "tags": [
+      "group-chat",
+      "light",
+      "logistics-heavy",
+      "question-heavy"
+    ]
+  },
+  {
+    "chatName": "Close Friend",
+    "messageCount": 2,
+    "inbound": 1,
+    "outbound": 1,
+    "outboundShare": 0.5,
+    "firstSeen": "2026-01-01",
+    "lastSeen": "2026-01-01",
+    "isGroup": false,
+    "sentimentScore": 0.159,
+    "warmthScore": 1.0,
+    "frictionScore": 0.0,
+    "operationalScore": 0.5,
+    "questionCount": 0,
+    "relationshipGuess": "warm personal relationship",
+    "tags": [
+      "direct-chat",
+      "light",
+      "warm",
+      "logistics-heavy"
+    ]
+  }
+]

package/examples/sample-vault/08 Sources/WhatsApp/Raw/2026-01-01.jsonl

@@ -0,0 +1,6 @@
+{"id":"sample-1","source":"sample","timestamp":"2026-01-01T10:00:00+00:00","chatName":"Mom","isGroup":false,"fromMe":false,"author":"Mom","body":"Good morning, call me when you wake up"}
+{"id":"sample-2","source":"sample","timestamp":"2026-01-01T10:05:00+00:00","chatName":"Mom","isGroup":false,"fromMe":true,"author":"Me","body":"Morning, will call in 10"}
+{"id":"sample-3","source":"sample","timestamp":"2026-01-01T11:00:00+00:00","chatName":"Project Team","isGroup":true,"fromMe":false,"author":"Alex","body":"Can you send the deck before the client meeting?"}
+{"id":"sample-4","source":"sample","timestamp":"2026-01-01T11:03:00+00:00","chatName":"Project Team","isGroup":true,"fromMe":true,"author":"Me","body":"Yes, sending the updated deck now"}
+{"id":"sample-5","source":"sample","timestamp":"2026-01-01T20:00:00+00:00","chatName":"Close Friend","isGroup":false,"fromMe":false,"author":"Friend","body":"That was fun haha, let's plan another trip"}
+{"id":"sample-6","source":"sample","timestamp":"2026-01-01T20:02:00+00:00","chatName":"Close Friend","isGroup":false,"fromMe":true,"author":"Me","body":"Yes absolutely, that was great"}

package/examples/sample-vault/08 Sources/WhatsApp/relationship_overrides.json

@@ -0,0 +1,7 @@
+{
+  "Mom": {
+    "role": "mother",
+    "confidence": "high",
+    "notes": "Sample override."
+  }
+}

package/lib/fs.js

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export function packageRoot(metaUrl) {
+  return path.resolve(path.dirname(fileURLToPath(metaUrl)), "..");
+}
+
+export function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+export function copyDir(source, target) {
+  ensureDir(target);
+  for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
+    const from = path.join(source, entry.name);
+    const to = path.join(target, entry.name);
+    if (entry.isDirectory()) copyDir(from, to);
+    else if (!fs.existsSync(to)) fs.copyFileSync(from, to);
+  }
+}
+
+export function resolveVault(cwd) {
+  let current = path.resolve(cwd);
+  while (true) {
+    if (fs.existsSync(path.join(current, "digital-brain.config.json"))) return current;
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return path.resolve(cwd);
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "digital-brain",
+  "version": "0.1.0",
+  "description": "Your private digital imprint for AI assistants.",
+  "type": "module",
+  "bin": {
+    "digital-brain": "bin/digital-brain.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "scripts/*.py",
+    "templates",
+    "whatsapp-web",
+    "examples",
+    "docs",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test:sample": "node ./bin/digital-brain.js extract --vault ./examples/sample-vault --days 365 --min-messages 1 && node ./bin/digital-brain.js interpret --vault ./examples/sample-vault --days 365",
+    "check": "node --check bin/digital-brain.js && node --check lib/*.js && node --check whatsapp-web/*.mjs && python3 -m py_compile scripts/*.py",
+    "start": "node ./bin/digital-brain.js"
+  },
+  "keywords": [
+    "ai",
+    "memory",
+    "personal-ai",
+    "obsidian",
+    "whatsapp",
+    "local-first",
+    "context"
+  ],
+  "author": "Rushill Shah",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "qrcode-terminal": "^0.12.0",
+    "whatsapp-web.js": "^1.34.7"
+  }
+}

package/scripts/digital_brain_relationship_extractor.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import math
+import re
+from collections import Counter, defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+
+POSITIVE = {"love", "thanks", "thank", "amazing", "great", "good", "nice", "perfect", "proud", "happy", "haha", "lol", "miss", "excited", "best", "awesome", "appreciate", "congrats"}
+NEGATIVE = {"angry", "annoyed", "upset", "sad", "bad", "hate", "sorry", "fight", "problem", "issue", "wrong", "stress", "fuck", "shit", "worried", "pain", "hurt", "confused"}
+LOGISTICS = {"when", "where", "time", "today", "tomorrow", "meeting", "call", "send", "sent", "come", "coming", "reach", "book", "plan", "schedule"}
+WORK = {"pr", "repo", "client", "customer", "meeting", "deck", "code", "ship", "product", "founder", "startup", "work", "office", "investor", "sales", "demo", "launch"}
+
+
+def main():
+    args = parse_args()
+    vault = args.vault.resolve()
+    whatsapp = vault / "08 Sources" / "WhatsApp"
+    output_dir = whatsapp / "Analysis"
+    output_dir.mkdir(parents=True, exist_ok=True)
+    messages = load_messages(whatsapp / "Raw", 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")
+    write_markdown(output_dir / "Relationship Map.md", profiles, args.days)
+    print(f"Analyzed {len(messages)} messages.")
+    print(f"Wrote {len(profiles)} relationship profiles.")
+
+
+def load_messages(raw_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")):
+        with path.open("r", encoding="utf-8") as f:
+            for line in f:
+                if not line.strip():
+                    continue
+                record = json.loads(line)
+                dt = datetime.fromisoformat(record["timestamp"].replace("Z", "+00:00"))
+                if cutoff and dt.timestamp() < cutoff:
+                    continue
+                record["_dt"] = dt
+                messages.append(record)
+    return messages
+
+
+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]
+    profiles.sort(key=lambda p: (p["messageCount"], p["lastSeen"]), reverse=True)
+    return profiles
+
+
+def profile_chat(chat_name, messages):
+    count = len(messages)
+    outbound = sum(1 for m in messages if m.get("fromMe"))
+    inbound = count - outbound
+    dates = [m["_dt"] for m in messages]
+    text = "\n".join(m.get("body") or "" for m in messages)
+    words = Counter(re.findall(r"[a-zA-Z']+", text.lower()))
+    positive = score(words, POSITIVE)
+    negative = score(words, NEGATIVE)
+    logistics = score(words, LOGISTICS)
+    work = score(words, WORK)
+    warmth = (positive + text.count("!") * 0.25) / max(count, 1)
+    friction = negative / max(count, 1)
+    operational = (logistics + work) / max(count, 1)
+    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)
+    return {
+        "chatName": chat_name,
+        "messageCount": count,
+        "inbound": inbound,
+        "outbound": outbound,
+        "outboundShare": round(outbound / count, 2),
+        "firstSeen": min(dates).date().isoformat(),
+        "lastSeen": max(dates).date().isoformat(),
+        "isGroup": any(m.get("isGroup") for m in messages),
+        "sentimentScore": round(sentiment, 3),
+        "warmthScore": round(warmth, 3),
+        "frictionScore": round(friction, 3),
+        "operationalScore": round(operational, 3),
+        "questionCount": text.count("?"),
+        "relationshipGuess": guess,
+        "tags": tags,
+    }
+
+
+def infer_tags(group, count, inbound, outbound, warmth, friction, operational, work, logistics, questions):
+    tags = ["group-chat" if group else "direct-chat"]
+    tags.append("high-volume" if count >= 500 else "active" if count >= 100 else "light")
+    if warmth > 0.08:
+        tags.append("warm")
+    if friction > 0.035:
+        tags.append("friction-present")
+    if operational > 0.12:
+        tags.append("logistics-heavy")
+    if work > logistics and work > 5:
+        tags.append("work-signal")
+    if questions / max(count, 1) > 0.25:
+        tags.append("question-heavy")
+    if outbound / max(count, 1) > 0.7:
+        tags.append("user-driving")
+    if inbound / max(count, 1) > 0.7:
+        tags.append("other-driving")
+    return tags
+
+
+def infer_relationship(tags, count, warmth, friction, operational, work, balance):
+    if "group-chat" in tags:
+        return "group, likely work/project or operational" if work > 10 else "group, likely social or mixed context"
+    if count >= 500 and warmth > 0.06:
+        return "close/high-context personal relationship"
+    if count >= 200 and operational > 0.1:
+        return "active operational relationship"
+    if work > 10 and operational > 0.08:
+        return "work or project relationship"
+    if warmth > 0.08:
+        return "warm personal relationship"
+    if friction > 0.05:
+        return "relationship with friction or emotionally charged moments"
+    if balance < 0.25 or balance > 0.75:
+        return "asymmetric communication pattern"
+    return "general relationship, needs human labeling"
+
+
+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"- Guess: {profile['relationshipGuess']}",
+            f"- Messages: {profile['messageCount']} ({profile['inbound']} inbound, {profile['outbound']} outbound)",
+            f"- Dates: {profile['firstSeen']} to {profile['lastSeen']}",
+            f"- Scores: sentiment {profile['sentimentScore']}, warmth {profile['warmthScore']}, friction {profile['frictionScore']}, operational {profile['operationalScore']}",
+            f"- Tags: {', '.join(profile['tags'])}",
+            "",
+        ])
+    path.write_text("\n".join(lines), encoding="utf-8")
+
+
+def score(words, lexicon):
+    return sum(words[word] for word in lexicon)
+
+
+def normalized_sentiment(positive, negative, count):
+    if positive + negative == 0:
+        return 0
+    return ((positive - negative) / (positive + negative)) * min(1, math.log10(count + 1) / 3)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--vault", type=Path, required=True)
+    parser.add_argument("--days", type=int, default=30)
+    parser.add_argument("--min-messages", type=int, default=20)
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    main()

package/scripts/digital_brain_relationship_interpreter.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+import argparse
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+ROLE_KEYWORDS = [
+    ("mother", ["mom", "mum", "mummy", "maa", "mother"]),
+    ("father", ["dad", "papa", "father"]),
+    ("sibling", ["brother", "sister", "bhai", "behen", "sis"]),
+    ("family", ["family", "cousin", "uncle", "aunt", "mama", "maasi"]),
+    ("romantic partner", ["girlfriend", "boyfriend", "babe", "baby"]),
+    ("work collaborator", ["intern", "client", "work", "team", "project", "founder"]),
+    ("friend", ["boys", "friends", "trip", "dance"]),
+    ("medical/support", ["doctor", "dr ", "hospital"]),
+]
+
+
+def main():
+    args = parse_args()
+    vault = args.vault.resolve()
+    whatsapp = vault / "08 Sources" / "WhatsApp"
+    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"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    people_dir.mkdir(parents=True, exist_ok=True)
+
+    models = []
+    for profile in profiles:
+        model = build_model(profile, overrides.get(profile["chatName"], {}))
+        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")
+        models.append(model)
+
+    (whatsapp / "Analysis" / "interpreted_relationship_models.json").write_text(json.dumps(models, indent=2, ensure_ascii=False), encoding="utf-8")
+    write_index(vault / "06 AI Memory" / "Interpreted Relationship Memory.md", models)
+    print(f"Wrote interpreted notes: {len(models)}")
+
+
+def build_model(profile, override):
+    role, confidence, reason = infer_role(profile, override)
+    return {
+        **profile,
+        "role": role,
+        "roleConfidence": confidence,
+        "roleReason": reason,
+        "closeness": infer_closeness(profile),
+        "conversationDifficulty": infer_difficulty(profile),
+        "reciprocity": infer_reciprocity(profile),
+        "howToContinue": infer_continuity(profile, role),
+        "boundaries": infer_boundaries(role, infer_difficulty(profile)),
+    }
+
+
+def infer_role(profile, override):
+    if override.get("role"):
+        return override["role"], override.get("confidence", "high"), "manual override"
+    name = profile["chatName"].lower()
+    for role, keywords in ROLE_KEYWORDS:
+        if any(keyword in name for keyword in keywords):
+            return role, "high" if role in {"mother", "father"} else "medium", "matched chat name"
+    if profile["isGroup"]:
+        return "work/project group" if "work-signal" in profile["tags"] else "group", "medium", "group chat"
+    if "work-signal" in profile["tags"]:
+        return "work collaborator", "medium", "work/project signal"
+    if "warm" in profile["tags"] and profile["messageCount"] > 300:
+        return "close personal contact", "low", "high volume and warmth, no explicit label"
+    if "logistics-heavy" in profile["tags"]:
+        return "operational contact", "low", "logistics-heavy communication"
+    return "unlabeled contact", "low", "no reliable role evidence"
+
+
+def infer_closeness(profile):
+    if profile["messageCount"] >= 500 and profile["warmthScore"] > 0.06:
+        return "high"
+    if profile["messageCount"] >= 200:
+        return "medium-high"
+    if profile["messageCount"] >= 75 or profile["warmthScore"] > 0.08:
+        return "medium"
+    return "low/unclear"
+
+
+def infer_difficulty(profile):
+    if profile["frictionScore"] > 0.06:
+        return "high"
+    if profile["frictionScore"] > 0.03 or "friction-present" in profile["tags"]:
+        return "medium"
+    if profile["operationalScore"] > 0.15 and profile["warmthScore"] < 0.03:
+        return "practical/low-emotional"
+    return "low"
+
+
+def infer_reciprocity(profile):
+    share = profile["outboundShare"]
+    if share > 0.68:
+        return "user drives most of the conversation"
+    if share < 0.32:
+        return "other side drives most of the conversation"
+    return "balanced"
+
+
+def infer_continuity(profile, role):
+    guidance = []
+    if role in {"mother", "father", "family"}:
+        guidance += ["Use warmer language than a work chat.", "Do not make the interaction purely transactional."]
+    elif "work" in role:
+        guidance += ["Lead with context, next steps, and clear asks.", "Keep emotional interpretation light."]
+    elif role == "romantic partner":
+        guidance += ["Use extra care with tone.", "Prefer warmth and specificity over generic advice."]
+    else:
+        guidance.append("Keep tone neutral until the user labels this relationship.")
+    if "logistics-heavy" in profile["tags"]:
+        guidance.append("Track open loops, plans, dates, and commitments.")
+    return guidance
+
+
+def infer_boundaries(role, difficulty):
+    boundaries = ["Do not expose private summaries unless asked."]
+    if role == "unlabeled contact":
+        boundaries.append("Do not invent a relationship category.")
+    if difficulty in {"medium", "high"}:
+        boundaries.append("Do not assume friction means the relationship is bad.")
+    return boundaries
+
+
+def render_note(model):
+    return f"""# {model['chatName']}
+
+Generated: {datetime.now(timezone.utc).isoformat()}
+Role: {model['role']}
+Role confidence: {model['roleConfidence']}
+Closeness: {model['closeness']}
+Conversation difficulty: {model['conversationDifficulty']}
+
+These are private working notes. Edit them where wrong.
+
+## Role / Relationship Label
+- {model['role']} ({model['roleConfidence']} confidence).
+- Reason: {model['roleReason']}.
+
+## Closeness And Importance
+- Closeness: {model['closeness']}.
+- Reciprocity: {model['reciprocity']}.
+- Conversation difficulty: {model['conversationDifficulty']}.
+
+## Communication Pattern
+- Messages: {model['messageCount']} ({model['inbound']} inbound, {model['outbound']} outbound).
+- Tags: {', '.join(model['tags'])}.
+
+## How To Continue This Relationship
+{bullets(model['howToContinue'])}
+
+## What Not To Assume
+{bullets(model['boundaries'])}
+"""
+
+
+def write_index(path, models):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    lines = ["# Interpreted Relationship Memory", "", "Generated working notes. Treat as editable, not truth.", ""]
+    for model in models:
+        lines.append(f"- [[{safe_filename(model['chatName'])}]]: {model['role']} ({model['roleConfidence']}), closeness {model['closeness']}, difficulty {model['conversationDifficulty']}")
+    path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def bullets(items):
+    return "\n".join(f"- {item}" for item in items)
+
+
+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 load_json(path, fallback):
+    if not path.exists():
+        return fallback
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--vault", type=Path, required=True)
+    parser.add_argument("--days", type=int, default=30)
+    parser.add_argument("--max-messages", type=int, default=120)
+    parser.add_argument("--provider", choices=["heuristic"], default="heuristic")
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    main()