cobrain 0.1.0__tar.gz

cobrain-0.1.0/LICENSE

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

cobrain-0.1.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: cobrain
+Version: 0.1.0
+Summary: Cobrain CLI helps AI agents gather, organize and visualize owner's knowledge locally on device. Use it to back up and organize your knowledge, help AI agents read your mind, or map and track your learning progress.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: build>=1.5.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: twine>=6.2.0
+Requires-Dist: xdk>=0.9.0
+Dynamic: license-file
+
+# Cobrain
+
+## Overview
+
+Cobrain CLI helps AI agents gather, organize and visualize owner's knowledge in a local vault: files (topics, sources) + graph (structured metadata).
+
+- Vault locally stores and organizes knowledge, tracks learning, and creates persistant shared context between owner/user/agent for collaboration and decisions
+- Agent manages vault autonomously
+- Cobrain CLI performs deterministic tasks and helps AI agent perform vault-related tasks reliably and token-efficiently
+
+## Installation & Setup
+
+Install agent skill `skills/cobrain-vault`. Agent does the rest.
+
+Alternative:
+```bash
+pip install cobrain
+```
+
+## Vault
+
+```
+vault/
+├── vault.html            # Visual graph with search/filters for human user
+├── topics/               # Topic files (.md), source of truth for CLI
+├── sources/
+│   ├── chats/            # ChatGPT conversations (.md)
+│   ├── x/                # X conversations (.yaml)
+│   └── ...               # Add more for other sources
+└── .cobrain/             # App internals, read but never edit directly
+    ├── vault.yaml        # Derived graph of topics, with metadata
+    ├── categories.yaml   # Customizable topic category colors / titles
+    ├── backups/          # Rolling backups
+    ├── diffs/            # Diffs from backups
+    └── logs/             # Ingest logs
+        ├── chatgpt/
+        └── x/
+```
+
+`vault/sources/`: raw content ingested from external systems (ChatGPT, X, user-provided documents, your own chat with user), users never read this.
+`vault/topics/`: curated summaries users read, source of truth for everything.
+
+## CLI reference
+
+```bash
+brn version                        # show version
+brn vault --dir <path>             # initialize new/existing vault, write config
+brn sync [--warnings]              # build graph from files + show warnings
+brn show                           # build and open vault.html in browser
+brn vault [--ids <ids>] [--minimal | --full | --full+] [--flow | --block]  # get graph as YAML (select ids, topic metadata fields, YAML format)
+brn vault --ids <ids> --set field=value...   # update topic frontmatter + sync
+brn vault --from <id> [--depth N]  # subtree
+brn vault --from <id> --to <id2>   # shortest path (parent links only)
+brn sources [--warnings]           # view source stats + warnings
+brn sources --ingest chatgpt --paths <path...> [--since <dt>] [--until <dt>] [--titles <titles]>  # ingest ChatGPT conversations.json
+brn sources --ingest x --ids <post_ids>  # ingest X posts by ID/URL/xurl
+brn sources --ingest x --own [--count <N> | --new | --since-id <id> --until-id <id>]  # fetch own posts (default 10, count, all new until hit existing, or target range)
+brn sources --ingest x --own --authorization-code <code>  # first-time X auth
+brn sources --ingest x --likes [--count <N> | --new]  # ingest liked posts
+brn sources --ingest x --bookmarks [--count <N> | --new]  # ingest bookmarked posts
+brn backup                         # copy vault.yaml + categories.yaml (up to 20)
+```
+
+All `--ingest x` commands pull full conversation above the target post, and minimize API credits spent by always checking locally stored posts first.
+
+## Topics
+
+## Sources
+
+X and ChatGPT: integrated, agent ingests with CLI command.
+Other sources (webpage, file, chat): agent reads directly.
+
+### X
+
+- Built with XDK (official X SDK), with their affordable [pay-per-use pricing](https://docs.x.com/x-api/getting-started/pricing) and 24h retrieved post caching to save your credits.
+- Uses your own app's OAuth2.0 credentials.
+- Ingest your bookmarks, likes, posts and replies, or any post by id/url. Official endpoint filters supported as flags.
+- CLI automatically builds coherent conversations (one per file) from target post up to original (root) post. Locally stored posts are re-used whenever possible to save your credits. New posts from an existing conversation merge into the same file seamlessly.
+- Output: `vault/x/<conversation_author>_<conversation_id>.yaml`.
+
+### ChatGPT
+
+- Request data export from your ChatGPT app and run ingest command on `conversations.json`.
+- Filter by dates and title supported as flags.
+- Output: `vault/chats/<title>.md`.

cobrain-0.1.0/README.md

@@ -0,0 +1,85 @@
+# Cobrain
+
+## Overview
+
+Cobrain CLI helps AI agents gather, organize and visualize owner's knowledge in a local vault: files (topics, sources) + graph (structured metadata).
+
+- Vault locally stores and organizes knowledge, tracks learning, and creates persistant shared context between owner/user/agent for collaboration and decisions
+- Agent manages vault autonomously
+- Cobrain CLI performs deterministic tasks and helps AI agent perform vault-related tasks reliably and token-efficiently
+
+## Installation & Setup
+
+Install agent skill `skills/cobrain-vault`. Agent does the rest.
+
+Alternative:
+```bash
+pip install cobrain
+```
+
+## Vault
+
+```
+vault/
+├── vault.html            # Visual graph with search/filters for human user
+├── topics/               # Topic files (.md), source of truth for CLI
+├── sources/
+│   ├── chats/            # ChatGPT conversations (.md)
+│   ├── x/                # X conversations (.yaml)
+│   └── ...               # Add more for other sources
+└── .cobrain/             # App internals, read but never edit directly
+    ├── vault.yaml        # Derived graph of topics, with metadata
+    ├── categories.yaml   # Customizable topic category colors / titles
+    ├── backups/          # Rolling backups
+    ├── diffs/            # Diffs from backups
+    └── logs/             # Ingest logs
+        ├── chatgpt/
+        └── x/
+```
+
+`vault/sources/`: raw content ingested from external systems (ChatGPT, X, user-provided documents, your own chat with user), users never read this.
+`vault/topics/`: curated summaries users read, source of truth for everything.
+
+## CLI reference
+
+```bash
+brn version                        # show version
+brn vault --dir <path>             # initialize new/existing vault, write config
+brn sync [--warnings]              # build graph from files + show warnings
+brn show                           # build and open vault.html in browser
+brn vault [--ids <ids>] [--minimal | --full | --full+] [--flow | --block]  # get graph as YAML (select ids, topic metadata fields, YAML format)
+brn vault --ids <ids> --set field=value...   # update topic frontmatter + sync
+brn vault --from <id> [--depth N]  # subtree
+brn vault --from <id> --to <id2>   # shortest path (parent links only)
+brn sources [--warnings]           # view source stats + warnings
+brn sources --ingest chatgpt --paths <path...> [--since <dt>] [--until <dt>] [--titles <titles]>  # ingest ChatGPT conversations.json
+brn sources --ingest x --ids <post_ids>  # ingest X posts by ID/URL/xurl
+brn sources --ingest x --own [--count <N> | --new | --since-id <id> --until-id <id>]  # fetch own posts (default 10, count, all new until hit existing, or target range)
+brn sources --ingest x --own --authorization-code <code>  # first-time X auth
+brn sources --ingest x --likes [--count <N> | --new]  # ingest liked posts
+brn sources --ingest x --bookmarks [--count <N> | --new]  # ingest bookmarked posts
+brn backup                         # copy vault.yaml + categories.yaml (up to 20)
+```
+
+All `--ingest x` commands pull full conversation above the target post, and minimize API credits spent by always checking locally stored posts first.
+
+## Topics
+
+## Sources
+
+X and ChatGPT: integrated, agent ingests with CLI command.
+Other sources (webpage, file, chat): agent reads directly.
+
+### X
+
+- Built with XDK (official X SDK), with their affordable [pay-per-use pricing](https://docs.x.com/x-api/getting-started/pricing) and 24h retrieved post caching to save your credits.
+- Uses your own app's OAuth2.0 credentials.
+- Ingest your bookmarks, likes, posts and replies, or any post by id/url. Official endpoint filters supported as flags.
+- CLI automatically builds coherent conversations (one per file) from target post up to original (root) post. Locally stored posts are re-used whenever possible to save your credits. New posts from an existing conversation merge into the same file seamlessly.
+- Output: `vault/x/<conversation_author>_<conversation_id>.yaml`.
+
+### ChatGPT
+
+- Request data export from your ChatGPT app and run ingest command on `conversations.json`.
+- Filter by dates and title supported as flags.
+- Output: `vault/chats/<title>.md`.

cobrain-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "cobrain"
+version = "0.1.0"
+description = "Cobrain CLI helps AI agents gather, organize and visualize owner's knowledge locally on device. Use it to back up and organize your knowledge, help AI agents read your mind, or map and track your learning progress."
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "build>=1.5.0",
+    "pyyaml>=6.0",
+    "twine>=6.2.0",
+    "xdk>=0.9.0",
+]
+
+[project.scripts]
+cobrain = "cobrain.cli:main"
+brn = "cobrain.cli:main"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.ruff]
+target-version = "py311"
+
+[tool.pyright]
+pythonVersion = "3.11"
+
+[tool.deptry.per_rule_ignores]
+DEP003 = ["cobrain"]

