@codemieai/code 0.0.46 → 0.0.47

package/dist/agents/plugins/claude/plugin/.claude-plugin/plugin.json

@@ -5,5 +5,5 @@
     "name": "AI/Run CodeMie",
     "email": "support@codemieai.com"
   },
-  "version": "1.0.12"
+  "version": "1.0.13"
 }

package/dist/agents/plugins/claude/plugin/skills/msgraph/README.md

@@ -0,0 +1,183 @@
+# Microsoft Graph API Skill for Claude Code
+
+Work with your Microsoft 365 account from Claude Code — emails, calendar, SharePoint, Teams, OneDrive, contacts, and org chart — all via the Microsoft Graph API.
+
+---
+
+## Quick Start
+
+### 1. Install dependencies
+
+```bash
+pip install msal requests
+```
+
+### 2. Log in (first time only)
+
+```bash
+python .codemie/claude-plugin/skills/msgraph/msgraph.py login
+```
+
+You'll see a message like:
+```
+==============================
+To sign in, use a web browser to open the page https://microsoft.com/devicelogin
+and enter the code ABCD-1234 to authenticate.
+==============================
+```
+
+Open the URL in your browser, enter the code, and sign in with your Microsoft account.
+Your token is cached at `~/.ms_graph_token_cache.json` — you won't need to log in again until it expires (tokens refresh automatically).
+
+### 3. Ask Claude anything
+
+After logging in, just ask Claude naturally:
+
+- *"Show me my unread emails"*
+- *"What meetings do I have this week?"*
+- *"Find the Q4 report in SharePoint"*
+- *"What did Alice send me in Teams?"*
+- *"Who reports to me?"*
+
+Claude will use this skill automatically.
+
+---
+
+## CLI Reference
+
+```
+python .codemie/claude-plugin/skills/msgraph/msgraph.py <command> [options]
+```
+
+### Auth commands
+
+| Command | Description |
+|---------|-------------|
+| `login` | Authenticate (device code flow) |
+| `logout` | Remove cached credentials |
+| `status` | Check if you're logged in |
+
+### Data commands
+
+| Command | Key options | Description |
+|---------|-------------|-------------|
+| `me` | | Your profile |
+| `emails` | `--limit N`, `--unread`, `--search QUERY`, `--read ID`, `--send TO --subject S --body B`, `--folder NAME` | Work with Outlook emails |
+| `calendar` | `--limit N`, `--create TITLE --start DT --end DT`, `--availability` | Calendar events |
+| `sharepoint` | `--sites`, `--site ID [--path P]`, `--download ID` | SharePoint files |
+| `teams` | `--chats`, `--messages CHAT_ID`, `--send MSG --chat-id ID`, `--teams-list` | Teams messages |
+| `onedrive` | `[--path P]`, `--upload FILE`, `--download ID`, `--info ID` | OneDrive files |
+| `people` | `--search NAME`, `--contacts` | People & contacts |
+| `org` | `--manager`, `--reports` | Org chart |
+
+Add `--json` to any command for machine-readable JSON output.
+
+---
+
+## Examples
+
+```bash
+# List 20 most recent emails
+python .codemie/claude-plugin/skills/msgraph/msgraph.py emails --limit 20
+
+# Read a specific email (paste the ID from list output)
+python .codemie/claude-plugin/skills/msgraph/msgraph.py emails --read AAMkAGI2...
+
+# Send an email
+python .codemie/claude-plugin/skills/msgraph/msgraph.py emails \
+  --send colleague@company.com \
+  --subject "Quick question" \
+  --body "Are you free tomorrow at 2pm?"
+
+# Upcoming calendar events
+python .codemie/claude-plugin/skills/msgraph/msgraph.py calendar --limit 5
+
+# Create a meeting
+python .codemie/claude-plugin/skills/msgraph/msgraph.py calendar \
+  --create "Design Review" \
+  --start "2024-03-20T14:00" \
+  --end "2024-03-20T15:00" \
+  --timezone "Europe/Berlin"
+
+# List SharePoint sites you follow
+python .codemie/claude-plugin/skills/msgraph/msgraph.py sharepoint --sites
+
+# Browse a site's documents
+python .codemie/claude-plugin/skills/msgraph/msgraph.py sharepoint \
+  --site "contoso.sharepoint.com,abc123,def456" \
+  --path "Documents/2024"
+
+# Download a OneDrive file
+python .codemie/claude-plugin/skills/msgraph/msgraph.py onedrive --download ITEM_ID --output report.xlsx
+
+# Upload to OneDrive
+python .codemie/claude-plugin/skills/msgraph/msgraph.py onedrive \
+  --upload ./presentation.pptx \
+  --dest "Documents/presentations/deck.pptx"
+
+# Recent Teams chats
+python .codemie/claude-plugin/skills/msgraph/msgraph.py teams --chats
+
+# Read a chat conversation
+python .codemie/claude-plugin/skills/msgraph/msgraph.py teams --messages 19:abc123@thread.v2
+
+# Search your contacts
+python .codemie/claude-plugin/skills/msgraph/msgraph.py people --search "John"
+
+# Your manager
+python .codemie/claude-plugin/skills/msgraph/msgraph.py org --manager
+```
+
+---
+
+## Token Cache
+
+Credentials are stored in `~/.ms_graph_token_cache.json`.
+- Access tokens refresh automatically (they last ~1 hour, but MSAL handles renewal)
+- Refresh tokens last longer (~90 days by default in Azure)
+- Run `logout` to remove the cache: `python msgraph.py logout`
+
+---
+
+## Permissions
+
+The script requests these Microsoft Graph scopes on first login:
+
+| Scope | Used for |
+|-------|---------|
+| `User.Read` | Profile (`me`, `org`) |
+| `Mail.Read` | Reading emails |
+| `Mail.Send` | Sending emails |
+| `Calendars.Read` / `Calendars.ReadWrite` | Calendar events |
+| `Files.Read` / `Files.ReadWrite` | OneDrive files |
+| `Sites.Read.All` | SharePoint sites |
+| `Chat.Read` / `Chat.ReadWrite` | Teams chats |
+| `People.Read` | People rankings |
+| `Contacts.Read` | Outlook contacts |
+
+If your organization restricts some permissions, certain commands may return `Permission denied`.
+
+---
+
+## Troubleshooting
+
+**`ModuleNotFoundError: No module named 'msal'`**
+```bash
+pip install msal requests
+```
+
+**`NOT_LOGGED_IN`**
+```bash
+python .codemie/claude-plugin/skills/msgraph/msgraph.py login
+```
+
+**`Permission denied (403)`**
+Your organization may have restricted that Graph API permission. Contact your IT admin.
+
+**`Authentication expired (401)`**
+```bash
+python .codemie/claude-plugin/skills/msgraph/msgraph.py login
+```
+
+**Token cache is at wrong path**
+Edit `CACHE_FILE` at the top of `msgraph.py` to change the location.

