@bobfrankston/gcards 0.1.15 → 0.1.17

package/README.md

@@ -40,7 +40,8 @@ gfix inspect -u user          # Preview all standard fixes (no changes)
 gfix apply -u user            # Apply all standard fixes
 
 gfix names -u user            # Preview name parsing + dup phone/email removal
-gfix names -u user --apply    # Parse names, remove dup phones/emails
+gfix names -u user --apply    # Parse names, remove dup phones/emails, move email/phone-only to _delete/
+gfix problems -u user         # Process edited problems.txt (x=delete, or replace name)
 
 gfix birthday -u user         # Preview birthday extraction
 gfix birthday -u user --apply # Extract to CSV and remove
@@ -147,10 +148,28 @@ gcards/                   # App directory (%APPDATA%\gcards or ~/.config/gcards)
 
 When a contact has a full name in `givenName` but no `familyName`:
 - Parses "First Middle Last" into separate fields
+- Handles suffixes like Ph.D., M.D., P.E., Jr., III
 - Updates `displayNameLastFirst` to proper "Last, First" format
 - Cleans up `fileAses` entries (strips junk characters)
+- Fixes repeated words (e.g., "John Smith Smith Smith" → "John Smith")
 - Creates `changes.log` with all modifications
 
+Contacts with no real name are moved to `_delete/`:
+- Email-only (no name field)
+- Phone-only (phone number as name)
+- Empty contacts (no name, email, or phone)
+
+Recovery lists saved to `emailonly.json` and `phoneonly.json`.
+
+## Handling Problem Contacts (`gfix problems`)
+
+After `gfix names`, ambiguous contacts are saved to `problems.txt`. Edit this file to fix:
+- Add `x` at start of line to mark for deletion
+- Replace the name with corrected "First Last" format
+- Leave unchanged to skip
+
+Then run `gfix problems -u user` to apply.
+
 ## Workflow
 
 1. **Initial sync**: `gcards sync -u yourname`

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()) {
@@ -1086,11 +1100,44 @@ async function pushContacts(user: string, options: { yes: boolean; verbose: bool
         console.log(`\nErrors written to: ${problemsFile}`);
     }
 
-    // Write notdeleted file if any contacts were skipped due to photos
+    // Write notdeleted file if any contacts were skipped due to photos/starred
+    // Also append to problems.txt so user can decide their fate
     if (notDeleted.length > 0) {
         const notDeletedFile = path.join(paths.userDir, 'notdeleted.json');
         fs.writeFileSync(notDeletedFile, JSON.stringify(notDeleted, null, 2));
-        console.log(`\n${notDeleted.length} contacts with photos not deleted from Google (see notdeleted.json)`);
+        console.log(`\n${notDeleted.length} contacts with photos/starred not deleted from Google (see notdeleted.json)`);
+
+        // Append to problems.txt for user review
+        const problemsPath = path.join(paths.userDir, 'problems.txt');
+        let existingProblems = '';
+        if (fs.existsSync(problemsPath)) {
+            existingProblems = fs.readFileSync(problemsPath, 'utf-8');
+        } else {
+            existingProblems = `# Edit this file then run: gfix problems -u ${user}
+# Format: filename<TAB>name<TAB>reason
+# To delete: add 'x' at start of line
+# To mark as company: add 'c' at start of line (moves name to organization)
+# To fix name: replace the name with "First Last" or "First [Middle] Last"
+# To skip: leave unchanged
+#
+`;
+        }
+
+        // Add photo/starred entries
+        const newEntries = notDeleted.map(nd => {
+            const id = nd.resourceName.replace('people/', '');
+            const reason = nd.reason === '*photo' ? 'has-photo' : 'starred';
+            return `${id}.json\t${nd.displayName}\t${reason}`;
+        });
+
+        // Avoid duplicates - check if entry already exists
+        const existingLines = new Set(existingProblems.split('\n').map(l => l.split('\t')[0]));
+        const uniqueEntries = newEntries.filter(e => !existingLines.has(e.split('\t')[0]));
+
+        if (uniqueEntries.length > 0) {
+            fs.writeFileSync(problemsPath, existingProblems.trimEnd() + '\n' + uniqueEntries.join('\n') + '\n');
+            console.log(`Added ${uniqueEntries.length} photo/starred entries to problems.txt for review`);
+        }
     }
 
     // Remove completed deletions from queue
@@ -1107,6 +1154,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';
@@ -558,16 +559,36 @@ const HONORIFIC_PREFIXES = new Set([
 const NAME_SUFFIXES = new Set([
     // Generational
     'jr', 'jr.', 'sr', 'sr.', 'i', 'ii', 'iii', 'iv', 'v',
-    // Academic
+    // Academic - Doctorates
     'phd', 'ph.d', 'ph.d.', 'md', 'm.d', 'm.d.', 'do', 'd.o', 'd.o.',
     'dds', 'd.d.s', 'd.d.s.', 'dmd', 'd.m.d', 'd.m.d.',
     'jd', 'j.d', 'j.d.', 'llb', 'll.b', 'll.b.', 'llm', 'll.m', 'll.m.',
+    'edd', 'ed.d', 'ed.d.', 'dmin', 'd.min', 'd.min.',
+    'dsc', 'd.sc', 'd.sc.', 'dphil', 'd.phil', 'd.phil.',
+    'psyd', 'psy.d', 'psy.d.', 'dnp', 'd.n.p', 'd.n.p.',
+    'pharmd', 'pharm.d', 'pharm.d.', 'dpt', 'd.p.t', 'd.p.t.',
+    'dvm', 'd.v.m', 'd.v.m.',
+    // Academic - Masters
     'mba', 'm.b.a', 'm.b.a.', 'ma', 'm.a', 'm.a.', 'ms', 'm.s', 'm.s.',
+    'msc', 'm.sc', 'm.sc.', 'med', 'm.ed', 'm.ed.',
+    'mfa', 'm.f.a', 'm.f.a.', 'mph', 'm.p.h', 'm.p.h.',
+    'msw', 'm.s.w', 'm.s.w.', 'meng', 'm.eng', 'm.eng.',
+    // Academic - Bachelors
     'ba', 'b.a', 'b.a.', 'bs', 'b.s', 'b.s.', 'bsc', 'b.sc', 'b.sc.',
-    'edd', 'ed.d', 'ed.d.',
+    'beng', 'b.eng', 'b.eng.', 'bfa', 'b.f.a', 'b.f.a.',
+    // UK/Commonwealth specific
+    'dic', 'd.i.c', 'd.i.c.',  // Diploma of Imperial College
+    'frcs', 'f.r.c.s', 'f.r.c.s.',  // Fellow Royal College of Surgeons
+    'frcp', 'f.r.c.p', 'f.r.c.p.',  // Fellow Royal College of Physicians
+    'frs', 'f.r.s', 'f.r.s.',  // Fellow Royal Society
+    'obe', 'o.b.e', 'o.b.e.',  // Order of British Empire
+    'mbe', 'm.b.e', 'm.b.e.',
+    'cbe', 'c.b.e', 'c.b.e.',
     // Professional certifications
     'cpa', 'c.p.a', 'c.p.a.', 'cfa', 'c.f.a', 'c.f.a.',
     'pe', 'p.e', 'p.e.', 'esq', 'esq.',
+    'ra', 'r.a', 'r.a.',  // Registered Architect
+    'aia', 'a.i.a', 'a.i.a.',  // American Institute of Architects
     'rn', 'r.n', 'r.n.', 'lpn', 'l.p.n', 'l.p.n.',
     'cae', 'c.a.e', 'c.a.e.', 'pmp', 'p.m.p', 'p.m.p.',
     'cissp', 'ccna', 'mcse', 'aws',
@@ -576,6 +597,12 @@ const NAME_SUFFIXES = new Set([
     'sj', 's.j', 's.j.', 'op', 'o.p', 'o.p.', 'osb', 'o.s.b', 'o.s.b.',
 ]);
 
+/** Check if a string looks like a suffix (matches NAME_SUFFIXES patterns) */
+function isSuffix(word: string): boolean {
+    const lower = word.toLowerCase().replace(/[.,]+$/, '');
+    return NAME_SUFFIXES.has(lower) || NAME_SUFFIXES.has(lower.replace(/\./g, ''));
+}
+
 /** Convert ALL CAPS to Title Case, preserve mixed case */
 function fixCase(name: string): string {
     if (!name) return name;
@@ -666,17 +693,20 @@ function parseFullName(fullName: string): ParsedName {
         const beforeComma = namePart.substring(0, commaIndex).trim();
         const afterComma = namePart.substring(commaIndex + 1).trim();
 
-        // Check if after-comma part is a known suffix
-        const afterLower = afterComma.toLowerCase().replace(/\./g, '');
-        if (NAME_SUFFIXES.has(afterLower) || NAME_SUFFIXES.has(afterLower.replace(/\s+/g, ''))) {
+        // Check if after-comma part is a known suffix (or multiple suffixes)
+        // Handle "John Smith, Ph.D., P.E." or "John Smith, Jr."
+        const afterParts = afterComma.split(/,\s*/);
+        const allSuffixes = afterParts.every(p => isSuffix(p.trim()));
+
+        if (allSuffixes) {
             suffix = afterComma;
             namePart = beforeComma;
         } else {
             // Could be "Last, First" format or unknown suffix
             const beforeParts = beforeComma.split(/\s+/);
-            const afterParts = afterComma.split(/\s+/);
+            const afterWords = afterComma.split(/\s+/);
 
-            if (beforeParts.length === 1 && afterParts.length >= 1) {
+            if (beforeParts.length === 1 && afterWords.length >= 1) {
                 // Ambiguous: could be "Smith, John" or "John Smith, UnknownSuffix"
                 ambiguous = true;
             }
@@ -710,6 +740,17 @@ function parseFullName(fullName: string): ParsedName {
         }
     }
 
+    // Check for suffixes at the END of the name (no comma)
+    // E.g., "John Smith Ph.D." or "Mary Jones P.E."
+    // Collect suffixes from the end working backwards
+    const trailingSuffixes: string[] = [];
+    while (rawParts.length > 2 && isSuffix(rawParts[rawParts.length - 1])) {
+        trailingSuffixes.unshift(rawParts.pop()!);
+    }
+    if (trailingSuffixes.length > 0) {
+        suffix = suffix ? suffix + ', ' + trailingSuffixes.join(', ') : trailingSuffixes.join(', ');
+    }
+
     // Now apply case normalization
     const parts = rawParts.map(fixCase);
 
@@ -752,6 +793,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 +837,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 +845,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,71 +898,53 @@ 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);
 
-            // Check for company names first
+            // Company names are fine - skip without adding to problems
             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}"`);
                 continue;
             }
 
             // Check for ambiguous cases
             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}"`);
+                problems.push(`${file}\t${name.givenName}\tambiguous`);
+                console.log(`  [SKIP:ambiguous] ${displayName} (${file})`);
                 continue;
             }
 
             // Check if no parseable last name
             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}"`);
+                problems.push(`${file}\t${name.givenName}\tno-last-name`);
+                console.log(`  [SKIP:no-last-name] ${displayName} (${file})`);
                 continue;
             }
 
@@ -1016,13 +1089,28 @@ async function runNamesFix(user: string, mode: 'inspect' | 'apply'): Promise<voi
         console.log(`\nLog file: ${logPath}`);
     }
 
-    // Write problems.txt for ambiguous cases
+    // Write problems.txt for ambiguous cases (editable format)
     if (problems.length > 0) {
         const problemsPath = path.join(paths.userDir, 'problems.txt');
-        fs.writeFileSync(problemsPath, problems.join('\n'));
+        const header = `# Edit this file then run: gfix problems -u ${user}
+# Format: filename<TAB>name<TAB>reason
+# To delete: add 'x' at start of line
+# To mark as company: add 'c' at start of line (moves name to organization)
+# To fix name: replace the name with "First Last" or "First [Middle] Last"
+# To skip: leave unchanged
+#
+`;
+        fs.writeFileSync(problemsPath, header + problems.join('\n'));
         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 +1143,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`);
@@ -1071,6 +1160,201 @@ async function runNamesFix(user: string, mode: 'inspect' | 'apply'): Promise<voi
     }
 }
 
+/** Process edited problems.txt - apply name fixes or deletions */
+async function runProblems(user: string): Promise<void> {
+    const paths = getUserPaths(user);
+    const problemsPath = path.join(paths.userDir, 'problems.txt');
+
+    if (!fs.existsSync(problemsPath)) {
+        console.error(`No problems.txt found for user: ${user}`);
+        console.error(`Run 'gfix names -u ${user}' first to generate it.`);
+        process.exit(1);
+    }
+
+    const content = fs.readFileSync(problemsPath, 'utf-8');
+    const lines = content.split(/\r?\n/).filter(l => l.trim() && !l.startsWith('#'));
+
+    if (lines.length === 0) {
+        console.log('No entries in problems.txt (or all are comments)');
+        return;
+    }
+
+    console.log(`\nProcessing ${lines.length} entries from problems.txt\n`);
+
+    let deleted = 0;
+    let fixed = 0;
+    let skipped = 0;
+
+    if (!fs.existsSync(paths.toDeleteDir)) {
+        fs.mkdirSync(paths.toDeleteDir, { recursive: true });
+    }
+
+    let companies = 0;
+
+    for (const line of lines) {
+        // Check for deletion marker (x or x<space> at start)
+        // Always force delete (overrides photo/starred protection)
+        const deleteMatch = line.match(/^x\s*(.*)/i);
+        if (deleteMatch) {
+            const rest = deleteMatch[1];
+            const parts = rest.split('\t');
+            const file = parts[0]?.trim();
+            if (!file) {
+                console.log(`  [SKIP] Can't parse: ${line.slice(0, 50)}`);
+                skipped++;
+                continue;
+            }
+
+            const srcPath = path.join(paths.contactsDir, file);
+            if (!fs.existsSync(srcPath)) {
+                console.log(`  [SKIP] File not found: ${file}`);
+                skipped++;
+                continue;
+            }
+
+            // Mark with _delete: 'force' to override photo/starred protection
+            const contact = parseJsonc(fs.readFileSync(srcPath, 'utf-8')) as GooglePerson;
+            (contact as any)._delete = 'force';
+            fs.writeFileSync(srcPath, JSON.stringify(contact, null, 2));
+
+            const dstPath = path.join(paths.toDeleteDir, file);
+            fs.renameSync(srcPath, dstPath);
+            console.log(`  [DELETE] ${file}`);
+            deleted++;
+            continue;
+        }
+
+        // Check for company marker (c or c<space> at start)
+        const companyMatch = line.match(/^c\s*(.*)/i);
+        if (companyMatch) {
+            const rest = companyMatch[1];
+            const parts = rest.split('\t');
+            const file = parts[0]?.trim();
+            const origName = parts[1]?.trim() || '';
+            if (!file) {
+                console.log(`  [SKIP] Can't parse: ${line.slice(0, 50)}`);
+                skipped++;
+                continue;
+            }
+
+            const filePath = path.join(paths.contactsDir, file);
+            if (!fs.existsSync(filePath)) {
+                console.log(`  [SKIP] File not found: ${file}`);
+                skipped++;
+                continue;
+            }
+
+            const contact = parseJsonc(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
+            const name = contact.names?.[0];
+            const companyName = name?.givenName || name?.displayName || origName;
+
+            // Move name to organization
+            if (!contact.organizations) {
+                contact.organizations = [];
+            }
+            if (contact.organizations.length === 0) {
+                contact.organizations.push({ name: companyName });
+            } else if (!contact.organizations[0].name) {
+                contact.organizations[0].name = companyName;
+            }
+
+            // Clear person name fields
+            if (name) {
+                delete name.givenName;
+                delete name.familyName;
+                delete name.middleName;
+                delete name.displayNameLastFirst;
+            }
+
+            fs.writeFileSync(filePath, JSON.stringify(contact, null, 2));
+            console.log(`  [COMPANY] ${file}: ${companyName}`);
+            companies++;
+            continue;
+        }
+
+        // Parse as tab-separated: filename<TAB>name<TAB>reason
+        const parts = line.split('\t');
+        if (parts.length < 2) {
+            skipped++;
+            continue;
+        }
+
+        const file = parts[0].trim();
+        const newName = parts[1].trim();
+        const originalReason = parts[2]?.trim() || '';
+
+        // Check if name was changed (compare with original patterns)
+        // Original format was: "Original Name" so if it doesn't start with quote, it's edited
+        const wasEdited = !newName.startsWith('"');
+
+        if (!wasEdited) {
+            skipped++;
+            continue;
+        }
+
+        // Parse the new name: "First Last" or "First [Middle] Last"
+        const filePath = path.join(paths.contactsDir, file);
+        if (!fs.existsSync(filePath)) {
+            console.log(`  [SKIP] File not found: ${file}`);
+            skipped++;
+            continue;
+        }
+
+        const contact = parseJsonc(fs.readFileSync(filePath, 'utf-8')) as GooglePerson;
+        const name = contact.names?.[0];
+        if (!name) {
+            console.log(`  [SKIP] No name in contact: ${file}`);
+            skipped++;
+            continue;
+        }
+
+        // Parse "First [Middle] Last" format
+        const nameMatch = newName.match(/^(\S+)(?:\s+\[([^\]]+)\])?\s+(.+)$/);
+        if (!nameMatch) {
+            // Try simple "First Last"
+            const simpleParts = newName.split(/\s+/);
+            if (simpleParts.length >= 2) {
+                const first = simpleParts[0];
+                const last = simpleParts.slice(1).join(' ');
+                name.givenName = first;
+                name.familyName = last;
+                delete name.middleName;
+                fs.writeFileSync(filePath, JSON.stringify(contact, null, 2));
+                console.log(`  [FIX] ${file}: ${first} ${last}`);
+                fixed++;
+            } else {
+                console.log(`  [SKIP] Can't parse name: "${newName}"`);
+                skipped++;
+            }
+            continue;
+        }
+
+        const [, first, middle, last] = nameMatch;
+        name.givenName = first;
+        name.familyName = last;
+        if (middle) {
+            name.middleName = middle;
+        } else {
+            delete name.middleName;
+        }
+
+        fs.writeFileSync(filePath, JSON.stringify(contact, null, 2));
+        console.log(`  [FIX] ${file}: ${first}${middle ? ' ' + middle : ''} ${last}`);
+        fixed++;
+    }
+
+    console.log(`\n${'='.repeat(50)}`);
+    console.log(`Summary:`);
+    console.log(`  Fixed: ${fixed}`);
+    console.log(`  Companies: ${companies}`);
+    console.log(`  Deleted: ${deleted}`);
+    console.log(`  Skipped: ${skipped}`);
+
+    if (fixed > 0 || deleted > 0 || companies > 0) {
+        console.log(`\nRun 'gcards push -u ${user}' to apply changes to Google.`);
+    }
+}
+
 async function runFix(user: string, mode: 'inspect' | 'apply'): Promise<void> {
     const paths = getUserPaths(user);
 
@@ -1852,6 +2136,7 @@ Commands:
     birthday    Extract birthdays to CSV and remove from contacts
     fileas      Normalize "Last, First" fileAs to "First Last"
     names       Parse givenName into first/middle/last, clean fileAs, remove dup phones/emails
+    problems    Process edited problems.txt (apply fixes or deletions)
     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
@@ -1882,6 +2167,10 @@ Name parsing (when givenName has full name but no familyName):
   - gfix names -u bob              # Preview name splits
   - gfix names -u bob --apply      # Split names and create changes.log
 
+Processing problem contacts (from gfix names):
+  - Edit problems.txt: add 'x' at start to delete, or replace name with "First Last"
+  - gfix problems -u bob           # Apply fixes from edited problems.txt
+
 Duplicate detection and merge:
   - gfix undup -u bob              # Find duplicates -> merger.json
   - Edit merger.json (remove false positives, add "_delete": true for spam)
@@ -1917,26 +2206,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;
@@ -1982,6 +2287,8 @@ async function main(): Promise<void> {
         await runMerge(resolvedUser, processLimit);
     } else if (command === 'reset') {
         await runReset(resolvedUser);
+    } else if (command === 'problems') {
+        await runProblems(resolvedUser);
     } else {
         console.error(`Unknown command: ${command}`);
         showUsage();

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.17",
   "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"
   }
 }