linkmark 1.0.0__tar.gz

linkmark-1.0.0/LICENSE

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

linkmark-1.0.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: linkmark
+Version: 1.0.0
+Summary: Annotated bookmark CLI — save links with mandatory context
+Author: linkmark contributors
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# linkmark — Annotated Bookmark CLI
+
+Save links with mandatory context — because bookmarks are useless without the "why."
+
+## Install
+
+```bash
+# Clone or copy the file
+cp linkmark.py /usr/local/bin/linkmark
+chmod +x /usr/local/bin/linkmark
+
+# Or run directly
+python3 linkmark.py
+```
+
+**Requirements:** Python 3.11+, zero external dependencies (stdlib only).
+
+## Quick start
+
+```bash
+# Add a bookmark (note is mandatory)
+linkmark add "https://docs.python.org/3/library/sqlite3.html" "Python sqlite3 docs — FTS5 reference" --tag python --tag docs
+
+# List recent bookmarks
+linkmark list
+
+# Search
+linkmark search "python"
+
+# Export
+linkmark export --format markdown > bookmarks.md
+linkmark export --format json > bookmarks.json
+
+# Stats
+linkmark stats
+
+# List tags
+linkmark tags
+
+# Delete
+linkmark delete 1
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `add <url> <note> [--tag TAG ...]` | Save a bookmark with mandatory annotation |
+| `list [--page N] [--limit N]` | List recent bookmarks, newest first |
+| `search <query> [--limit N]` | Full-text search (FTS5, falls back to LIKE) |
+| `export [--format markdown\|json]` | Export all bookmarks |
+| `stats` | Show total, this week, top tags |
+| `delete <id>` | Remove a bookmark by ID |
+| `tags` | List all tags with counts |
+
+## Storage
+
+- SQLite database at `~/.local/share/linkmark/bookmarks.db`
+- FTS5 virtual table for full-text search (auto-created if available)
+- Tags stored in normalized many-to-many tables

linkmark-1.0.0/README.md

@@ -0,0 +1,60 @@
+# linkmark — Annotated Bookmark CLI
+
+Save links with mandatory context — because bookmarks are useless without the "why."
+
+## Install
+
+```bash
+# Clone or copy the file
+cp linkmark.py /usr/local/bin/linkmark
+chmod +x /usr/local/bin/linkmark
+
+# Or run directly
+python3 linkmark.py
+```
+
+**Requirements:** Python 3.11+, zero external dependencies (stdlib only).
+
+## Quick start
+
+```bash
+# Add a bookmark (note is mandatory)
+linkmark add "https://docs.python.org/3/library/sqlite3.html" "Python sqlite3 docs — FTS5 reference" --tag python --tag docs
+
+# List recent bookmarks
+linkmark list
+
+# Search
+linkmark search "python"
+
+# Export
+linkmark export --format markdown > bookmarks.md
+linkmark export --format json > bookmarks.json
+
+# Stats
+linkmark stats
+
+# List tags
+linkmark tags
+
+# Delete
+linkmark delete 1
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `add <url> <note> [--tag TAG ...]` | Save a bookmark with mandatory annotation |
+| `list [--page N] [--limit N]` | List recent bookmarks, newest first |
+| `search <query> [--limit N]` | Full-text search (FTS5, falls back to LIKE) |
+| `export [--format markdown\|json]` | Export all bookmarks |
+| `stats` | Show total, this week, top tags |
+| `delete <id>` | Remove a bookmark by ID |
+| `tags` | List all tags with counts |
+
+## Storage
+
+- SQLite database at `~/.local/share/linkmark/bookmarks.db`
+- FTS5 virtual table for full-text search (auto-created if available)
+- Tags stored in normalized many-to-many tables