package/dist/agents/plugins/claude/plugin/skills/msgraph/SKILL.md

@@ -0,0 +1,233 @@
+---
+name: msgraph
+description: >
+  Work with Microsoft 365 services via the Graph API — emails, calendar events, SharePoint sites,
+  Teams chats, OneDrive files, contacts, and org chart. Use this skill whenever the user asks
+  about their emails, inbox, unread messages, meetings, calendar, Teams messages or chats,
+  SharePoint documents, OneDrive files, colleagues, manager, direct reports, or any personal/
+  organizational Microsoft data. Invoke proactively any time the user mentions Outlook, Teams,
+  SharePoint, OneDrive, or wants to interact with their Microsoft 365 account. The skill uses
+  a local Python CLI (msgraph.py) that handles authentication, token caching, and all API calls.
+---
+
+# Microsoft Graph API Skill
+
+This skill lets you interact with Microsoft 365 services on behalf of the user using the
+Microsoft Graph API. The Python CLI at `scripts/msgraph.py` handles everything.
+
+## Setup & Authentication
+
+**Check login status first** — always run this before any other command:
+
+```bash
+python scripts/msgraph.py status
+```
+
+**Output interpretation:**
+- `Logged in as: user@company.com` → proceed with any command below
+- `NOT_LOGGED_IN` → follow the Login Flow below
+- `TOKEN_EXPIRED` → session expired, also follow the Login Flow below
+
+### Login Flow (first time or after expiry)
+
+```bash
+python scripts/msgraph.py login
+```
+
+This starts the **Device Code Flow** — it will print a URL and a short code like:
+```
+To sign in, use a web browser to open the page https://microsoft.com/devicelogin
+and enter the code ABCD-1234 to authenticate.
+```
+
+Tell the user exactly that message, then wait. Once they complete login in the browser,
+the token is cached at `~/.ms_graph_token_cache.json` and all subsequent commands run silently.
+
+### When NOT logged in or token expired
+
+If status returns `NOT_LOGGED_IN` or `TOKEN_EXPIRED`, tell the user:
+
+> "You need to log in to Microsoft first. Run this command in your terminal:
+> ```
+> python scripts/msgraph.py login
+> ```
+> A code and URL will appear — open the URL in your browser and enter the code."
+
+---
+
+## Available Commands
+
+### Profile & Org
+
+```bash
+# Your profile
+python scripts/msgraph.py me
+
+# Your manager
+python scripts/msgraph.py org --manager
+
+# Your direct reports
+python scripts/msgraph.py org --reports
+```
+
+### Emails
+
+```bash
+# List recent emails (default 10)
+python scripts/msgraph.py emails
+
+# More emails
+python scripts/msgraph.py emails --limit 25
+
+# Unread only
+python scripts/msgraph.py emails --unread
+
+# Search emails
+python scripts/msgraph.py emails --search "invoice Q4"
+
+# Read a specific email by ID (copy ID from list output)
+python scripts/msgraph.py emails --read MESSAGE_ID
+
+# Send an email
+python scripts/msgraph.py emails --send recipient@example.com --subject "Hello" --body "Message text"
+
+# Browse specific folder (inbox, sentitems, drafts, deleteditems, junkemail)
+python scripts/msgraph.py emails --folder sentitems --limit 5
+
+# Machine-readable JSON output
+python scripts/msgraph.py emails --json
+```
+
+### Calendar
+
+```bash
+# Upcoming events (default 10)
+python scripts/msgraph.py calendar
+
+# More events
+python scripts/msgraph.py calendar --limit 20
+
+# Create an event
+python scripts/msgraph.py calendar --create "Team Standup" \
+  --start "2024-03-20T09:00" --end "2024-03-20T09:30" \
+  --location "Teams" --timezone "Europe/Berlin"
+
+# Check availability for a time window
+python scripts/msgraph.py calendar --availability \
+  --start "2024-03-20T09:00:00" --end "2024-03-20T18:00:00"
+```
+
+### SharePoint
+
+```bash
+# List followed/joined SharePoint sites
+python scripts/msgraph.py sharepoint --sites
+
+# Browse files in a specific site (use ID from --sites output)
+python scripts/msgraph.py sharepoint --site SITE_ID
+
+# Browse a subfolder within a site
+python scripts/msgraph.py sharepoint --site SITE_ID --path "Documents/Reports"
+
+# Download a file
+python scripts/msgraph.py sharepoint --download ITEM_ID --output report.xlsx
+```
+
+### Teams
+
+```bash
+# List all Teams chats
+python scripts/msgraph.py teams --chats
+
+# Read messages from a chat (use chat ID from --chats output)
+python scripts/msgraph.py teams --messages CHAT_ID
+
+# Send a message to a chat
+python scripts/msgraph.py teams --send "Hello team!" --chat-id CHAT_ID
+
+# List teams you're a member of
+python scripts/msgraph.py teams --teams-list
+```
+
+### OneDrive
+
+```bash
+# List root files
+python scripts/msgraph.py onedrive
+
+# Browse a folder
+python scripts/msgraph.py onedrive --path "Documents"
+
+# Upload a file
+python scripts/msgraph.py onedrive --upload ./report.pdf --dest "Documents/report.pdf"
+
+# Download a file by ID
+python scripts/msgraph.py onedrive --download ITEM_ID --output local_copy.pdf
+
+# File metadata
+python scripts/msgraph.py onedrive --info ITEM_ID
+```
+
+### People & Contacts
+
+```bash
+# Frequent collaborators (AI-ranked by Microsoft)
+python scripts/msgraph.py people
+
+# Search people by name
+python scripts/msgraph.py people --search "Alice"
+
+# Outlook address book contacts
+python scripts/msgraph.py people --contacts
+```
+
+---
+
+## Workflow Patterns
+
+### "Show me my emails"
+1. Run `status` → check login
+2. Run `emails --limit 15` → show results
+3. If user wants to read one, run `emails --read ID`
+
+### "What's on my calendar today/this week?"
+1. Run `calendar --limit 10`
+2. Parse dates in output and filter for user's timeframe
+
+### "Find a file in SharePoint"
+1. Run `sharepoint --sites` → list sites
+2. Run `sharepoint --site SITE_ID` → browse files
+3. Use `--path` to drill into folders
+4. Offer `--download ITEM_ID` if user wants the file
+
+### "Check my Teams messages"
+1. Run `teams --chats` → list chats
+2. User picks a chat → run `teams --messages CHAT_ID`
+
+### "Who's my manager?" / "Who reports to me?"
+- Run `org --manager` or `org --reports`
+
+---
+
+## Error Handling
+
+| Exit code | Meaning |
+|-----------|---------|
+| 0 | Success |
+| 1 | API error (shown in output) |
+| 2 | NOT_LOGGED_IN — user must run `login` |
+
+When you see `Permission denied` errors, it means the OAuth scope isn't granted for that operation.
+This can happen if the user's organization has restricted certain Graph API permissions.
+
+---
+
+## Dependencies
+
+The script requires Python 3.10+ and two packages:
+```bash
+pip install msal requests
+```
+
+If `msal` or `requests` are not installed, the script prints the install command and exits.
+IMPORTANT: you must work with current date (get it from sh/bash)

