@bobfrankston/gcards 0.1.16 → 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

@@ -1100,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

package/gfix.ts

@@ -559,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',
@@ -577,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;
@@ -667,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;
             }
@@ -711,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);
 
@@ -887,18 +927,15 @@ async function runNamesFix(user: string, mode: 'inspect' | 'apply'): Promise<voi
 
             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(`  [SKIP:company] ${displayName} (${file})`);
                 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)`);
+                problems.push(`${file}\t${name.givenName}\tambiguous`);
                 console.log(`  [SKIP:ambiguous] ${displayName} (${file})`);
                 continue;
             }
@@ -906,7 +943,7 @@ async function runNamesFix(user: string, mode: 'inspect' | 'apply'): Promise<voi
             // 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`);
+                problems.push(`${file}\t${name.givenName}\tno-last-name`);
                 console.log(`  [SKIP:no-last-name] ${displayName} (${file})`);
                 continue;
             }
@@ -1052,10 +1089,18 @@ 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}`);
     }
 
@@ -1115,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);
 
@@ -1896,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
@@ -1926,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)
@@ -2042,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/package.json

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