linkmark-1.0.0/linkmark.egg-info/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: linkmark
+Version: 1.0.0
+Summary: Annotated bookmark CLI — save links with mandatory context
+Author: linkmark contributors
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# linkmark — Annotated Bookmark CLI
+
+Save links with mandatory context — because bookmarks are useless without the "why."
+
+## Install
+
+```bash
+# Clone or copy the file
+cp linkmark.py /usr/local/bin/linkmark
+chmod +x /usr/local/bin/linkmark
+
+# Or run directly
+python3 linkmark.py
+```
+
+**Requirements:** Python 3.11+, zero external dependencies (stdlib only).
+
+## Quick start
+
+```bash
+# Add a bookmark (note is mandatory)
+linkmark add "https://docs.python.org/3/library/sqlite3.html" "Python sqlite3 docs — FTS5 reference" --tag python --tag docs
+
+# List recent bookmarks
+linkmark list
+
+# Search
+linkmark search "python"
+
+# Export
+linkmark export --format markdown > bookmarks.md
+linkmark export --format json > bookmarks.json
+
+# Stats
+linkmark stats
+
+# List tags
+linkmark tags
+
+# Delete
+linkmark delete 1
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `add <url> <note> [--tag TAG ...]` | Save a bookmark with mandatory annotation |
+| `list [--page N] [--limit N]` | List recent bookmarks, newest first |
+| `search <query> [--limit N]` | Full-text search (FTS5, falls back to LIKE) |
+| `export [--format markdown\|json]` | Export all bookmarks |
+| `stats` | Show total, this week, top tags |
+| `delete <id>` | Remove a bookmark by ID |
+| `tags` | List all tags with counts |
+
+## Storage
+
+- SQLite database at `~/.local/share/linkmark/bookmarks.db`
+- FTS5 virtual table for full-text search (auto-created if available)
+- Tags stored in normalized many-to-many tables

linkmark-1.0.0/linkmark.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+linkmark.py
+pyproject.toml
+linkmark.egg-info/PKG-INFO
+linkmark.egg-info/SOURCES.txt
+linkmark.egg-info/dependency_links.txt
+linkmark.egg-info/entry_points.txt
+linkmark.egg-info/top_level.txt

linkmark-1.0.0/linkmark.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

linkmark-1.0.0/linkmark.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+linkmark = linkmark:main

linkmark-1.0.0/linkmark.egg-info/top_level.txt

@@ -0,0 +1 @@
+linkmark

linkmark-1.0.0/linkmark.py

@@ -0,0 +1,490 @@
+#!/usr/bin/env python3
+"""linkmark — Annotated Bookmark CLI for Developers & Researchers.
+
+Save links with mandatory context — because bookmarks are useless without the "why."
+
+Usage:
+    linkmark add <url> <note> [--tag TAG ...]
+    linkmark list [--page N] [--limit N]
+    linkmark search <query> [--limit N]
+    linkmark export [--format markdown|json]
+    linkmark stats
+    linkmark delete <id>
+    linkmark tags
+"""
+
+import argparse
+import json
+import os
+import sqlite3
+import sys
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Database helpers
+# ---------------------------------------------------------------------------
+
+DEFAULT_DB = Path.home() / ".local" / "share" / "linkmark" / "bookmarks.db"
+
+
+def get_db_path() -> Path:
+    """Return the database path, creating parent dirs if needed."""
+    db_path = DEFAULT_DB
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+    return db_path
+
+
+def get_connection(db_path: Path | None = None) -> sqlite3.Connection:
+    """Open a connection and ensure schema exists."""
+    path = db_path or get_db_path()
+    conn = sqlite3.connect(str(path))
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA foreign_keys=ON")
+    _ensure_schema(conn)
+    _ensure_fts(conn)
+    return conn
+
+
+def _ensure_schema(conn: sqlite3.Connection) -> None:
+    """Create tables if they don't exist."""
+    conn.executescript("""
+        CREATE TABLE IF NOT EXISTS bookmarks (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            url TEXT NOT NULL,
+            note TEXT NOT NULL DEFAULT '',
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS tags (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL UNIQUE
+        );
+
+        CREATE TABLE IF NOT EXISTS bookmark_tags (
+            bookmark_id INTEGER NOT NULL REFERENCES bookmarks(id) ON DELETE CASCADE,
+            tag_id INTEGER NOT NULL REFERENCES tags(id) ON DELETE CASCADE,
+            PRIMARY KEY (bookmark_id, tag_id)
+        );
+    """)
+    conn.commit()
+
+
+def _ensure_fts(conn: sqlite3.Connection) -> None:
+    """Create FTS5 virtual table if FTS5 is available; silently skip otherwise."""
+    try:
+        conn.execute("""
+            CREATE VIRTUAL TABLE IF NOT EXISTS bookmarks_fts USING fts5(
+                url, note,
+                content='bookmarks',
+                content_rowid='id'
+            )
+        """)
+        # Triggers to keep FTS index in sync
+        conn.executescript("""
+            CREATE TRIGGER IF NOT EXISTS bookmarks_ai AFTER INSERT ON bookmarks BEGIN
+                INSERT INTO bookmarks_fts(rowid, url, note)
+                VALUES (new.id, new.url, new.note);
+            END;
+            CREATE TRIGGER IF NOT EXISTS bookmarks_ad AFTER DELETE ON bookmarks BEGIN
+                INSERT INTO bookmarks_fts(bookmarks_fts, rowid, url, note)
+                VALUES('delete', old.id, old.url, old.note);
+            END;
+            CREATE TRIGGER IF NOT EXISTS bookmarks_au AFTER UPDATE ON bookmarks BEGIN
+                INSERT INTO bookmarks_fts(bookmarks_fts, rowid, url, note)
+                VALUES('delete', old.id, old.url, old.note);
+                INSERT INTO bookmarks_fts(rowid, url, note)
+                VALUES (new.id, new.url, new.note);
+            END;
+        """)
+        conn.commit()
+    except sqlite3.OperationalError:
+        # FTS5 not available — silently fall back to LIKE search
+        conn.rollback()
+
+
+def _fts_available(conn: sqlite3.Connection) -> bool:
+    """Check whether the FTS table exists."""
+    row = conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='bookmarks_fts'"
+    ).fetchone()
+    return row is not None
+
+
+# ---------------------------------------------------------------------------
+# Time helpers
+# ---------------------------------------------------------------------------
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+def _ts(iso_str: str) -> datetime:
+    return datetime.fromisoformat(iso_str)
+
+
+def _human_time(iso_str: str) -> str:
+    """Convert ISO timestamp to a human-readable relative string."""
+    dt = _ts(iso_str)
+    now = datetime.now(timezone.utc)
+    delta = now - dt
+    if delta < timedelta(minutes=1):
+        return "just now"
+    if delta < timedelta(hours=1):
+        m = delta.seconds // 60
+        return f"{m}m ago"
+    if delta < timedelta(days=1):
+        h = delta.seconds // 3600
+        return f"{h}h ago"
+    if delta < timedelta(days=7):
+        return f"{delta.days}d ago"
+    return dt.strftime("%Y-%m-%d")
+
+
+# ---------------------------------------------------------------------------
+# Commands
+# ---------------------------------------------------------------------------
+
+def cmd_add(args: argparse.Namespace) -> None:
+    """Add a bookmark."""
+    conn = get_connection()
+    now = _now()
+    cursor = conn.execute(
+        "INSERT INTO bookmarks (url, note, created_at, updated_at) VALUES (?, ?, ?, ?)",
+        (args.url, args.note, now, now),
+    )
+    bookmark_id = cursor.lastrowid
+
+    # Handle tags
+    if args.tag:
+        for tag_name in args.tag:
+            tag_name = tag_name.lower().strip()
+            conn.execute("INSERT OR IGNORE INTO tags (name) VALUES (?)", (tag_name,))
+            tag_id = conn.execute(
+                "SELECT id FROM tags WHERE name = ?", (tag_name,)
+            ).fetchone()["id"]
+            conn.execute(
+                "INSERT OR IGNORE INTO bookmark_tags (bookmark_id, tag_id) VALUES (?, ?)",
+                (bookmark_id, tag_id),
+            )
+
+    conn.commit()
+
+    # Show tags in output
+    tags_display = ""
+    if args.tag:
+        tags_display = "  [" + ", ".join(args.tag) + "]"
+
+    print(f"  #{bookmark_id}  {args.url}{tags_display}")
+    print(f"       {args.note}")
+    conn.close()
+
+
+def cmd_list(args: argparse.Namespace) -> None:
+    """List recent bookmarks."""
+    conn = get_connection()
+    limit = args.limit or 20
+    offset = (args.page - 1) * limit if args.page > 1 else 0
+
+    rows = conn.execute(
+        """
+        SELECT b.id, b.url, b.note, b.created_at,
+               (SELECT GROUP_CONCAT(t2.name, ', ')
+                FROM bookmark_tags bt2
+                JOIN tags t2 ON t2.id = bt2.tag_id
+                WHERE bt2.bookmark_id = b.id) AS tags
+        FROM bookmarks b
+        ORDER BY b.created_at DESC, b.id DESC
+        LIMIT ? OFFSET ?
+        """,
+        (limit, offset),
+    ).fetchall()
+
+    if not rows:
+        print("  No bookmarks yet.  linkmark add <url> \"your note\"")
+        conn.close()
+        return
+
+    total = conn.execute("SELECT COUNT(*) AS n FROM bookmarks").fetchone()["n"]
+    page_label = f"page {args.page}" if args.page > 1 else "latest"
+
+    print(f"  Bookmarks ({page_label}, {total} total):")
+    print()
+    for row in rows:
+        tags_str = f"  [{row['tags']}]" if row["tags"] else ""
+        note_preview = row["note"]
+        print(f"  #{row['id']}  {row['url']}{tags_str}")
+        print(f"       {note_preview}  ({_human_time(row['created_at'])})")
+        print()
+
+    conn.close()
+
+
+def cmd_search(args: argparse.Namespace) -> None:
+    """Search bookmarks by query."""
+    conn = get_connection()
+
+    if _fts_available(conn):
+        try:
+            rows = conn.execute(
+                """
+                SELECT b.id, b.url, b.note, b.created_at,
+                       (SELECT GROUP_CONCAT(t2.name, ', ')
+                        FROM bookmark_tags bt2
+                        JOIN tags t2 ON t2.id = bt2.tag_id
+                        WHERE bt2.bookmark_id = b.id) AS tags,
+                       rank
+                FROM bookmarks_fts fts
+                JOIN bookmarks b ON b.id = fts.rowid
+                WHERE bookmarks_fts MATCH ?
+                ORDER BY rank
+                LIMIT ?
+                """,
+                (args.query, args.limit or 20),
+            ).fetchall()
+        except sqlite3.OperationalError:
+            rows = _like_search(conn, args.query, args.limit or 20)
+    else:
+        rows = _like_search(conn, args.query, args.limit or 20)
+
+    if not rows:
+        print(f"  No results for \"{args.query}\"")
+        conn.close()
+        return
+
+    print(f"  Search results for \"{args.query}\" ({len(rows)} found):")
+    print()
+    for row in rows:
+        tags_str = f"  [{row['tags']}]" if row["tags"] else ""
+        print(f"  #{row['id']}  {row['url']}{tags_str}")
+        print(f"       {row['note']}  ({_human_time(row['created_at'])})")
+        print()
+
+    conn.close()
+
+
+def _like_search(conn: sqlite3.Connection, query: str, limit: int):
+    """Fallback LIKE-based search."""
+    pattern = f"%{query}%"
+    return conn.execute(
+        """
+        SELECT b.id, b.url, b.note, b.created_at,
+               (SELECT GROUP_CONCAT(t2.name, ', ')
+                FROM bookmark_tags bt2
+                JOIN tags t2 ON t2.id = bt2.tag_id
+                WHERE bt2.bookmark_id = b.id) AS tags
+        FROM bookmarks b
+        WHERE b.url LIKE ? OR b.note LIKE ?
+        ORDER BY b.created_at DESC, b.id DESC
+        LIMIT ?
+        """,
+        (pattern, pattern, limit),
+    ).fetchall()
+
+
+def cmd_export(args: argparse.Namespace) -> None:
+    """Export bookmarks."""
+    conn = get_connection()
+    fmt = args.format or "markdown"
+
+    rows = conn.execute(
+        """
+        SELECT b.id, b.url, b.note, b.created_at,
+               (SELECT GROUP_CONCAT(t2.name, ', ')
+                FROM bookmark_tags bt2
+                JOIN tags t2 ON t2.id = bt2.tag_id
+                WHERE bt2.bookmark_id = b.id) AS tags
+        FROM bookmarks b
+        ORDER BY b.created_at DESC, b.id DESC
+        """,
+    ).fetchall()
+
+    if fmt == "json":
+        data = []
+        for row in rows:
+            data.append(
+                {
+                    "id": row["id"],
+                    "url": row["url"],
+                    "note": row["note"],
+                    "tags": row["tags"].split(", ") if row["tags"] else [],
+                    "created_at": row["created_at"],
+                }
+            )
+        print(json.dumps(data, indent=2))
+    else:
+        # Markdown
+        print("# linkmark bookmarks\n")
+        print(f"_{len(rows)} bookmarks, exported {_now()}_\n")
+        for row in rows:
+            tags_str = ""
+            if row["tags"]:
+                tags_str = " " + " ".join(f"`{t}`" for t in row["tags"].split(", "))
+            print(f"- [{row['note']}]({row['url']}){tags_str}")
+            print(f"  _saved {_human_time(row['created_at'])}_")
+            print()
+
+    conn.close()
+
+
+def cmd_stats(args: argparse.Namespace) -> None:
+    """Show bookmark statistics."""
+    conn = get_connection()
+
+    total = conn.execute("SELECT COUNT(*) AS n FROM bookmarks").fetchone()["n"]
+
+    # Bookmarks this week
+    week_ago = (datetime.now(timezone.utc) - timedelta(days=7)).isoformat()
+    this_week = conn.execute(
+        "SELECT COUNT(*) AS n FROM bookmarks WHERE created_at >= ?", (week_ago,)
+    ).fetchone()["n"]
+
+    # Top tags
+    top_tags = conn.execute(
+        """
+        SELECT t.name, COUNT(bt.bookmark_id) AS count
+        FROM tags t
+        JOIN bookmark_tags bt ON bt.tag_id = t.id
+        GROUP BY t.id
+        ORDER BY count DESC
+        LIMIT 10
+        """,
+    ).fetchall()
+
+    # Bookmarks this month
+    month_ago = (datetime.now(timezone.utc) - timedelta(days=30)).isoformat()
+    this_month = conn.execute(
+        "SELECT COUNT(*) AS n FROM bookmarks WHERE created_at >= ?", (month_ago,)
+    ).fetchone()["n"]
+
+    print(f"  linkmark stats")
+    print(f"  {'─' * 30}")
+    print(f"  Total bookmarks:    {total}")
+    print(f"  This week:          {this_week}")
+    print(f"  This month:         {this_month}")
+    print()
+
+    if top_tags:
+        print("  Top tags:")
+        for tag in top_tags:
+            bar = "█" * min(tag["count"], 20)
+            print(f"    {tag['name']:20s} {tag['count']:4d}  {bar}")
+    else:
+        print("  No tags yet.  Use --tag when adding bookmarks.")
+
+    conn.close()
+
+
+def cmd_delete(args: argparse.Namespace) -> None:
+    """Delete a bookmark by ID."""
+    conn = get_connection()
+    row = conn.execute("SELECT url FROM bookmarks WHERE id = ?", (args.id,)).fetchone()
+    if not row:
+        print(f"  Bookmark #{args.id} not found.")
+        conn.close()
+        sys.exit(1)
+    conn.execute("DELETE FROM bookmarks WHERE id = ?", (args.id,))
+    conn.commit()
+    print(f"  Deleted #{args.id}  {row['url']}")
+    conn.close()
+
+
+def cmd_tags(args: argparse.Namespace) -> None:
+    """List all tags with counts."""
+    conn = get_connection()
+    rows = conn.execute(
+        """
+        SELECT t.name, COUNT(bt.bookmark_id) AS count
+        FROM tags t
+        JOIN bookmark_tags bt ON bt.tag_id = t.id
+        GROUP BY t.id
+        ORDER BY count DESC
+        """,
+    ).fetchall()
+    if not rows:
+        print("  No tags yet.")
+        conn.close()
+        return
+    for row in rows:
+        print(f"  {row['name']:25s} ({row['count']})")
+    conn.close()
+
+
+# ---------------------------------------------------------------------------
+# CLI entry point
+# ---------------------------------------------------------------------------
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="linkmark",
+        description="linkmark — Annotated Bookmark CLI. Save links with mandatory context.",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    # add
+    p_add = sub.add_parser("add", help="Save a bookmark with annotation")
+    p_add.add_argument("url", help="URL to bookmark")
+    p_add.add_argument("note", help="Why this matters (annotation)")
+    p_add.add_argument("--tag", action="append", default=[], help="Add a tag (repeatable)")
+
+    # list
+    p_list = sub.add_parser("list", help="List recent bookmarks")
+    p_list.add_argument("--page", type=int, default=1, help="Page number (default: 1)")
+    p_list.add_argument("--limit", type=int, default=20, help="Items per page (default: 20)")
+
+    # search
+    p_search = sub.add_parser("search", help="Search bookmarks")
+    p_search.add_argument("query", help="Search query")
+    p_search.add_argument("--limit", type=int, default=20, help="Max results (default: 20)")
+
+    # export
+    p_export = sub.add_parser("export", help="Export bookmarks")
+    p_export.add_argument(
+        "--format",
+        choices=["markdown", "json"],
+        default="markdown",
+        help="Export format (default: markdown)",
+    )
+
+    # stats
+    sub.add_parser("stats", help="Show bookmark statistics")
+
+    # delete
+    p_delete = sub.add_parser("delete", help="Delete a bookmark")
+    p_delete.add_argument("id", type=int, help="Bookmark ID")
+
+    # tags
+    sub.add_parser("tags", help="List all tags")
+
+    return parser
+
+
+def main() -> None:
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(0)
+
+    dispatch = {
+        "add": cmd_add,
+        "list": cmd_list,
+        "search": cmd_search,
+        "export": cmd_export,
+        "stats": cmd_stats,
+        "delete": cmd_delete,
+        "tags": cmd_tags,
+    }
+
+    handler = dispatch.get(args.command)
+    if handler:
+        handler(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

linkmark-1.0.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "linkmark"
+version = "1.0.0"
+description = "Annotated bookmark CLI — save links with mandatory context"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.11"
+authors = [{name = "linkmark contributors"}]
+dependencies = []
+
+[project.scripts]
+linkmark = "linkmark:main"
+
+[tool.setuptools]
+py-modules = ["linkmark"]

linkmark-1.0.0/setup.cfg

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