jodie 0.1.0__py3-none-any.whl

jodie/__init__.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python3
+# jodie/__init__.py
+
+from jodie import contact, parsers
+from jodie.cli.__doc__ import __version__, __description__, __url__, __doc__

jodie/cli/__doc__.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# jodie/cli/__doc__.py
+"""jodie - Manage macOS Contacts.app from command line!
+
+Usage:
+    jodie new TEXT... [options]
+    jodie new [options]
+    jodie new --auto TEXT... [options]
+    jodie new --paste [options]
+    jodie new --stdin [options]
+    jodie new --explicit EMAIL NAME [COMPANY] [TITLE] [NOTE...]
+    jodie parse [options] TEXT
+
+Arguments:
+    TEXT                                Text for jodie to parse intelligently (default mode).
+    EMAIL                               Email address (used with --explicit).
+    NAME                                Full name (used with --explicit).
+    COMPANY                             Company name (used with --explicit).
+    TITLE                               Job title (used with --explicit).
+    NOTE                                Note text (used with --explicit).
+
+Options:
+    --explicit                          Use strict positional parsing (EMAIL NAME COMPANY TITLE NOTE).
+    -A --auto                           Smart parsing mode (default, kept for backward compatibility).
+    -C COMPANY --company=COMPANY        Company name.
+    -E EMAIL --email=EMAIL              Email.
+    -F FIRST --first=FIRST              First name.
+    --first-name=FIRST                  First name (alias for --first).
+    --firstname=FIRST                   First name (alias for --first).
+    -L LAST --last=LAST                 Last name.
+    --last-name=LAST                    Last name (alias for --last).
+    --lastname=LAST                     Last name (alias for --last).
+    -U NAME --full-name=NAME            Full name.
+    --name=NAME                         Full name (alias for --full-name).
+    -N NOTE --note=NOTE                 Any text you want to save in the `Note` field in Contacts.app.
+    --notes=NOTE                        Note text (alias for --note).
+    -P PHONE --phone=PHONE              Phone.
+    -T TITLE --title=TITLE              Job title.
+    -X TEXT  --text=TEXT                Text for jodie to try her best to parse semi-intelligently if she can.
+    -W WEBSITES --websites=WEBSITES     Comma-separated list of websites/URLs.
+    --website=WEBSITES                  Website URLs (alias for --websites).
+    --linkedin=URL                      LinkedIn profile URL (auto-labeled as LinkedIn).
+    -D --dry-run                        Preview parsed fields without saving.
+    -H --help                           Show this screen.
+    -V --version                        Show version.
+    --paste                             Read input from clipboard (pbpaste).
+    --stdin                             Read input from stdin (pipe/heredoc).
+
+"""
+
+__version__     = '0.1.0'
+__title__       = "jodie"
+__license__     = "MIT"
+__description__ = "Jodie lets you add contacts to Contacts.app on macOS from command line"
+__keywords__    = "macOS Contacts.app Contact management Contacts command line tool CLI"
+__author__      = "austin"
+__email__       = "tips@cia.lol"
+__url__         = "https://github.com/austinogilvie/jodie"
+
+
+__all__ = ['__version__', '__description__', '__url__', '__doc__']

jodie/cli/__init__.py

@@ -0,0 +1,2 @@
+#!/usr/bin/env python3
+# jodie/cli/__init__.py