cobrain-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cobrain-0.1.0/src/cobrain/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

cobrain-0.1.0/src/cobrain/cli/__init__.py

@@ -0,0 +1,167 @@
+import argparse
+import signal
+import sys
+
+from cobrain import __version__
+
+from .vault import cmd_backup, cmd_vault
+from .show import cmd_show
+from .sources import cmd_sources
+from .sync import cmd_sync
+
+
+def cmd_version(args: argparse.Namespace) -> None:
+    print(__version__)
+
+
+def main() -> None:
+    def _signal_handler(signum, frame):
+        print("\nInterrupted", file=sys.stderr)
+        sys.exit(130)
+
+    signal.signal(signal.SIGINT, _signal_handler)
+    signal.signal(signal.SIGTERM, _signal_handler)
+
+    prog = "brn" if "brn" in sys.argv[0] else "cobrain"
+    parser = argparse.ArgumentParser(
+        prog=prog,
+        description="Cobrain CLI helps AI agents gather, organize and visualize owner's knowledge locally on device. Use it to back up and organize your knowledge, help AI agents read your mind, or map and track your learning progress.",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    version_parser = subparsers.add_parser("version", help="Show version")
+    version_parser.set_defaults(func=cmd_version)
+
+    sync_parser = subparsers.add_parser("sync", help="Rebuild vault graph from files")
+    sync_parser.add_argument("--warnings", action="store_true", help="Show warnings")
+    sync_parser.set_defaults(func=cmd_sync)
+
+    vault_parser = subparsers.add_parser("vault", help="List or update topics")
+
+    vault_parser.add_argument(
+        "--dir",
+        dest="vault_dir",
+        help="Path to vault directory (initializes if not found)",
+    )
+
+    vault_parser.add_argument(
+        "--set", nargs="+", help="Set metadata for --ids (also syncs)"
+    )
+
+    traversal_group = vault_parser.add_argument_group("Discovery")
+    traversal_group.add_argument("--ids", help="Comma-separated topic IDs")
+    traversal_group.add_argument("--from", dest="from_topic", help="Starting topic")
+    traversal_group.add_argument("--depth", type=int, default=1, help="Traversal depth")
+    traversal_group.add_argument("--to", dest="to_topic", help="Target topic for path")
+
+    fields_group = vault_parser.add_argument_group("Fields")
+    fields_group.add_argument(
+        "--minimal",
+        action="store_true",
+        help="id, aliases, category, parent, related",
+    )
+    fields_group.add_argument(
+        "--full",
+        action="store_true",
+        help="minimal + title, created_at, updated_at",
+    )
+    fields_group.add_argument(
+        "--full+",
+        dest="full_plus",
+        action="store_true",
+        help="full + sources, word_count",
+    )
+
+    format_group = vault_parser.add_argument_group("Format")
+    format_group.add_argument(
+        "--flow",
+        action="store_true",
+        default=True,
+        help="Flow style (default, compact)",
+    )
+    format_group.add_argument(
+        "--block", action="store_true", help="Block style (human-readable)"
+    )
+
+    vault_parser.set_defaults(func=cmd_vault)
+
+    show_parser = subparsers.add_parser("show", help="Show vault in browser")
+    show_parser.set_defaults(func=cmd_show)
+
+    backup_parser = subparsers.add_parser("backup", help="Create rolling backup")
+    backup_parser.set_defaults(func=cmd_backup)
+
+    sources_parser = subparsers.add_parser("sources", help="Manage sources")
+
+    sources_parser.add_argument("--warnings", action="store_true", help="Show warnings")
+
+    chatgpt_group = sources_parser.add_argument_group("ChatGPT")
+    chatgpt_group.add_argument(
+        "--ingest",
+        choices=["chatgpt", "x"],
+        help="Ingest source (e.g., chatgpt, x)",
+    )
+    chatgpt_group.add_argument(
+        "--paths", nargs="+", help="Path(s) to conversations.json files"
+    )
+    chatgpt_group.add_argument(
+        "--since", dest="since_datetime", help="Start datetime (ISO 8601, inclusive)"
+    )
+    chatgpt_group.add_argument(
+        "--until", dest="until_datetime", help="End datetime (ISO 8601, inclusive)"
+    )
+    chatgpt_group.add_argument("--titles", help="Filter by titles (comma-separated)")
+
+    x_endpoints_group = sources_parser.add_argument_group("X endpoints")
+    x_endpoints_group.add_argument(
+        "--ids", help="Comma-separated post IDs, URLs, or xurls"
+    )
+    x_endpoints_group.add_argument(
+        "--own",
+        action="store_true",
+        help="Ingest own posts",
+    )
+    x_endpoints_group.add_argument(
+        "--likes", action="store_true", help="Ingest liked posts"
+    )
+    x_endpoints_group.add_argument(
+        "--bookmarks", action="store_true", help="Ingest bookmarked posts"
+    )
+
+    x_filters_group = sources_parser.add_argument_group("X filters")
+    x_filters_group.add_argument(
+        "--new",
+        action="store_true",
+        help="Loop until hitting existing posts",
+    )
+    x_filters_group.add_argument("--count", type=int, help="Total posts to fetch")
+    x_filters_group.add_argument(
+        "--since-id",
+        dest="since_id",
+        help="Oldest post ID (excl., --own only)",
+    )
+    x_filters_group.add_argument(
+        "--until-id",
+        dest="until_id",
+        help="Newest post ID (excl., --own only)",
+    )
+
+    x_auth_group = sources_parser.add_argument_group("X auth")
+    x_auth_group.add_argument(
+        "--authorization-code",
+        help="Authorization code from redirect URL",
+    )
+
+    sources_parser.set_defaults(func=cmd_sources)
+
+    args = parser.parse_args()
+
+    try:
+        args.func(args)
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

cobrain-0.1.0/src/cobrain/cli/ingest/__init__.py

@@ -0,0 +1,4 @@
+from cobrain.cli.ingest.chatgpt import cmd_ingest_chat
+from cobrain.cli.ingest.x.cmd import cmd_ingest_x
+
+__all__ = ["cmd_ingest_chat", "cmd_ingest_x"]

cobrain-0.1.0/src/cobrain/cli/ingest/chatgpt.py

@@ -0,0 +1,260 @@
+import argparse
+import re
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from cobrain.cli.utils import _parse_iso_datetime
+from cobrain.directories import (
+    get_chats_dir,
+    get_chats_logs_dir,
+    get_chat_log_path,
+)
+from cobrain.yaml_utils import write_yaml
+
+
+def cmd_ingest_chat(args: argparse.Namespace) -> None:
+    from cobrain.parsers.chatgpt import (
+        load_conversations,
+        filter_conversations,
+        parse_conversation_expand,
+        conversation_to_markdown,
+        compute_word_count,
+        get_last_message_id,
+        get_output_filename,
+        get_existing_file_for_conversation,
+        message_to_markdown,
+    )
+
+    paths = [Path(p).expanduser().resolve() for p in args.paths]
+    for path in paths:
+        if not path.exists():
+            print(f"ERROR: File not found: {path}", file=sys.stderr)
+            sys.exit(1)
+
+    from_time = None
+    till_time = None
+    titles = None
+
+    if args.since_datetime:
+        try:
+            from_time = _parse_iso_datetime(args.since_datetime).timestamp()
+        except ValueError:
+            print(
+                f"ERROR: Invalid --since datetime: {args.since_datetime}",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+
+    if args.until_datetime:
+        try:
+            till_time = _parse_iso_datetime(args.until_datetime).timestamp()
+        except ValueError:
+            print(
+                f"ERROR: Invalid --until datetime: {args.until_datetime}",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+
+    if args.titles:
+        titles = [t.strip() for t in args.titles.split(",") if t.strip()]
+
+    conversations = []
+    path_by_conv_id: dict[str, Path] = {}
+    for path in paths:
+        convs = load_conversations(path)
+        for c in convs:
+            conv_id = c.get("conversation_id") or c.get("id", "")
+            path_by_conv_id[conv_id] = path
+        conversations.extend(convs)
+
+    filtered = filter_conversations(conversations, from_time, till_time, titles)
+
+    chats_dir = get_chats_dir()
+    logs_dir = get_chats_logs_dir()
+    chats_dir.mkdir(parents=True, exist_ok=True)
+    logs_dir.mkdir(parents=True, exist_ok=True)
+
+    created_files = []
+    updated_files = []
+
+    log_entries = []
+    ingest_timestamp = datetime.utcnow().strftime("%Y%m%dT%H%M%S")
+
+    for conv_data in filtered:
+        conv_id = conv_data.get("conversation_id") or conv_data.get("id", "")
+
+        existing_file = get_existing_file_for_conversation(chats_dir, conv_id)
+        existing_last_msg_id = None
+        created_at = datetime.utcnow().isoformat()
+        existing_body = ""
+        existing_title = None
+
+        if existing_file:
+            existing_last_msg_id = _find_last_message_id_from_log(conv_id)
+            existing_content = existing_file.read_text(encoding="utf-8")
+            fm, existing_body = _split_frontmatter(existing_content)
+            created_at = _get_created_at_from_file(existing_file)
+            existing_title = fm.get("title") if fm else None
+
+        conv = parse_conversation_expand(conv_data, existing_last_msg_id)
+
+        if existing_file:
+            updated_files.append(str(existing_file))
+        else:
+            if conv.messages:
+                created_files.append(get_output_filename(conv))
+            else:
+                continue
+
+        output_filename = get_output_filename(conv)
+        output_path = chats_dir / output_filename
+
+        updated_at = datetime.utcnow().isoformat()
+        last_msg_id = (
+            get_last_message_id(conv) if conv.messages else (existing_last_msg_id or "")
+        )
+
+        if existing_file and existing_body.strip():
+            existing_word_count = _get_word_count_from_file(existing_file)
+            word_count = existing_word_count + compute_word_count(conv)
+
+            body_content = existing_body.rstrip("\n")
+            if conv.messages:
+                if body_content:
+                    body_content += "\n\n***\n\n"
+                for msg in conv.messages:
+                    body_content += message_to_markdown(msg)
+                    body_content += "\n\n***\n\n"
+
+            new_fm = _build_frontmatter(
+                conv_id=conv_id,
+                conv_title=existing_title or conv.title,
+                created_at=created_at,
+                updated_at=updated_at,
+                original_create_time=conv.create_time,
+                word_count=word_count,
+                urls=conv.sources,
+            )
+            content = new_fm + "\n" + body_content.rstrip()
+        else:
+            word_count = compute_word_count(conv)
+            title = existing_title or conv.title
+            content = conversation_to_markdown(
+                conv,
+                source_path=None,
+                word_count=word_count,
+                created_at=created_at,
+                updated_at=updated_at,
+                title=title,
+            )
+
+        output_path.write_text(content, encoding="utf-8")
+
+        log_entries.append(
+            {
+                "conversation_id": conv_id,
+                "output_file": str(output_path),
+                "last_message_id": last_msg_id,
+                "ingested_at": ingest_timestamp,
+                "filters": {
+                    "since": args.since_datetime,
+                    "until": args.until_datetime,
+                    "titles": args.titles,
+                },
+            }
+        )
+
+    if log_entries:
+        log_path = get_chat_log_path(ingest_timestamp)
+        write_yaml(log_path, log_entries)
+
+    total_created = len(created_files)
+    total_updated = len(updated_files)
+    print(f"Ingest complete: {total_created} created, {total_updated} updated")
+
+
+def _find_last_message_id_from_log(conv_id: str) -> str | None:
+    from cobrain.yaml_utils import read_yaml
+
+    logs_dir = get_chats_logs_dir()
+    if not logs_dir.exists():
+        return None
+    for log_file in logs_dir.glob("ingest_*.yaml"):
+        log_data = read_yaml(log_file)
+        if not log_data:
+            continue
+        if isinstance(log_data, list):
+            for entry in log_data:
+                if not isinstance(entry, dict):
+                    continue
+                if entry.get("conversation_id") == conv_id:
+                    return entry.get("last_message_id")
+    return None
+
+
+def _get_created_at_from_file(file_path: Path) -> str:
+    try:
+        content = file_path.read_text(encoding="utf-8")
+        pattern = re.compile(r"^created_at:\s*(.+)$", re.MULTILINE)
+        match = pattern.search(content)
+        if match:
+            return match.group(1).strip()
+    except Exception:
+        pass
+    return datetime.utcnow().isoformat()
+
+
+def _get_word_count_from_file(file_path: Path) -> int:
+    try:
+        content = file_path.read_text(encoding="utf-8")
+        pattern = re.compile(r"^word_count:\s*(\d+)$", re.MULTILINE)
+        match = pattern.search(content)
+        if match:
+            return int(match.group(1))
+    except Exception:
+        pass
+    return 0
+
+
+def _split_frontmatter(content: str) -> tuple[dict, str]:
+    fm_pattern = re.compile(r"^---\s*\n(.*?)\n---\s*\n", re.DOTALL)
+    match = fm_pattern.search(content)
+    if match:
+        fm_text = match.group(1)
+        body = content[match.end() :]
+        body = body.lstrip("\n")
+        fm = {}
+        for line in fm_text.split("\n"):
+            if ":" in line:
+                key, value = line.split(":", 1)
+                fm[key.strip()] = value.strip()
+        return fm, body
+    return {}, content
+
+
+def _build_frontmatter(
+    conv_id: str,
+    conv_title: str,
+    created_at: str,
+    updated_at: str,
+    original_create_time: float,
+    word_count: int,
+    urls: list[str],
+) -> str:
+    from cobrain.parsers.chatgpt import format_timestamp
+
+    lines = ["---"]
+    lines.append(f"id: {conv_id}")
+    lines.append(f"title: {conv_title}")
+    lines.append(f"created_at: {created_at}")
+    lines.append(f"updated_at: {updated_at}")
+    lines.append(
+        f"original_conversation_created_at: {format_timestamp(original_create_time)}"
+    )
+    lines.append(f"word_count: {word_count}")
+    lines.append("sources:")
+    for url in urls:
+        lines.append(f"  - {url}")
+    lines.append("---")
+    return "\n".join(lines)

cobrain-0.1.0/src/cobrain/cli/ingest/x/__init__.py

@@ -0,0 +1,8 @@
+from cobrain.cli.ingest.x.cmd import cmd_ingest_x
+from cobrain.cli.ingest.x.parse import _parse_post_args, _extract_post_id
+
+__all__ = [
+    "cmd_ingest_x",
+    "_parse_post_args",
+    "_extract_post_id",
+]