@bobfrankston/gcards 0.1.15 → 0.1.16

package/gcards.ts

@@ -79,6 +79,7 @@ function cleanupEscapeHandler(): void {
         process.stdin.pause();
         process.stdin.removeAllListeners('data');
     }
+    process.stdin.unref();  // Allow Node to exit even if stdin is open
 }
 
 async function getAccessToken(user: string, writeAccess = false, forceRefresh = false): Promise<string> {
@@ -257,7 +258,14 @@ function saveSyncToken(paths: UserPaths, token: string): void {
 }
 
 async function sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return new Promise(resolve => {
+        const timeout = setTimeout(resolve, ms);
+        // Allow escape to interrupt sleep
+        if (escapePressed) {
+            clearTimeout(timeout);
+            resolve();
+        }
+    });
 }
 
 async function fetchContactsWithRetry(
@@ -1053,6 +1061,12 @@ async function pushContacts(user: string, options: { yes: boolean; verbose: bool
             problems.push(errorMsg);
             errorCount++;
 
+            // Check for etag mismatch - needs resync
+            if (error.message?.includes('FAILED_PRECONDITION') || error.message?.includes('etag')) {
+                console.log(`    → Contact changed on Google. Run 'gcards sync' then retry.`);
+                continue;
+            }
+
             // Get AI explanation if available and error is from API
             if (error instanceof ApiError && error.payload) {
                 if (isAIAvailable()) {
@@ -1107,6 +1121,12 @@ async function pushContacts(user: string, options: { yes: boolean; verbose: bool
     const skipped = skippedPhoto + skippedStarred;
     const skippedDetails = skipped > 0 ? ` (${skippedPhoto} photo, ${skippedStarred} starred)` : '';
     console.log(`\nPush complete: ${successCount} succeeded, ${errorCount} failed, ${skipped} skipped${skippedDetails}`);
+
+    // Check if any errors were etag related
+    const etagErrors = problems.filter(p => p.includes('FAILED_PRECONDITION') || p.includes('etag'));
+    if (etagErrors.length > 0) {
+        console.log(`\n${etagErrors.length} contact(s) had etag conflicts. Run 'gcards sync' to refresh, then retry push.`);
+    }
 }
 
 async function main(): Promise<void> {

package/gfix.ts

@@ -11,6 +11,7 @@
 import fs from 'fs';
 import path from 'path';
 import readline from 'readline';
+import { parse as parseJsonc } from 'jsonc-parser';
 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, getAllUsers, normalizeUser, matchUsers } from './glib/gutils.ts';
@@ -752,6 +753,29 @@ function looksLikePhone(s: string): boolean {
     return digits.length >= 7 && digits.length <= 15 && /^[\d\s\-.()+]+$/.test(s);
 }
 
+/** Fix repeated words in a string - returns cleaned string or null if no fix needed */
+function fixRepeatedWords(s: string): string | null {
+    const words = s.split(/\s+/);
+    if (words.length < 3) return null;
+
+    // Count consecutive repeated words
+    const seen = new Set<string>();
+    const result: string[] = [];
+    for (const word of words) {
+        const lower = word.toLowerCase().replace(/[.,]+$/, ''); // normalize
+        if (!seen.has(lower)) {
+            seen.add(lower);
+            result.push(word.replace(/[.]+$/, '')); // remove trailing dots
+        }
+    }
+
+    // Only return if we actually removed something
+    if (result.length < words.length) {
+        return result.join(' ').trim();
+    }
+    return null;
+}
+
 /** Fix names: parse givenName into first/middle/last, clean fileAs, handle nameless contacts */
 async function runNamesFix(user: string, mode: 'inspect' | 'apply'): Promise<void> {
     const paths = getUserPaths(user);
@@ -773,6 +797,7 @@ async function runNamesFix(user: string, mode: 'inspect' | 'apply'): Promise<voi
 
     const changeLogs: NameChangeLog[] = [];
     const problems: string[] = [];
+    const needsAction: { file: string; displayName: string; reason: string }[] = [];
     let contactsModified = 0;
 
     // Track nameless contacts for deletion
@@ -780,25 +805,51 @@ async function runNamesFix(user: string, mode: 'inspect' | 'apply'): Promise<voi
     const phoneOnly: { file: string; resourceName: string; phone: string }[] = [];
     const emailOnlyFile = path.join(paths.userDir, 'emailonly.json');
     const phoneOnlyFile = path.join(paths.userDir, 'phoneonly.json');
+    const needsActionFile = path.join(paths.userDir, 'needsaction.txt');
 
     for (const file of files) {
         const filePath = path.join(paths.contactsDir, file);
-        const contact = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
+        let contact: GooglePerson;
+        try {
+            contact = parseJsonc(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
+        } catch (e: any) {
+            needsAction.push({ file, displayName: '(parse error)', reason: e.message });
+            console.log(`  [NEEDS-ACTION:parse-error] ${file}: ${e.message}`);
+            continue;
+        }
 
         const name = contact.names?.[0];
 
-        // Handle contacts with no names or phone-as-name
+        // Handle contacts with no names -> DELETE
         if (!name || !name.givenName) {
-            const email = contact.emailAddresses?.[0]?.value || '(no email)';
-            emailOnly.push({ file, resourceName: contact.resourceName, email });
-            console.log(`  [EMAIL-ONLY] ${file}: ${email}`);
+            const email = contact.emailAddresses?.[0]?.value;
+            const phone = contact.phoneNumbers?.[0]?.value;
+            if (email) {
+                emailOnly.push({ file, resourceName: contact.resourceName, email });
+                console.log(`  [DELETE:email-only] ${email} (${file})`);
+            } else if (phone) {
+                phoneOnly.push({ file, resourceName: contact.resourceName, phone });
+                console.log(`  [DELETE:phone-only] ${phone} (${file})`);
+            } else {
+                emailOnly.push({ file, resourceName: contact.resourceName, email: '(empty contact)' });
+                console.log(`  [DELETE:empty] no name/email/phone (${file})`);
+            }
             continue;
         }
 
-        // Check if name is actually a phone number
+        // Check if name is actually a phone number -> DELETE
         if (looksLikePhone(name.givenName)) {
             phoneOnly.push({ file, resourceName: contact.resourceName, phone: name.givenName });
-            console.log(`  [PHONE-ONLY] ${file}: "${name.givenName}"`);
+            console.log(`  [DELETE:phone-only] "${name.givenName}" (${file})`);
+            continue;
+        }
+
+        // Check if name is actually an email address (including malformed like "foo. bar@x. y. com") -> DELETE
+        const nameNormalized = name.givenName.replace(/\.\s+/g, '.').replace(/\s+\./g, '.');
+        if (nameNormalized.includes('@') && nameNormalized.match(/^[^\s]+@[^\s]+\.[^\s]+$/)) {
+            const cleanEmail = nameNormalized.toLowerCase();
+            emailOnly.push({ file, resourceName: contact.resourceName, email: cleanEmail });
+            console.log(`  [DELETE:email-in-name] "${name.givenName}" -> ${cleanEmail} (${file})`);
             continue;
         }
 
@@ -807,47 +858,32 @@ async function runNamesFix(user: string, mode: 'inspect' | 'apply'): Promise<voi
         let parsedFirst = '';
         let parsedLast = '';
 
-        // Check displayName for corruption (repeated words like "Dr. Dr. Dr. Dr.")
-        const displayName = name.displayName || name.givenName || 'Unknown';
-        const displayWords = displayName.split(/\s+/);
-        if (displayWords.length > 4) {
-            const wordCounts = new Map<string, number>();
-            for (const w of displayWords) {
-                wordCounts.set(w.toLowerCase(), (wordCounts.get(w.toLowerCase()) || 0) + 1);
+        // Fix repeated words in givenName (like "Brian Taraci Taraci Taraci...")
+        const fixedGivenName = fixRepeatedWords(name.givenName);
+        if (fixedGivenName) {
+            changes.push(`givenName: "${name.givenName.slice(0, 40)}..." -> "${fixedGivenName}" (removed repeated words)`);
+            if (mode === 'apply') {
+                name.givenName = fixedGivenName;
+                modified = true;
             }
-            const maxCount = Math.max(...wordCounts.values());
-            if (maxCount > 3) {
-                problems.push(`${file}: repeated words in displayName (${maxCount}x) - corrupted data`);
-                console.log(`  [CORRUPTED] ${displayName.slice(0, 60)}... (${file})`);
-                continue;
+        }
+
+        // Fix repeated words in familyName
+        if (name.familyName) {
+            const fixedFamilyName = fixRepeatedWords(name.familyName);
+            if (fixedFamilyName) {
+                changes.push(`familyName: "${name.familyName.slice(0, 40)}..." -> "${fixedFamilyName}" (removed repeated words)`);
+                if (mode === 'apply') {
+                    name.familyName = fixedFamilyName;
+                    modified = true;
+                }
             }
         }
 
         // If givenName exists but no familyName, parse it
         if (name.givenName && !name.familyName) {
-            // Check for repeated words (corrupted data like "Smith Smith Smith...")
-            const words = name.givenName.split(/\s+/);
-            if (words.length > 4) {
-                const wordCounts = new Map<string, number>();
-                for (const w of words) {
-                    wordCounts.set(w.toLowerCase(), (wordCounts.get(w.toLowerCase()) || 0) + 1);
-                }
-                const maxCount = Math.max(...wordCounts.values());
-                if (maxCount > 3) {
-                    const displayName = name.displayName || name.givenName.slice(0, 50) + '...' || 'Unknown';
-                    problems.push(`${file}: repeated words (${maxCount}x) - corrupted data`);
-                    console.log(`  [CORRUPTED] ${displayName} (${file})`);
-                    continue;
-                }
-            }
 
-            // Check for email addresses
-            if (name.givenName.includes('@')) {
-                const displayName = name.displayName || name.givenName || 'Unknown';
-                problems.push(`${file}: "${name.givenName}" - email address, not a name`);
-                console.log(`  [EMAIL] ${displayName} (${file}): "${name.givenName}"`);
-                continue;
-            }
+            // Note: email-in-name is now handled earlier as DELETE
 
             const parsed = parseFullName(name.givenName);
 
@@ -855,7 +891,7 @@ async function runNamesFix(user: string, mode: 'inspect' | 'apply'): Promise<voi
             if (parsed.isCompany) {
                 const displayName = name.displayName || name.givenName || 'Unknown';
                 problems.push(`${file}: "${name.givenName}" - looks like a company name`);
-                console.log(`  [COMPANY] ${displayName} (${file}): "${name.givenName}"`);
+                console.log(`  [SKIP:company] ${displayName} (${file})`);
                 continue;
             }
 
@@ -863,7 +899,7 @@ async function runNamesFix(user: string, mode: 'inspect' | 'apply'): Promise<voi
             if (parsed.ambiguous) {
                 const displayName = name.displayName || name.givenName || 'Unknown';
                 problems.push(`${file}: "${name.givenName}" - ambiguous (could be "Last, First" or unknown suffix)`);
-                console.log(`  [AMBIGUOUS] ${displayName} (${file}): "${name.givenName}"`);
+                console.log(`  [SKIP:ambiguous] ${displayName} (${file})`);
                 continue;
             }
 
@@ -871,7 +907,7 @@ async function runNamesFix(user: string, mode: 'inspect' | 'apply'): Promise<voi
             if (!parsed.last) {
                 const displayName = name.displayName || name.givenName || 'Unknown';
                 problems.push(`${file}: "${name.givenName}" - no last name detected`);
-                console.log(`  [NO LAST NAME] ${displayName} (${file}): "${name.givenName}"`);
+                console.log(`  [SKIP:no-last-name] ${displayName} (${file})`);
                 continue;
             }
 
@@ -1023,6 +1059,13 @@ async function runNamesFix(user: string, mode: 'inspect' | 'apply'): Promise<voi
         console.log(`\nProblems file: ${problemsPath}`);
     }
 
+    // Write needsaction.txt for manual fixing
+    if (needsAction.length > 0) {
+        const content = needsAction.map(c => `${c.file}\t${c.displayName}\t${c.reason}`).join('\n');
+        fs.writeFileSync(needsActionFile, content);
+        console.log(`\nNeeds action file: ${needsActionFile}`);
+    }
+
     // Handle email-only and phone-only contacts
     if (mode === 'apply' && (emailOnly.length > 0 || phoneOnly.length > 0)) {
         if (!fs.existsSync(paths.toDeleteDir)) {
@@ -1055,13 +1098,14 @@ async function runNamesFix(user: string, mode: 'inspect' | 'apply'): Promise<voi
     console.log(`\n${'='.repeat(50)}`);
     console.log(`Summary:`);
     console.log(`  Contacts with changes: ${changeLogs.length}`);
-    console.log(`  Email-only (no name): ${emailOnly.length}`);
-    console.log(`  Phone-only (phone as name): ${phoneOnly.length}`);
+    console.log(`  To delete (email/phone only): ${emailOnly.length + phoneOnly.length}`);
+    console.log(`  Needs manual action (see needsaction.txt): ${needsAction.length}`);
     console.log(`  Ambiguous (see problems.txt): ${problems.length}`);
     if (mode === 'apply') {
         console.log(`  Contacts modified: ${contactsModified}`);
-        if (emailOnly.length > 0) console.log(`  Email-only moved to _delete/ (recovery: emailonly.json)`);
-        if (phoneOnly.length > 0) console.log(`  Phone-only moved to _delete/ (recovery: phoneonly.json)`);
+        if (emailOnly.length > 0 || phoneOnly.length > 0) {
+            console.log(`  Moved to _delete/: ${emailOnly.length + phoneOnly.length} (recovery: emailonly.json, phoneonly.json)`);
+        }
     }
     if (mode === 'inspect' && (changeLogs.length > 0 || emailOnly.length > 0 || phoneOnly.length > 0)) {
         console.log(`\nTo apply fixes, run: gfix names -u ${user} --apply`);
@@ -1917,26 +1961,42 @@ async function main(): Promise<void> {
     let targetUser = '';
     let applyFlag = false;
     const positionalArgs: string[] = [];
+    const unrecognized: 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('-')) {
-            if (!command) {
-                command = arg;
-            } else {
-                positionalArgs.push(arg);
-            }
+        switch (arg) {
+            case '-u': case '--user': case '-user':
+                user = args[++i] || '';
+                break;
+            case '-to': case '--to':
+                targetUser = args[++i] || '';
+                break;
+            case '--apply':
+                applyFlag = true;
+                break;
+            case '-limit': case '--limit':
+                processLimit = parseInt(args[++i], 10) || 0;
+                break;
+            default:
+                if (!arg.startsWith('-')) {
+                    if (!command) {
+                        command = arg;
+                    } else {
+                        positionalArgs.push(arg);
+                    }
+                } else {
+                    unrecognized.push(arg);
+                }
         }
     }
 
+    if (unrecognized.length > 0) {
+        console.error(`Unrecognized argument(s): ${unrecognized.join(', ')}`);
+        console.error(`Use 'gfix' for usage information.`);
+        process.exit(1);
+    }
+
     if (!command) {
         showUsage();
         return;

package/glib/gutils.ts

@@ -5,6 +5,7 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { parse as parseJsonc } from 'jsonc-parser';
 import type { GcardsConfig, ContactIndex, UserPaths } from './gctypes.ts';
 
 export const APP_DIR = path.dirname(import.meta.dirname);  // Parent of glib/
@@ -34,7 +35,11 @@ export const CREDENTIALS_FILE = path.join(APP_DIR, 'credentials.json');
 
 export function loadConfig(): GcardsConfig {
     if (fs.existsSync(CONFIG_FILE)) {
-        return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+        try {
+            return parseJsonc(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+        } catch (e: any) {
+            throw new Error(`Failed to parse ${CONFIG_FILE}: ${e.message}`);
+        }
     }
     return {};
 }
@@ -76,7 +81,11 @@ export function ensureUserDir(user: string): void {
 
 export function loadIndex(paths: UserPaths): ContactIndex {
     if (fs.existsSync(paths.indexFile)) {
-        return JSON.parse(fs.readFileSync(paths.indexFile, 'utf-8'));
+        try {
+            return parseJsonc(fs.readFileSync(paths.indexFile, 'utf-8'));
+        } catch (e: any) {
+            throw new Error(`Failed to parse ${paths.indexFile}: ${e.message}`);
+        }
     }
     return { contacts: {}, lastSync: '' };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/gcards",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "Google Contacts cleanup and management tool",
   "type": "module",
   "main": "gcards.ts",
@@ -32,6 +32,7 @@
     "tsx": "^4.21.0"
   },
   "dependencies": {
-    "@bobfrankston/miscassists": "file:../../../projects/NodeJS/miscassists"
+    "@bobfrankston/miscassists": "file:../../../projects/NodeJS/miscassists",
+    "jsonc-parser": "^3.3.1"
   }
 }