jodie/cli/__main__.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+# jodie/cli/__main__.py
+import sys
+from docopt import docopt
+from nameparser import HumanName
+import jodie
+from jodie.cli.__doc__ import __version__, __description__, __url__, __doc__
+from jodie.constants import WEBMAIL_DOMAINS
+
+COMMANDS = ('new', 'parse',)
+UTILITY_FLAGS = ('--auto', '--explicit', '--help', '--version', '--dry-run', '--paste', '--stdin')
+
+def detect_argument_mode(args):
+    """
+    Mode priority:
+    1. --explicit -> positional (strict order)
+    2. Named flags -> named mode
+    3. TEXT arguments -> auto (default)
+    """
+    # --explicit forces positional mode
+    if args.get('--explicit'):
+        return "positional"
+
+    # Check for named options (excluding utility flags)
+    named_options = {k: v for k, v in args.items()
+                     if k.startswith('--') and k not in UTILITY_FLAGS}
+
+    if any(named_options.values()):
+        return "named"
+
+    # Default: bare args -> auto-parse
+    if args.get('TEXT'):
+        return "auto"
+
+    return "positional"
+
+def parse_auto(arguments):
+    detected_fields = {
+        "first_name": None,
+        "last_name": None,
+        "email": None,
+        "phone": None,
+        "job_title": None,
+        "company": None,
+        "websites": [],
+        "note": None
+    }
+
+    # Track which arguments were consumed (by original text)
+    consumed_args = set()
+
+    # First pass: identify all fields that can be unambiguously determined
+    for arg in arguments:
+        # 1. Email Address - Strong, unambiguous signal
+        if not detected_fields["email"]:
+            email = jodie.parsers.EmailParser.parse(arg)
+            if email:
+                detected_fields["email"] = email
+                consumed_args.add(arg)
+                # Infer name from mailbox format if name is not already set
+                if not detected_fields["first_name"]:
+                    first_name, last_name = jodie.parsers.NameParser.parse(arg)
+                    if first_name or last_name:
+                        detected_fields["first_name"] = first_name
+                        detected_fields["last_name"] = last_name
+                continue
+
+        # 2. Website URL - High-confidence markers
+        website = jodie.parsers.WebsiteParser.parse(arg)
+        if website:
+            if not detected_fields["websites"]:
+                detected_fields["websites"] = []
+            detected_fields["websites"].append(website)
+            consumed_args.add(arg)
+            continue
+
+        # 3. Job Title - Common patterns, after ruling out email/URL
+        if not detected_fields["job_title"]:
+            title = jodie.parsers.TitleParser.parse(arg)
+            if title:
+                detected_fields["job_title"] = title
+                consumed_args.add(arg)
+                continue
+
+        # 4. Phone Number - Look for phone patterns
+        if not detected_fields["phone"]:
+            phone = jodie.parsers.PhoneParser.parse(arg)
+            if phone:
+                detected_fields["phone"] = phone
+                consumed_args.add(arg)
+                continue
+
+        # 5. Person Name - Often ambiguous without context
+        if not detected_fields["first_name"]:
+            first_name, last_name = jodie.parsers.NameParser.parse(arg)
+            if first_name or last_name:
+                detected_fields["first_name"] = first_name
+                detected_fields["last_name"] = last_name
+                consumed_args.add(arg)
+                continue
+
+    # Second pass: handle company name and any remaining fields
+    for arg in arguments:
+        # Skip if this argument was already consumed
+        if arg in consumed_args:
+            continue
+
+        # 6. Company Name - Most ambiguous, use as fallback
+        if not detected_fields["company"]:
+            # Check for business-related terms
+            if any(term in arg.lower() for term in ["inc", "llc", "ltd", "corp", "co"]):
+                detected_fields["company"] = arg.strip()
+                continue
+            
+            # Check if this matches any of the collected website domains
+            if detected_fields["websites"]:
+                for url in detected_fields["websites"]:
+                    domain = url.split("//")[-1].split("/")[0].lower()
+                    if arg.lower() in domain or domain in arg.lower():
+                        detected_fields["company"] = arg.strip()
+                        break
+            if detected_fields["company"]:
+                continue
+
+            # If we get here and still don't have a company, this might be the company name
+            if not detected_fields["company"]:
+                detected_fields["company"] = arg.strip()
+
+    # Infer company from email domain if not found
+    if not detected_fields["company"] and detected_fields["email"]:
+        email = detected_fields["email"]
+        if "@" in email:
+            domain = email.split("@")[1].lower()
+            if domain not in WEBMAIL_DOMAINS:
+                # Extract company name from domain (e.g., "thirdprime.vc" -> "Thirdprime")
+                company_name = domain.split(".")[0].title()
+                detected_fields["company"] = company_name
+
+    return detected_fields
+
+
+def main():
+    first, last, email, phone, title, company, websites, note = (None,) * 8
+
+    args = docopt(__doc__, version=__version__)
+
+    # Handle --paste: read from clipboard and parse
+    if args.get('--paste'):
+        from jodie.input import read_clipboard, SignaturePreprocessor
+        text = read_clipboard()
+        preprocessed = SignaturePreprocessor.preprocess(text)
+        fields = parse_auto(preprocessed)
+        if fields:
+            if fields.get('first_name'):
+                human_name = HumanName(f"{fields['first_name']} {fields['last_name']}".strip())
+                if human_name:
+                    first, last = human_name.first, human_name.last
+            email = fields.get('email')
+            phone = fields.get('phone')
+            title = fields.get('job_title')
+            company = fields.get('company')
+            websites = fields.get('websites')
+        # Apply explicit overrides from command line
+        # TODO: Notes disabled pending AppleScript refactor (ISS-000012)
+        # note = args.get('--note') or args.get('--notes')
+        if args.get('--company'):
+            company = args.get('--company')
+
+    # Handle --stdin: read from stdin and parse
+    elif args.get('--stdin'):
+        from jodie.input import read_stdin, SignaturePreprocessor
+        text = read_stdin()
+        preprocessed = SignaturePreprocessor.preprocess(text)
+        fields = parse_auto(preprocessed)
+        if fields:
+            if fields.get('first_name'):
+                human_name = HumanName(f"{fields['first_name']} {fields['last_name']}".strip())
+                if human_name:
+                    first, last = human_name.first, human_name.last
+            email = fields.get('email')
+            phone = fields.get('phone')
+            title = fields.get('job_title')
+            company = fields.get('company')
+            websites = fields.get('websites')
+        # Apply explicit overrides from command line
+        # TODO: Notes disabled pending AppleScript refactor (ISS-000012)
+        # note = args.get('--note') or args.get('--notes')
+        if args.get('--company'):
+            company = args.get('--company')
+
+    else:
+        # Standard mode detection for non-paste/stdin
+        mode = detect_argument_mode(args)
+
+        if mode == "auto":
+            fields = parse_auto(args['TEXT'])
+            if fields:
+                if fields.get('first_name'):
+                    human_name = HumanName(f"{fields['first_name']} {fields['last_name']}".strip())
+                    if human_name:
+                        first, last = human_name.first, human_name.last
+
+                email = fields.get('email')
+                phone = fields.get('phone')
+                title = fields.get('job_title')
+                company = fields.get('company')
+                websites = fields.get('websites')
+                # TODO: Notes disabled pending AppleScript refactor (ISS-000012)
+                # note = fields.get('note')
+
+        elif mode == "positional":
+            try:
+                full_name = args['NAME']
+                first, last = jodie.parsers.NameParser.parse(full_name)
+                email = jodie.parsers.EmailParser.parse(args['EMAIL'])
+            except Exception as e:
+                sys.stderr.write(
+                    f"Error processing positional arguments: {str(e)}\n")
+                sys.exit(1)
+            company = args.get('COMPANY')
+            title = args.get('TITLE')
+            # TODO: Notes disabled pending AppleScript refactor (ISS-000012)
+            # note = args.get('NOTE')
+
+        elif mode == "named":
+            try:
+                # Handle first name aliases: --first, --first-name, --firstname
+                first = args.get('--first') or args.get('--first-name') or args.get('--firstname')
+                # Handle last name aliases: --last, --last-name, --lastname
+                last = args.get('--last') or args.get('--last-name') or args.get('--lastname')
+                # Handle full name aliases: --full-name, --name
+                full = args.get('--full-name') or args.get('--name')
+                if full:
+                    parts = full.split()
+                    if first is None:
+                        first = parts[0].strip()
+                    if last is None:
+                        last = ' '.join(parts[1:]).strip()
+                email = args.get('--email')
+                phone = args.get('--phone')
+                title = args.get('--title')
+                company = args.get('--company')
+                # Handle websites aliases: --websites, --website
+                websites = args.get('--websites') or args.get('--website')
+                if websites and isinstance(websites, str):
+                    # Only split if it's a string (from command line)
+                    websites = [url.strip() for url in websites.split(',')]
+                # Handle --linkedin specially (adds with LinkedIn label)
+                linkedin_url = args.get('--linkedin')
+                if linkedin_url:
+                    if websites is None:
+                        websites = []
+                    elif isinstance(websites, str):
+                        websites = [websites]
+                    websites.append({'url': linkedin_url, 'label': 'LinkedIn'})
+                # Handle note aliases: --note, --notes
+                # TODO: Notes disabled pending AppleScript refactor (ISS-000012)
+                # note = args.get('--note') or args.get('--notes')
+
+            except Exception as e:
+                sys.stderr.write(f"Error processing named arguments: {str(e)}\n")
+                sys.exit(1)
+
+    # Handle dry-run preview
+    if args.get('--dry-run'):
+        from jodie.cli.preview import format_preview
+        fields = {
+            'first_name': first,
+            'last_name': last,
+            'email': email,
+            'phone': phone,
+            'job_title': title,
+            'company': company,
+            'websites': websites,
+            'note': note
+        }
+        preview = format_preview(fields)
+        sys.stdout.write(preview + "\n")
+        sys.exit(0)
+
+    c = jodie.contact.Contact(
+        first_name=first,
+        last_name=last,
+        email=email,
+        phone=phone,
+        job_title=title,
+        company=company,
+        websites=websites,
+        note=note
+    )
+
+    sys.stdout.write(f'Saving...\n{c}\n')
+    status = 0 if c.save() else 1
+    sys.exit(status)
+
+
+if __name__ == "__main__":
+    main()