package/dist/agents/plugins/claude/plugin/skills/msgraph/scripts/msgraph.py

@@ -0,0 +1,785 @@
+#!/usr/bin/env python3
+"""
+msgraph.py — Microsoft Graph API CLI for Claude Code skill
+
+Authentication: MSAL device code flow with persistent token cache.
+First time: python msgraph.py login
+Subsequent: token refreshed silently from cache.
+"""
+
+import argparse
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+try:
+    from msal import PublicClientApplication, SerializableTokenCache
+    import requests
+except ImportError:
+    print("Missing dependencies. Install with:")
+    print("  pip install msal requests")
+    sys.exit(1)
+
+# ── Config ────────────────────────────────────────────────────────────────────
+CLIENT_ID  = "14d82eec-204b-4c2f-b7e8-296a70dab67e"   # MS GraphAPI public client
+AUTHORITY  = "https://login.microsoftonline.com/common"
+SCOPES     = [
+    "User.Read",
+    "Mail.Read",
+    "Mail.Send",
+    "Calendars.Read",
+    "Calendars.ReadWrite",
+    "Files.Read",
+    "Files.ReadWrite",
+    "Sites.Read.All",
+    "Chat.Read",
+    "Chat.ReadWrite",
+    "People.Read",
+    "Contacts.Read",
+]
+CACHE_FILE = Path.home() / ".ms_graph_token_cache.json"
+GRAPH_BASE = "https://graph.microsoft.com/v1.0"
+
+# ── Token Cache ───────────────────────────────────────────────────────────────
+def load_cache() -> SerializableTokenCache:
+    cache = SerializableTokenCache()
+    if CACHE_FILE.exists():
+        cache.deserialize(CACHE_FILE.read_text())
+    return cache
+
+def save_cache(cache: SerializableTokenCache):
+    if cache.has_state_changed:
+        CACHE_FILE.write_text(cache.serialize())
+
+# ── Authentication ────────────────────────────────────────────────────────────
+def get_access_token(force_login: bool = False) -> str:
+    cache = load_cache()
+    app = PublicClientApplication(
+        client_id=CLIENT_ID,
+        authority=AUTHORITY,
+        token_cache=cache
+    )
+
+    if not force_login:
+        accounts = app.get_accounts()
+        if accounts:
+            result = app.acquire_token_silent(SCOPES, account=accounts[0])
+            if result and "access_token" in result:
+                save_cache(cache)
+                return result["access_token"]
+
+    # Device Code Flow
+    flow = app.initiate_device_flow(scopes=SCOPES)
+    if "user_code" not in flow:
+        raise RuntimeError(f"Failed to initiate device flow: {flow.get('error_description')}")
+
+    print("\n" + "=" * 60)
+    print(flow["message"])
+    print("=" * 60 + "\n")
+
+    result = app.acquire_token_by_device_flow(flow)
+    if "access_token" not in result:
+        raise RuntimeError(f"Authentication failed: {result.get('error_description')}")
+
+    save_cache(cache)
+    return result["access_token"]
+
+def get_token_or_exit() -> str:
+    """Get token from cache only — exit with helpful message if not logged in or token expired."""
+    cache = load_cache()
+    app = PublicClientApplication(
+        client_id=CLIENT_ID,
+        authority=AUTHORITY,
+        token_cache=cache
+    )
+    accounts = app.get_accounts()
+    if not accounts:
+        print("NOT_LOGGED_IN")
+        sys.exit(2)
+    result = app.acquire_token_silent(SCOPES, account=accounts[0])
+    if not result or "access_token" not in result:
+        print("TOKEN_EXPIRED")
+        sys.exit(2)
+    save_cache(cache)
+    return result["access_token"]
+
+# ── Graph API Helpers ─────────────────────────────────────────────────────────
+def graph_get(endpoint: str, token: str, params: dict | None = None) -> dict:
+    r = requests.get(
+        f"{GRAPH_BASE}{endpoint}",
+        headers={"Authorization": f"Bearer {token}"},
+        params=params or {}
+    )
+    r.raise_for_status()
+    return r.json()
+
+def graph_post(endpoint: str, token: str, body: dict) -> dict:
+    r = requests.post(
+        f"{GRAPH_BASE}{endpoint}",
+        headers={
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json"
+        },
+        json=body
+    )
+    r.raise_for_status()
+    return r.json() if r.content else {}
+
+def graph_download(endpoint: str, token: str) -> bytes:
+    r = requests.get(
+        f"{GRAPH_BASE}{endpoint}",
+        headers={"Authorization": f"Bearer {token}"},
+        allow_redirects=True
+    )
+    r.raise_for_status()
+    return r.content
+
+def graph_upload(endpoint: str, token: str, content: bytes, content_type: str = "application/octet-stream") -> dict:
+    r = requests.put(
+        f"{GRAPH_BASE}{endpoint}",
+        headers={
+            "Authorization": f"Bearer {token}",
+            "Content-Type": content_type
+        },
+        data=content
+    )
+    r.raise_for_status()
+    return r.json()
+
+# ── Formatters ────────────────────────────────────────────────────────────────
+def fmt_dt(iso: str) -> str:
+    """Format ISO datetime to readable string."""
+    try:
+        dt = datetime.fromisoformat(iso.replace("Z", "+00:00"))
+        return dt.strftime("%Y-%m-%d %H:%M")
+    except Exception:
+        return iso[:16].replace("T", " ")
+
+def fmt_size(size: int) -> str:
+    for unit in ["B", "KB", "MB", "GB"]:
+        if size < 1024:
+            return f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} TB"
+
+def print_json(data: dict | list):
+    print(json.dumps(data, indent=2, ensure_ascii=False))
+
+# ── Commands ──────────────────────────────────────────────────────────────────
+
+def cmd_login(args):
+    """Authenticate and cache credentials."""
+    print("Starting Microsoft authentication...")
+    token = get_access_token(force_login=True)
+    me = graph_get("/me", token)
+    print(f"\nLogged in as: {me['displayName']} <{me['userPrincipalName']}>")
+    print(f"User ID: {me['id']}")
+    print(f"Token cached at: {CACHE_FILE}")
+
+def cmd_logout(args):
+    """Remove cached credentials."""
+    if CACHE_FILE.exists():
+        CACHE_FILE.unlink()
+        print(f"Logged out. Cache removed: {CACHE_FILE}")
+    else:
+        print("No cached credentials found.")
+
+def cmd_status(args):
+    """Check login status."""
+    cache = load_cache()
+    app = PublicClientApplication(client_id=CLIENT_ID, authority=AUTHORITY, token_cache=cache)
+    accounts = app.get_accounts()
+    if not accounts:
+        print("NOT_LOGGED_IN")
+        print(f"\nTo login, run:\n  python {Path(__file__).name} login")
+        return
+    # Verify token can actually be acquired (not just that account exists in cache)
+    result = app.acquire_token_silent(SCOPES, account=accounts[0])
+    if result and "access_token" in result:
+        save_cache(cache)
+        print(f"Logged in as: {accounts[0]['username']}")
+        print(f"Cache file: {CACHE_FILE}")
+    else:
+        print("TOKEN_EXPIRED")
+        print(f"Account: {accounts[0]['username']}")
+        print(f"\nSession expired. Re-authenticate with:\n  python {Path(__file__).name} login")
+
+def cmd_me(args):
+    """Show user profile information."""
+    token = get_token_or_exit()
+    me = graph_get("/me", token)
+    fields = ["displayName", "userPrincipalName", "id", "mail", "jobTitle",
+              "department", "officeLocation", "businessPhones", "mobilePhone"]
+    if args.json:
+        print_json({k: me.get(k) for k in fields if me.get(k)})
+        return
+    print(f"Name       : {me.get('displayName', 'N/A')}")
+    print(f"Email      : {me.get('userPrincipalName', 'N/A')}")
+    print(f"Job Title  : {me.get('jobTitle', 'N/A')}")
+    print(f"Department : {me.get('department', 'N/A')}")
+    print(f"Office     : {me.get('officeLocation', 'N/A')}")
+    print(f"Phone      : {me.get('businessPhones', ['N/A'])[0] if me.get('businessPhones') else 'N/A'}")
+    print(f"User ID    : {me.get('id', 'N/A')}")
+
+def cmd_emails(args):
+    """List, read, send or search emails."""
+    token = get_token_or_exit()
+
+    if args.send:
+        # Send email: --send "To <email>" --subject "Subject" --body "Body"
+        to_email = args.send
+        body_content = args.body or ""
+        subject = args.subject or "(no subject)"
+        payload = {
+            "message": {
+                "subject": subject,
+                "body": {"contentType": "Text", "content": body_content},
+                "toRecipients": [{"emailAddress": {"address": to_email}}]
+            }
+        }
+        graph_post("/me/sendMail", token, payload)
+        print(f"Email sent to {to_email}")
+        return
+
+    if args.read:
+        # Read a specific email by ID
+        msg = graph_get(f"/me/messages/{args.read}", token)
+        print(f"Subject  : {msg.get('subject')}")
+        print(f"From     : {msg['from']['emailAddress']['name']} <{msg['from']['emailAddress']['address']}>")
+        print(f"Date     : {fmt_dt(msg['receivedDateTime'])}")
+        print(f"Read     : {'Yes' if msg['isRead'] else 'No'}")
+        print(f"\n{'─'*60}")
+        body = msg.get("body", {})
+        if body.get("contentType") == "text":
+            print(body.get("content", ""))
+        else:
+            # Strip basic HTML tags for readability
+            import re
+            text = re.sub(r'<[^>]+>', '', body.get("content", ""))
+            print(text[:2000])
+        return
+
+    # List/search emails
+    params: dict = {
+        "$top": args.limit,
+        "$select": "id,subject,from,receivedDateTime,isRead,hasAttachments,importance",
+        "$orderby": "receivedDateTime desc"
+    }
+    if args.search:
+        params["$search"] = f'"{args.search}"'
+        params.pop("$orderby", None)  # $search incompatible with $orderby
+    if args.folder:
+        endpoint = f"/me/mailFolders/{args.folder}/messages"
+    elif args.unread:
+        params["$filter"] = "isRead eq false"
+        endpoint = "/me/messages"
+    else:
+        endpoint = "/me/messages"
+
+    data = graph_get(endpoint, token, params)
+    emails = data.get("value", [])
+
+    if args.json:
+        print_json(emails)
+        return
+
+    if not emails:
+        print("No emails found.")
+        return
+
+    print(f"\n{'ID':<36}  {'Date':<16}  {'Rd'}  {'Subject'}")
+    print("─" * 80)
+    for e in emails:
+        read_mark = "✓" if e["isRead"] else "●"
+        attach = "📎" if e.get("hasAttachments") else "  "
+        subject = e.get("subject", "(no subject)")[:45]
+        sender = e["from"]["emailAddress"].get("name", "")[:20]
+        date = fmt_dt(e["receivedDateTime"])
+        print(f"{e['id'][:36]}  {date}  {read_mark}   {attach} {subject}  ({sender})")
+
+def cmd_calendar(args):
+    """List or create calendar events."""
+    token = get_token_or_exit()
+
+    if args.create:
+        # Create event: --create "Title" --start "2024-03-15T10:00" --end "2024-03-15T11:00"
+        if not args.start or not args.end:
+            print("Error: --create requires --start and --end (format: YYYY-MM-DDTHH:MM)")
+            sys.exit(1)
+        tz = args.timezone or "UTC"
+        payload = {
+            "subject": args.create,
+            "start": {"dateTime": args.start, "timeZone": tz},
+            "end": {"dateTime": args.end, "timeZone": tz},
+        }
+        if args.location:
+            payload["location"] = {"displayName": args.location}
+        if args.body:
+            payload["body"] = {"contentType": "Text", "content": args.body}
+        event = graph_post("/me/events", token, payload)
+        print(f"Event created: {event.get('subject')}")
+        print(f"ID: {event.get('id')}")
+        return
+
+    if args.availability:
+        # Check free/busy for a time range
+        start = args.start or datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S")
+        end   = args.end   or datetime.now(timezone.utc).replace(hour=23, minute=59).strftime("%Y-%m-%dT%H:%M:%S")
+        view = graph_get(
+            "/me/calendarView",
+            token,
+            {"startDateTime": start, "endDateTime": end,
+             "$select": "subject,start,end,showAs", "$orderby": "start/dateTime"}
+        )
+        events = view.get("value", [])
+        if not events:
+            print(f"You're free between {start[:16]} and {end[:16]}.")
+        else:
+            print(f"\nBusy slots ({len(events)} events):")
+            for e in events:
+                print(f"  {fmt_dt(e['start']['dateTime'])} — {fmt_dt(e['end']['dateTime'])}: {e.get('subject', '(no title)')}")
+        return
+
+    # List upcoming events
+    now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    data = graph_get(
+        "/me/calendarView",
+        token,
+        {
+            "startDateTime": now,
+            "endDateTime": f"{datetime.now(timezone.utc).year + 1}-01-01T00:00:00Z",
+            "$top": args.limit,
+            "$select": "id,subject,start,end,location,organizer,isOnlineMeeting,onlineMeetingUrl",
+            "$orderby": "start/dateTime"
+        }
+    )
+    events = data.get("value", [])
+
+    if args.json:
+        print_json(events)
+        return
+
+    if not events:
+        print("No upcoming events.")
+        return
+
+    print(f"\n{'Date & Time':<20}  {'Duration':<10}  {'Title'}")
+    print("─" * 80)
+    for e in events:
+        start = fmt_dt(e["start"]["dateTime"])
+        title = e.get("subject", "(no title)")[:45]
+        organizer = e["organizer"]["emailAddress"].get("name", "")[:20]
+        online = "🎥" if e.get("isOnlineMeeting") else "  "
+        loc = e.get("location", {}).get("displayName", "")[:20]
+        print(f"{start:<20}  {online}  {title}  ({organizer})" + (f"  @ {loc}" if loc else ""))
+
+def cmd_sharepoint(args):
+    """Browse SharePoint sites and files."""
+    token = get_token_or_exit()
+
+    if args.sites:
+        # List all joined sites
+        data = graph_get("/me/followedSites", token, {"$select": "id,displayName,webUrl"})
+        sites = data.get("value", [])
+        if not sites:
+            # Fallback: search for sites
+            data = graph_get("/sites", token, {"search": "*", "$top": args.limit})
+            sites = data.get("value", [])
+        if args.json:
+            print_json(sites)
+            return
+        print(f"\n{'ID':<50}  {'Name'}")
+        print("─" * 80)
+        for s in sites[:args.limit]:
+            print(f"{s['id']:<50}  {s.get('displayName', 'N/A')}")
+            print(f"  URL: {s.get('webUrl', 'N/A')}")
+        return
+
+    if args.site:
+        # Browse files in a site's drive
+        site_id = args.site
+        path = args.path or "root"
+        endpoint = f"/sites/{site_id}/drive/root/children" if path == "root" else f"/sites/{site_id}/drive/root:/{path}:/children"
+        data = graph_get(endpoint, token, {"$top": args.limit, "$select": "id,name,size,lastModifiedDateTime,file,folder"})
+        items = data.get("value", [])
+        if args.json:
+            print_json(items)
+            return
+        print(f"\nFiles in site {site_id} / {path}:")
+        print("─" * 60)
+        for item in items:
+            kind = "📁" if "folder" in item else "📄"
+            size = fmt_size(item.get("size", 0)) if "file" in item else ""
+            modified = fmt_dt(item.get("lastModifiedDateTime", ""))
+            print(f"  {kind} {item['name']:<40} {size:<10} {modified}")
+        return
+
+    if args.download:
+        # Download a file by item ID from personal drive (use --site for SharePoint)
+        content = graph_download(f"/me/drive/items/{args.download}/content", token)
+        out_path = Path(args.output or f"downloaded_{args.download[:8]}")
+        out_path.write_bytes(content)
+        print(f"Downloaded {len(content)} bytes to {out_path}")
+        return
+
+    print("SharePoint commands: --sites | --site SITE_ID [--path PATH] | --download ITEM_ID")
+
+def cmd_teams(args):
+    """List Teams chats and messages."""
+    token = get_token_or_exit()
+
+    if args.chats:
+        # List all chats
+        data = graph_get("/me/chats", token, {
+            "$top": args.limit,
+            "$select": "id,topic,chatType,lastUpdatedDateTime"
+        })
+        chats = data.get("value", [])
+        if args.json:
+            print_json(chats)
+            return
+        print(f"\n{'Chat ID':<50}  {'Type':<10}  {'Topic'}")
+        print("─" * 80)
+        for c in chats:
+            topic = c.get("topic") or "(direct message)"
+            print(f"{c['id']:<50}  {c.get('chatType',''):<10}  {topic}")
+        return
+
+    if args.messages:
+        # Get messages in a chat
+        data = graph_get(f"/me/chats/{args.messages}/messages", token, {
+            "$top": args.limit,
+            "$select": "id,from,body,createdDateTime"
+        })
+        msgs = data.get("value", [])
+        if args.json:
+            print_json(msgs)
+            return
+        print(f"\nMessages in chat {args.messages[:20]}...:")
+        print("─" * 60)
+        for m in reversed(msgs):
+            sender = m.get("from", {}).get("user", {}).get("displayName", "Unknown") if m.get("from") else "System"
+            time = fmt_dt(m.get("createdDateTime", ""))
+            import re
+            body = re.sub(r'<[^>]+>', '', m.get("body", {}).get("content", ""))[:200]
+            print(f"[{time}] {sender}: {body}")
+        return
+
+    if args.send and args.chat_id:
+        # Send message to a chat
+        payload = {"body": {"content": args.send}}
+        result = graph_post(f"/me/chats/{args.chat_id}/messages", token, payload)
+        print(f"Message sent. ID: {result.get('id')}")
+        return
+
+    if args.teams_list:
+        # List joined teams
+        data = graph_get("/me/joinedTeams", token, {"$select": "id,displayName,description"})
+        teams = data.get("value", [])
+        if args.json:
+            print_json(teams)
+            return
+        for t in teams:
+            print(f"{t['id'][:36]}  {t['displayName']}")
+        return
+
+    print("Teams commands: --chats | --messages CHAT_ID | --send MSG --chat-id CHAT_ID | --teams-list")
+
+def cmd_onedrive(args):
+    """Browse, upload and download OneDrive files."""
+    token = get_token_or_exit()
+
+    if args.upload:
+        src = Path(args.upload)
+        if not src.exists():
+            print(f"File not found: {src}")
+            sys.exit(1)
+        dest_path = args.dest or src.name
+        content = src.read_bytes()
+        result = graph_upload(f"/me/drive/root:/{dest_path}:/content", token, content)
+        print(f"Uploaded: {result.get('name')} ({fmt_size(result.get('size', 0))})")
+        print(f"ID: {result.get('id')}")
+        return
+
+    if args.download:
+        content = graph_download(f"/me/drive/items/{args.download}/content", token)
+        out_path = Path(args.output or f"download_{args.download[:8]}")
+        out_path.write_bytes(content)
+        print(f"Downloaded {fmt_size(len(content))} to {out_path}")
+        return
+
+    if args.info:
+        item = graph_get(f"/me/drive/items/{args.info}", token)
+        if args.json:
+            print_json(item)
+            return
+        print(f"Name    : {item.get('name')}")
+        print(f"Size    : {fmt_size(item.get('size', 0))}")
+        print(f"Modified: {fmt_dt(item.get('lastModifiedDateTime', ''))}")
+        print(f"URL     : {item.get('webUrl', 'N/A')}")
+        return
+
+    # List files in a path
+    path = args.path or ""
+    endpoint = "/me/drive/root/children" if not path else f"/me/drive/root:/{path}:/children"
+    data = graph_get(endpoint, token, {
+        "$top": args.limit,
+        "$select": "id,name,size,lastModifiedDateTime,file,folder",
+        "$orderby": "name"
+    })
+    items = data.get("value", [])
+
+    if args.json:
+        print_json(items)
+        return
+
+    if not items:
+        print(f"No files found in /{path or ''}")
+        return
+
+    print(f"\nOneDrive: /{path or ''}")
+    print("─" * 60)
+    for item in items:
+        kind = "📁" if "folder" in item else "📄"
+        size = fmt_size(item.get("size", 0)) if "file" in item else ""
+        modified = fmt_dt(item.get("lastModifiedDateTime", ""))
+        count = f"  ({item['folder']['childCount']} items)" if "folder" in item else ""
+        print(f"  {kind} {item['id'][:16]}  {item['name']:<40} {size:<10} {modified}{count}")
+
+def cmd_people(args):
+    """List relevant people and contacts."""
+    token = get_token_or_exit()
+
+    if args.contacts:
+        # Outlook contacts
+        params = {"$top": args.limit, "$select": "displayName,emailAddresses,mobilePhone,jobTitle,companyName"}
+        if args.search:
+            params["$search"] = f'"{args.search}"'
+        data = graph_get("/me/contacts", token, params)
+        contacts = data.get("value", [])
+        if args.json:
+            print_json(contacts)
+            return
+        print(f"\n{'Name':<30}  {'Email':<35}  {'Title'}")
+        print("─" * 80)
+        for c in contacts:
+            emails = [e["address"] for e in c.get("emailAddresses", [])]
+            email = emails[0] if emails else "N/A"
+            print(f"{c.get('displayName',''):<30}  {email:<35}  {c.get('jobTitle','')}")
+        return
+
+    # Relevant people (AI-ranked by interaction)
+    params = {"$top": args.limit}
+    if args.search:
+        params["$search"] = f'"{args.search}"'
+    data = graph_get("/me/people", token, params)
+    people = data.get("value", [])
+
+    if args.json:
+        print_json(people)
+        return
+
+    if not people:
+        print("No people found.")
+        return
+
+    print(f"\n{'Name':<30}  {'Email':<35}  {'Title'}")
+    print("─" * 80)
+    for p in people:
+        emails = [s["address"] for s in p.get("scoredEmailAddresses", [])]
+        email = emails[0] if emails else "N/A"
+        print(f"{p.get('displayName',''):<30}  {email:<35}  {p.get('jobTitle','')}")
+
+def cmd_org(args):
+    """Show organizational info: manager, reports, colleagues."""
+    token = get_token_or_exit()
+
+    if args.manager:
+        try:
+            mgr = graph_get("/me/manager", token)
+            print(f"Manager: {mgr.get('displayName')} <{mgr.get('userPrincipalName')}>")
+            print(f"Title  : {mgr.get('jobTitle', 'N/A')}")
+        except requests.HTTPError as e:
+            if e.response.status_code == 404:
+                print("No manager found (you may be at the top of the org).")
+            else:
+                raise
+        return
+
+    if args.reports:
+        data = graph_get("/me/directReports", token,
+                         {"$select": "displayName,userPrincipalName,jobTitle"})
+        reports = data.get("value", [])
+        print(f"\nDirect Reports ({len(reports)}):")
+        for r in reports:
+            print(f"  {r.get('displayName'):<30}  {r.get('userPrincipalName')}")
+        return
+
+    # Default: show org context
+    try:
+        mgr = graph_get("/me/manager", token)
+        print(f"Manager: {mgr.get('displayName')}")
+    except Exception:
+        pass
+    reports = graph_get("/me/directReports", token, {"$select": "displayName"}).get("value", [])
+    print(f"Direct Reports: {len(reports)}")
+    colleagues = graph_get("/me/people", token, {"$top": 5}).get("value", [])
+    print(f"\nFrequent colleagues:")
+    for p in colleagues:
+        print(f"  {p.get('displayName')}")
+
+# ── CLI Setup ─────────────────────────────────────────────────────────────────
+def main():
+    parser = argparse.ArgumentParser(
+        description="Microsoft Graph API CLI",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python msgraph.py login                          # Authenticate
+  python msgraph.py status                         # Check login status
+  python msgraph.py me                             # Show profile
+  python msgraph.py emails --limit 10              # List 10 emails
+  python msgraph.py emails --unread                # Unread emails
+  python msgraph.py emails --search "invoice"      # Search emails
+  python msgraph.py emails --read MSG_ID           # Read specific email
+  python msgraph.py emails --send "a@b.com" --subject "Hi" --body "Hello"
+  python msgraph.py calendar --limit 10            # Upcoming events
+  python msgraph.py calendar --create "Meeting" --start 2024-03-15T10:00 --end 2024-03-15T11:00
+  python msgraph.py sharepoint --sites             # List SharePoint sites
+  python msgraph.py teams --chats                  # List Teams chats
+  python msgraph.py teams --messages CHAT_ID       # Read chat messages
+  python msgraph.py onedrive                       # List OneDrive root
+  python msgraph.py onedrive --path "Documents"    # Browse folder
+  python msgraph.py onedrive --upload file.txt     # Upload file
+  python msgraph.py people                         # Frequent contacts
+  python msgraph.py org --manager                  # Show your manager
+"""
+    )
+
+    # Global flags
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    # login
+    subparsers.add_parser("login", help="Authenticate with Microsoft")
+
+    # logout
+    subparsers.add_parser("logout", help="Remove cached credentials")
+
+    # status
+    subparsers.add_parser("status", help="Check login status")
+
+    # me
+    p_me = subparsers.add_parser("me", help="Show user profile")
+    p_me.add_argument("--json", action="store_true")
+
+    # emails
+    p_email = subparsers.add_parser("emails", help="Work with emails")
+    p_email.add_argument("--limit", type=int, default=10, help="Number of emails to show")
+    p_email.add_argument("--search", help="Search query")
+    p_email.add_argument("--unread", action="store_true", help="Show only unread emails")
+    p_email.add_argument("--folder", help="Mail folder (inbox, sentitems, drafts, etc.)")
+    p_email.add_argument("--read", metavar="ID", help="Read email by ID")
+    p_email.add_argument("--send", metavar="TO", help="Send email to address")
+    p_email.add_argument("--subject", help="Email subject (for --send)")
+    p_email.add_argument("--body", help="Email body text")
+    p_email.add_argument("--json", action="store_true")
+
+    # calendar
+    p_cal = subparsers.add_parser("calendar", help="Work with calendar")
+    p_cal.add_argument("--limit", type=int, default=10)
+    p_cal.add_argument("--create", metavar="TITLE", help="Create event with this title")
+    p_cal.add_argument("--start", help="Start datetime (YYYY-MM-DDTHH:MM)")
+    p_cal.add_argument("--end", help="End datetime (YYYY-MM-DDTHH:MM)")
+    p_cal.add_argument("--location", help="Event location")
+    p_cal.add_argument("--body", help="Event description")
+    p_cal.add_argument("--timezone", default="UTC", help="Timezone (e.g. Europe/Berlin)")
+    p_cal.add_argument("--availability", action="store_true", help="Check free/busy")
+    p_cal.add_argument("--json", action="store_true")
+
+    # sharepoint
+    p_sp = subparsers.add_parser("sharepoint", help="Browse SharePoint")
+    p_sp.add_argument("--sites", action="store_true", help="List followed sites")
+    p_sp.add_argument("--site", metavar="SITE_ID", help="Browse files in site")
+    p_sp.add_argument("--path", help="Path within site drive")
+    p_sp.add_argument("--download", metavar="ITEM_ID", help="Download file by ID")
+    p_sp.add_argument("--output", help="Output file path")
+    p_sp.add_argument("--limit", type=int, default=20)
+    p_sp.add_argument("--json", action="store_true")
+
+    # teams
+    p_teams = subparsers.add_parser("teams", help="Work with Teams")
+    p_teams.add_argument("--chats", action="store_true", help="List all chats")
+    p_teams.add_argument("--messages", metavar="CHAT_ID", help="Get messages from chat")
+    p_teams.add_argument("--send", metavar="TEXT", help="Send a message")
+    p_teams.add_argument("--chat-id", dest="chat_id", help="Target chat ID for --send")
+    p_teams.add_argument("--teams-list", action="store_true", help="List joined teams")
+    p_teams.add_argument("--limit", type=int, default=20)
+    p_teams.add_argument("--json", action="store_true")
+
+    # onedrive
+    p_od = subparsers.add_parser("onedrive", help="Work with OneDrive")
+    p_od.add_argument("--path", help="Folder path to browse")
+    p_od.add_argument("--upload", metavar="FILE", help="Upload a local file")
+    p_od.add_argument("--dest", help="Destination path in OneDrive (for --upload)")
+    p_od.add_argument("--download", metavar="ITEM_ID", help="Download by item ID")
+    p_od.add_argument("--output", help="Output file path")
+    p_od.add_argument("--info", metavar="ITEM_ID", help="Get file metadata")
+    p_od.add_argument("--limit", type=int, default=20)
+    p_od.add_argument("--json", action="store_true")
+
+    # people
+    p_ppl = subparsers.add_parser("people", help="Browse people and contacts")
+    p_ppl.add_argument("--contacts", action="store_true", help="Use Outlook contacts (not people)")
+    p_ppl.add_argument("--search", help="Search by name")
+    p_ppl.add_argument("--limit", type=int, default=20)
+    p_ppl.add_argument("--json", action="store_true")
+
+    # org
+    p_org = subparsers.add_parser("org", help="Organizational info")
+    p_org.add_argument("--manager", action="store_true", help="Show your manager")
+    p_org.add_argument("--reports", action="store_true", help="Show direct reports")
+    p_org.add_argument("--json", action="store_true")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(0)
+
+    command_map = {
+        "login":      cmd_login,
+        "logout":     cmd_logout,
+        "status":     cmd_status,
+        "me":         cmd_me,
+        "emails":     cmd_emails,
+        "calendar":   cmd_calendar,
+        "sharepoint": cmd_sharepoint,
+        "teams":      cmd_teams,
+        "onedrive":   cmd_onedrive,
+        "people":     cmd_people,
+        "org":        cmd_org,
+    }
+
+    try:
+        command_map[args.command](args)
+    except requests.HTTPError as e:
+        status = e.response.status_code
+        if status == 401:
+            print("Error: Authentication expired. Run: python msgraph.py login")
+        elif status == 403:
+            print(f"Error: Permission denied for this operation ({e.response.url})")
+            print("You may need additional OAuth scopes.")
+        elif status == 404:
+            print(f"Error: Resource not found ({e.response.url})")
+        else:
+            print(f"HTTP Error {status}: {e.response.text[:200]}")
+        sys.exit(1)
+    except KeyboardInterrupt:
+        print("\nCancelled.")
+        sys.exit(0)
+
+if __name__ == "__main__":
+    main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemieai/code",
-  "version": "0.0.46",
+  "version": "0.0.47",
   "description": "Unified AI coding assistant CLI - Manage Claude Code, Gemini & custom agents. Multi-provider support (OpenAI, Azure, LiteLLM, SSO). Built-in LangGraph agent with file operations & git integration.",
   "type": "module",
   "main": "dist/index.js",