@bobfrankston/gcards 0.1.5 → 0.1.7

package/.claude/settings.local.json

@@ -21,7 +21,8 @@
       "Bash(npm install:*)",
       "Bash(npx tsx:*)",
       "WebFetch(domain:lh3.googleusercontent.com)",
-      "Bash(curl:*)"
+      "Bash(curl:*)",
+      "Bash(bun build:*)"
     ],
     "deny": [],
     "ask": []

package/README.md

@@ -47,6 +47,8 @@ gfix birthday -u user --apply # Extract to CSV and remove
 
 gfix undup -u user            # Find duplicate contacts -> merger.json
 gfix merge -u user            # Merge duplicates locally (then use gcards push)
+
+gfix export -u source -to target "pattern"  # Export contacts to another user
 ```
 
 ## Google People API Fields
@@ -217,6 +219,27 @@ gcards sync -a
 gcards push -a
 ```
 
+## Exporting Contacts Between Users
+
+Transfer contacts from one user's account to another:
+
+```bash
+gfix export -u bob -to alice "John*"         # Export contacts matching "John*"
+gfix export -u bob -to ali "*@example.com"   # Export by email (partial user match)
+gfix export -u bob -to alice c1234567890     # Export specific contact by ID
+```
+
+**Features:**
+- `-u` source user (partial match supported)
+- `-to` target user (partial match - "ali" matches "alice" if unique)
+- Pattern supports `*` (any chars) and `?` (single char) wildcards
+- Matches on: displayName, givenName, familyName, "Last, First", email
+- Searches both `contacts/` and `deleted/` directories
+- Multiple matches prompt for selection: number(s), `*` for all, `q` to quit
+- Creates cleaned file in target's `_add/` as `x<sourceId>.json`
+
+After export, run `gcards push -u <target>` to upload.
+
 ## Setup
 
 1. Create Google Cloud project

package/gcards.ts

@@ -25,12 +25,19 @@ function ts(): string {
 }
 
 let escapePressed = false;