jodie/cli/preview.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+# jodie/cli/preview.py
+"""Dry-run preview formatting for contact fields."""
+
+def format_preview(fields: dict) -> str:
+    """Format parsed fields as a preview table.
+
+    Args:
+        fields: Dict with keys like 'first_name', 'last_name', 'email', etc.
+                Values can be strings or dicts with 'value', 'source', 'confidence'
+
+    Returns:
+        Formatted string table
+    """
+    # Normalize fields to consistent format
+    normalized = {}
+    field_labels = {
+        'first_name': 'First Name',
+        'last_name': 'Last Name',
+        'email': 'Email',
+        'phone': 'Phone',
+        'job_title': 'Title',
+        'company': 'Company',
+        'websites': 'Websites',
+        'note': 'Note'
+    }
+
+    for key, value in fields.items():
+        if value is None:
+            continue
+        label = field_labels.get(key, key.replace('_', ' ').title())
+        if isinstance(value, dict):
+            normalized[label] = value
+        elif isinstance(value, list):
+            # Handle websites list
+            if value:
+                normalized[label] = {'value': ', '.join(str(v) for v in value), 'source': 'parsed', 'confidence': 1.0}
+        else:
+            normalized[label] = {'value': str(value), 'source': 'parsed', 'confidence': 1.0}
+
+    if not normalized:
+        return "No fields detected."
+
+    lines = []
+    lines.append("┌" + "─" * 57 + "┐")
+    lines.append("│" + "Contact Preview".center(57) + "│")
+    lines.append("├" + "─" * 14 + "┬" + "─" * 22 + "┬" + "─" * 19 + "┤")
+    lines.append("│ Field        │ Value                │ Source            │")
+    lines.append("├" + "─" * 14 + "┼" + "─" * 22 + "┼" + "─" * 19 + "┤")
+
+    for field_name, field_data in normalized.items():
+        value = str(field_data.get('value', ''))[:20]
+        source = field_data.get('source', 'unknown')
+        confidence = field_data.get('confidence', 0)
+        if confidence > 0:
+            source_str = f"{source} ({int(confidence*100)}%)"
+        else:
+            source_str = source
+        lines.append(f"│ {field_name:<12} │ {value:<20} │ {source_str:<17} │")
+
+    lines.append("└" + "─" * 14 + "┴" + "─" * 22 + "┴" + "─" * 19 + "┘")
+    lines.append("")
+    lines.append("Run without --dry-run to save this contact.")
+
+    return "\n".join(lines)