+let abortController: AbortController | null = null;
 
 function setupEscapeHandler(): void {
+    // Create new abort controller for this operation
+    abortController = new AbortController();
+    
     // Handle Ctrl+C via SIGINT (works without raw mode)
     process.on('SIGINT', () => {
         escapePressed = true;
-        console.log('\n\nCtrl+C pressed - stopping after current operation...');
+        if (abortController) {
+            abortController.abort();
+        }
+        console.log('\n\nCtrl+C pressed - aborting...');
     });
 
     // Handle ESC key via raw mode (optional, for graceful stop)
@@ -40,10 +47,16 @@ function setupEscapeHandler(): void {
         process.stdin.on('data', (key) => {
             if (key[0] === 27) {  // ESC key
                 escapePressed = true;
-                console.log('\n\nESC pressed - stopping after current operation...');
+                if (abortController) {
+                    abortController.abort();
+                }
+                console.log('\n\nESC pressed - aborting...');
             } else if (key[0] === 3) {  // Ctrl+C in raw mode
                 escapePressed = true;
-                console.log('\n\nCtrl+C pressed - stopping after current operation...');
+                if (abortController) {
+                    abortController.abort();
+                }
+                console.log('\n\nCtrl+C pressed - aborting...');
             }
         });
     }
@@ -79,7 +92,9 @@ async function getAccessToken(user: string, writeAccess = false, forceRefresh =
         tokenDirectory: paths.userDir,
         tokenFileName,
         credentialsKey: 'web',
-        includeOfflineAccess: true
+        includeOfflineAccess: true,
+        prompt: 'select_account',  // Always show account picker for new auth
+        signal: abortController?.signal  // Pass abort signal for immediate cancellation
     });
 
     if (!token) {

package/gfix.ts

@@ -10,9 +10,10 @@
 
 import fs from 'fs';
 import path from 'path';
+import readline from 'readline';
 import type { GooglePerson, GoogleName, GooglePhoneNumber, GoogleEmailAddress, GoogleBirthday } from './glib/types.ts';
 import type { DeleteQueue, DeleteQueueEntry, UserPaths } from './glib/gctypes.ts';
-import { DATA_DIR, resolveUser, getUserPaths, loadIndex } from './glib/gutils.ts';
+import { DATA_DIR, resolveUser, getUserPaths, loadIndex, getAllUsers, normalizeUser } from './glib/gutils.ts';
 import { mergeContacts as mergeContactData, collectSourcePhotos, type MergeEntry, type PhotoEntry } from './glib/gmerge.ts';
 
 function loadDeleteQueue(paths: UserPaths): DeleteQueue {
@@ -1405,6 +1406,321 @@ async function runMerge(user: string, limit: number): Promise<void> {
     console.log(`\nRun 'gcards push -u ${user}' to apply changes to Google.`);
 }
 
+// ============================================================
+// Export Feature - Transfer contacts between users
+// ============================================================
+
+interface ContactMatch {
+    id: string;  /** JSON file id (without .json) */
+    displayName: string;
+    emails: string[];
+    filePath: string;
+    source: 'contacts' | 'deleted';
+}
+
+/** Find a contact by ID in contacts or deleted directories */
+function findContactById(paths: UserPaths, id: string): { contact: GooglePerson; filePath: string; source: 'contacts' | 'deleted' } {
+    const cleanId = id.replace(/\.json$/i, '');
+
+    // Check contacts directory
+    const contactPath = path.join(paths.contactsDir, `${cleanId}.json`);
+    if (fs.existsSync(contactPath)) {
+        return {
+            contact: JSON.parse(fs.readFileSync(contactPath, 'utf-8')),
+            filePath: contactPath,
+            source: 'contacts'
+        };
+    }
+
+    // Check deleted directory
+    const deletedPath = path.join(paths.deletedDir, `${cleanId}.json`);
+    if (fs.existsSync(deletedPath)) {
+        return {
+            contact: JSON.parse(fs.readFileSync(deletedPath, 'utf-8')),
+            filePath: deletedPath,
+            source: 'deleted'
+        };
+    }
+
+    return null;
+}
+
+/** Match users by partial name - returns matching user names */
+function matchUsers(pattern: string): string[] {
+    const allUsers = getAllUsers();
+    const normalizedPattern = pattern.toLowerCase();
+
+    return allUsers.filter(user => user.toLowerCase().includes(normalizedPattern));
+}
+
+/** Convert wildcard pattern to regex (supports * and ?) */
+function wildcardToRegex(pattern: string): RegExp {
+    const escaped = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')  // Escape special regex chars
+        .replace(/\*/g, '.*')                   // * matches anything
+        .replace(/\?/g, '.');                   // ? matches single char
+    return new RegExp(`^${escaped}$`, 'i');
+}
+
+/** Search contacts by name or email pattern */
+function searchContacts(paths: UserPaths, pattern: string): ContactMatch[] {
+    const regex = wildcardToRegex(pattern);
+    const matches: ContactMatch[] = [];
+
+    // Search in contacts directory
+    if (fs.existsSync(paths.contactsDir)) {
+        for (const file of fs.readdirSync(paths.contactsDir).filter(f => f.endsWith('.json'))) {
+            const filePath = path.join(paths.contactsDir, file);
+            const contact = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
+            if (matchesContact(contact, regex)) {
+                matches.push({
+                    id: file.replace(/\.json$/, ''),
+                    displayName: getContactDisplayName(contact),
+                    emails: (contact.emailAddresses || []).map(e => e.value).filter(Boolean) as string[],
+                    filePath,
+                    source: 'contacts'
+                });
+            }
+        }
+    }
+
+    // Search in deleted directory
+    if (fs.existsSync(paths.deletedDir)) {
+        for (const file of fs.readdirSync(paths.deletedDir).filter(f => f.endsWith('.json'))) {
+            const filePath = path.join(paths.deletedDir, file);
+            const contact = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
+            if (matchesContact(contact, regex)) {
+                matches.push({
+                    id: file.replace(/\.json$/, ''),
+                    displayName: getContactDisplayName(contact),
+                    emails: (contact.emailAddresses || []).map(e => e.value).filter(Boolean) as string[],
+                    filePath,
+                    source: 'deleted'
+                });
+            }
+        }
+    }
+
+    return matches;
+}
+
+/** Check if contact matches regex on name or email */
+function matchesContact(contact: GooglePerson, regex: RegExp): boolean {
+    // Check display name
+    const name = contact.names?.[0];
+    if (name) {
+        if (regex.test(name.displayName || '')) return true;
+        if (regex.test(name.givenName || '')) return true;
+        if (regex.test(name.familyName || '')) return true;
+        // "Last, First" format
+        if (name.givenName && name.familyName) {
+            if (regex.test(`${name.familyName}, ${name.givenName}`)) return true;
+            if (regex.test(`${name.givenName} ${name.familyName}`)) return true;
+        }
+        if (regex.test(name.displayNameLastFirst || '')) return true;
+    }
+
+    // Check emails
+    for (const email of contact.emailAddresses || []) {
+        if (regex.test(email.value || '')) return true;
+    }
+
+    return false;
+}
+
+/** Get display name for a contact */
+function getContactDisplayName(contact: GooglePerson): string {
+    const name = contact.names?.[0];
+    return name?.displayName || name?.givenName || name?.familyName || 'Unknown';
+}
+
+/** Clean contact for export - remove Google-specific metadata */
+function cleanContactForExport(contact: GooglePerson): GooglePerson {
+    const cleaned = { ...contact };
+
+    // Remove resource-specific fields that will be regenerated
+    delete cleaned.resourceName;
+    delete cleaned.etag;
+    delete (cleaned as any)._delete;
+    delete (cleaned as any)._deleted;
+
+    // Remove metadata that links to source account
+    if (cleaned.metadata) {
+        delete cleaned.metadata.sources;
+        delete cleaned.metadata.previousResourceNames;
+        delete cleaned.metadata.linkedPeopleResourceNames;
+    }
+
+    // Clean field metadata (source references)
+    const cleanFieldMetadata = (items: any[]) => {
+        if (!items) return;
+        for (const item of items) {
+            if (item.metadata) {
+                delete item.metadata.source;
+            }
+        }
+    };
+
+    cleanFieldMetadata(cleaned.names);
+    cleanFieldMetadata(cleaned.emailAddresses);
+    cleanFieldMetadata(cleaned.phoneNumbers);
+    cleanFieldMetadata(cleaned.addresses);
+    cleanFieldMetadata(cleaned.organizations);
+    cleanFieldMetadata(cleaned.urls);
+    cleanFieldMetadata(cleaned.biographies);
+    cleanFieldMetadata(cleaned.photos);
+    cleanFieldMetadata(cleaned.birthdays);
+    cleanFieldMetadata(cleaned.relations);
+    cleanFieldMetadata(cleaned.events);
+    cleanFieldMetadata(cleaned.memberships);
+    cleanFieldMetadata(cleaned.userDefined);
+
+    return cleaned;
+}
+
+/** Prompt user for selection when multiple matches */
+async function promptSelection(matches: ContactMatch[]): Promise<string[]> {
+    console.log('\nMultiple contacts found:');
+    for (let i = 0; i < matches.length; i++) {
+        const m = matches[i];
+        const emailStr = m.emails.length > 0 ? ` <${m.emails[0]}>` : '';
+        const srcStr = m.source === 'deleted' ? ' [deleted]' : '';
+        console.log(`  ${i + 1}. ${m.displayName}${emailStr}${srcStr} (${m.id})`);
+    }
+    console.log('\nEnter selection: number(s) separated by commas, * for all, or q to quit');
+
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+    return new Promise((resolve) => {
+        rl.question('> ', (answer) => {
+            rl.close();
+            const trimmed = answer.trim().toLowerCase();
+
+            if (trimmed === 'q' || trimmed === '') {
+                resolve([]);
+                return;
+            }
+
+            if (trimmed === '*') {
+                resolve(matches.map(m => m.id));
+                return;
+            }
+
+            // Parse comma-separated numbers
+            const selected: string[] = [];
+            for (const part of trimmed.split(',')) {
+                const num = parseInt(part.trim(), 10);
+                if (num >= 1 && num <= matches.length) {
+                    selected.push(matches[num - 1].id);
+                }
+            }
+            resolve(selected);
+        });
+    });
+}
+
+/** Export contacts from source user to target user */
+async function runExport(sourceUser: string, targetPattern: string, contactPattern: string): Promise<void> {
+    // Resolve target user by partial match
+    const targetMatches = matchUsers(targetPattern);
+
+    if (targetMatches.length === 0) {
+        console.error(`No users match pattern: ${targetPattern}`);
+        console.error(`Available users: ${getAllUsers().join(', ')}`);
+        process.exit(1);
+    }
+
+    if (targetMatches.length > 1) {
+        console.error(`Multiple users match pattern "${targetPattern}":`);
+        for (const u of targetMatches) {
+            console.error(`  - ${u}`);
+        }
+        console.error('Please be more specific.');
+        process.exit(1);
+    }
+
+    const targetUser = targetMatches[0];
+
+    if (normalizeUser(sourceUser) === normalizeUser(targetUser)) {
+        console.error('Source and target users cannot be the same.');
+        process.exit(1);
+    }
+
+    const sourcePaths = getUserPaths(sourceUser);
+    const targetPaths = getUserPaths(targetUser);
+
+    // Ensure target _add directory exists
+    if (!fs.existsSync(targetPaths.toAddDir)) {
+        fs.mkdirSync(targetPaths.toAddDir, { recursive: true });
+    }
+
+    // Find contacts to export
+    let contactIds: string[] = [];
+
+    // Check if contactPattern looks like an ID (alphanumeric, possibly with .json)
+    const cleanPattern = contactPattern.replace(/\.json$/i, '');
+    const found = findContactById(sourcePaths, cleanPattern);
+
+    if (found) {
+        // Direct ID match
+        contactIds = [cleanPattern];
+    } else {
+        // Search by name/email pattern
+        const matches = searchContacts(sourcePaths, contactPattern);
+
+        if (matches.length === 0) {
+            console.error(`No contacts match pattern: ${contactPattern}`);
+            process.exit(1);
+        }
+
+        if (matches.length === 1) {
+            contactIds = [matches[0].id];
+        } else {
+            contactIds = await promptSelection(matches);
+            if (contactIds.length === 0) {
+                console.log('No contacts selected.');
+                return;
+            }
+        }
+    }
+
+    // Export each selected contact
+    let exported = 0;
+    for (const id of contactIds) {
+        const result = findContactById(sourcePaths, id);
+        if (!result) {
+            console.error(`Contact not found: ${id}`);
+            continue;
+        }
+
+        const { contact, source } = result;
+        const displayName = getContactDisplayName(contact);
+
+        // Clean the contact for export
+        const cleaned = cleanContactForExport(contact);
+
+        // Generate unique filename: x<sourceId>.json
+        const exportFileName = `x${id}.json`;
+        const exportPath = path.join(targetPaths.toAddDir, exportFileName);
+
+        // Check for existing file
+        if (fs.existsSync(exportPath)) {
+            console.log(`  [SKIP] ${displayName} - already exists: ${exportFileName}`);
+            continue;
+        }
+
+        fs.writeFileSync(exportPath, JSON.stringify(cleaned, null, 2));
+        console.log(`  ${displayName} -> ${targetUser}/_add/${exportFileName}${source === 'deleted' ? ' [from deleted]' : ''}`);
+        exported++;
+    }
+
+    console.log(`\n${'='.repeat(50)}`);
+    console.log(`Exported: ${exported} contact(s) to ${targetUser}/_add/`);
+    if (exported > 0) {
+        console.log(`\nTo upload, run: gcards push -u ${targetUser}`);
+    }
+}
+
 /** Reset ALL delete markers: index.json, contact files, _delete.json, _delete/ folder */
 async function runReset(user: string): Promise<void> {
     const paths = getUserPaths(user);
@@ -1486,9 +1802,11 @@ Commands:
     undup       Find duplicate contacts (same name + overlapping email) -> merger.json
     merge       Merge duplicates locally (then use gcards push)
     reset       Clear all _delete flags from index.json
+    export      Transfer contact(s) to another user's _add directory
 
 Options:
-    -u, --user <name>   User profile to process
+    -u, --user <name>   User profile to process (source for export)
+    -to <user>          Target user for export (partial match OK)
     --apply             For birthday/fileas/names: actually apply changes
     -limit <n>          Process only first n contacts (for testing)
 
@@ -1518,6 +1836,16 @@ Duplicate detection and merge:
   - gcards push -u bob             # Push changes to Google
   - gcards sync -u bob --full      # Resync to get updated contacts
 
+Export contacts to another user:
+  - gfix export -u bob -to alice "John*"         # Export contacts matching "John*" to alice
+  - gfix export -u bob -to ali "*@example.com"   # Export by email pattern (ali matches alice)
+  - gfix export -u bob -to alice c1234567890     # Export by contact ID (with or without .json)
+  - Pattern supports * (any chars) and ? (single char) wildcards
+  - Matches on: displayName, givenName, familyName, "Last, First", email
+  - Searches both contacts/ and deleted/ directories
+  - Multiple matches prompt for selection: number(s), * for all, q to quit
+  - Creates cleaned file in target's _add/ directory as x<sourceId>.json
+
 Workflow:
   1. gfix inspect -u bob     # Review proposed changes
   2. gfix apply -u bob       # Apply changes to local files
@@ -1533,18 +1861,26 @@ async function main(): Promise<void> {
 
     let command = '';
     let user = '';
+    let targetUser = '';
     let applyFlag = false;
+    const positionalArgs: string[] = [];
 
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         if ((arg === '-u' || arg === '--user' || arg === '-user') && i + 1 < args.length) {
             user = args[++i];
+        } else if ((arg === '-to' || arg === '--to') && i + 1 < args.length) {
+            targetUser = args[++i];
         } else if (arg === '--apply') {
             applyFlag = true;
         } else if ((arg === '-limit' || arg === '--limit') && i + 1 < args.length) {
             processLimit = parseInt(args[++i], 10) || 0;
-        } else if (!arg.startsWith('-') && !command) {
-            command = arg;
+        } else if (!arg.startsWith('-')) {
+            if (!command) {
+                command = arg;
+            } else {
+                positionalArgs.push(arg);
+            }
         }
     }
 
@@ -1553,6 +1889,26 @@ async function main(): Promise<void> {
         return;
     }
 
+    // Export command has different argument handling
+    if (command === 'export') {
+        if (!user) {
+            console.error('Export requires -u <sourceUser>');
+            process.exit(1);
+        }
+        if (!targetUser) {
+            console.error('Export requires -to <targetUser>');
+            process.exit(1);
+        }
+        if (positionalArgs.length === 0) {
+            console.error('Export requires a contact pattern or ID');
+            console.error('Usage: gfix export -u <source> -to <target> <pattern>');
+            process.exit(1);
+        }
+        const resolvedSource = resolveUser(user);
+        await runExport(resolvedSource, targetUser, positionalArgs[0]);
+        return;
+    }
+
     const resolvedUser = resolveUser(user);
 
     if (processLimit > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/gcards",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Google Contacts cleanup and management tool",
   "type": "module",
   "main": "gcards.ts",