jodie/config.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+# jodie/config.py
+"""Configuration file support for jodie.
+
+Supports .jodierc files in TOML format, checked in order:
+1. Current directory (./.jodierc)
+2. Home directory (~/.jodierc)
+
+Command-line flags override config values.
+"""
+
+import os
+import sys
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+# Try Python 3.11+ tomllib, fall back to tomli
+try:
+    import tomllib
+except ImportError:
+    try:
+        import tomli as tomllib
+    except ImportError:
+        tomllib = None
+
+
+DEFAULT_CONFIG: Dict[str, Any] = {
+    "defaults": {
+        "company": None,
+        "note_prefix": None,
+        "websites": [],
+        "tags": [],
+    },
+    "parsers": {
+        "email": True,
+        "phone": True,
+        "website": True,
+        "title": True,
+        "name": True,
+        "company": True,
+    },
+    "behavior": {
+        "auto_infer_company": True,
+        "strip_pronouns": True,
+    }
+}
+
+
+def find_config_file() -> Optional[Path]:
+    """Find .jodierc in current dir or home dir.
+
+    Returns:
+        Path to config file if found, None otherwise
+    """
+    candidates = [
+        Path.cwd() / ".jodierc",
+        Path.home() / ".jodierc",
+    ]
+    for path in candidates:
+        if path.exists():
+            return path
+    return None
+
+
+def _deep_merge(base: dict, override: dict) -> dict:
+    """Recursively merge override into base.
+
+    Args:
+        base: Base dictionary
+        override: Dictionary to merge on top
+
+    Returns:
+        Merged dictionary
+    """
+    result = base.copy()
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = _deep_merge(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def load_config() -> Dict[str, Any]:
+    """Load config from file, merged with defaults.
+
+    Returns:
+        Configuration dictionary with defaults and any user overrides
+    """
+    config = DEFAULT_CONFIG.copy()
+    config = {k: v.copy() if isinstance(v, dict) else v for k, v in config.items()}
+
+    if tomllib is None:
+        # No TOML parser available, return defaults
+        return config
+
+    config_file = find_config_file()
+    if config_file:
+        try:
+            with open(config_file, "rb") as f:
+                user_config = tomllib.load(f)
+            config = _deep_merge(config, user_config)
+        except Exception as e:
+            sys.stderr.write(f"Warning: Error loading {config_file}: {e}\n")
+
+    return config
+
+
+def get_default(config: Dict[str, Any], key: str, cli_value: Optional[str] = None) -> Optional[str]:
+    """Get a value, preferring CLI over config.
+
+    Args:
+        config: Configuration dictionary
+        key: Key to look up in defaults section
+        cli_value: Value from command line (takes precedence)
+
+    Returns:
+        CLI value if provided, otherwise config default, or None
+    """
+    if cli_value is not None:
+        return cli_value
+    return config.get("defaults", {}).get(key)

jodie/constants.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+# jodie/constants.py
+"""Shared constants used across jodie modules."""
+
+from typing import FrozenSet
+
+# Common webmail/personal email providers
+# Used to distinguish work emails from personal emails
+# and to skip company inference from these domains
+WEBMAIL_DOMAINS: FrozenSet[str] = frozenset({
+    # Google
+    "gmail.com",
+    "googlemail.com",
+    # Microsoft
+    "hotmail.com",
+    "hotmail.co.uk",
+    "hotmail.de",
+    "hotmail.es",
+    "hotmail.fr",
+    "hotmail.it",
+    "outlook.com",
+    "live.com",
+    # Yahoo
+    "yahoo.com",
+    "ymail.com",
+    # Apple
+    "icloud.com",
+    "mac.com",
+    "me.com",
+    # AOL/Verizon
+    "aol.com",
+    "verizon.net",
+    # Privacy-focused
+    "protonmail.com",
+    "proton.me",
+    "tutanota.com",
+    "tuta.com",
+    "hushmail.com",
+    # Other
+    "hey.com",
+    "qq.com",
+    "zoho.com",
+    "fastmail.com",
+})

jodie/contact/__init__.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python3
+# jodie/contact/__init__.py
+from jodie.contact.contact import Contact
+
+__all__ = ("Contact", )