@bobfrankston/gcards 0.1.16 → 0.1.18

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

@@ -13,7 +13,7 @@ import { authenticateOAuth } from '../../../projects/oauth/oauthsupport/index.ts
 import type { GooglePerson, GoogleConnectionsResponse } from './glib/types.ts';
 import { GCARDS_GUID_KEY, extractGuids } from './glib/gctypes.ts';
 import type { ContactIndex, IndexEntry, DeletedEntry, DeleteQueue, DeleteQueueEntry, PushStatus, PendingChange, UserPaths } from './glib/gctypes.ts';
-import { DATA_DIR, CREDENTIALS_FILE, loadConfig, saveConfig, getUserPaths, ensureUserDir, loadIndex, normalizeUser, getAllUsers, resolveUser, FileLogger } from './glib/gutils.ts';
+import { DATA_DIR, CREDENTIALS_FILE, loadConfig, saveConfig, getUserPaths, ensureUserDir, loadIndex, normalizeUser, getAllUsers, resolveUser, FileLogger, processProblemsFile } from './glib/gutils.ts';
 import { explainApiError, isAIAvailable, showAISetupHint } from './glib/aihelper.ts';
 
 const PEOPLE_API_BASE = 'https://people.googleapis.com/v1';
@@ -563,6 +563,12 @@ async function findPendingChanges(paths: UserPaths, logger: FileLogger, since?:
         console.log(`Using -since override: ${since}`);
     }
 
+    // Process problems.txt first (applies deletions, fixes, etc.)
+    const problemsResult = processProblemsFile(paths, false);
+    if (problemsResult.deleted > 0 || problemsResult.fixed > 0 || problemsResult.companies > 0) {
+        console.log(`Processed problems.txt: ${problemsResult.deleted} deleted, ${problemsResult.fixed} fixed, ${problemsResult.companies} companies`);
+    }
+
     // Check _delete.json for deletion requests
     const deleteQueue = loadDeleteQueue(paths);
     for (const entry of deleteQueue.entries) {
@@ -629,7 +635,7 @@ async function findPendingChanges(paths: UserPaths, logger: FileLogger, since?:
         const files = fs.readdirSync(paths.toDeleteDir).filter(f => f.endsWith('.json'));
         for (const file of files) {
             const filePath = path.join(paths.toDeleteDir, file);
-            let content: GooglePerson;
+            let content: GooglePerson & { _delete?: string | boolean };
             try {
                 content = JSON.parse(await fp.readFile(filePath, 'utf-8'));
             } catch (e: any) {
@@ -644,7 +650,8 @@ async function findPendingChanges(paths: UserPaths, logger: FileLogger, since?:
                 type: 'delete',
                 resourceName: content.resourceName,
                 displayName,
-                filePath
+                filePath,
+                _delete: content._delete === 'force' ? 'force' : undefined
             });
         }
     }
@@ -975,21 +982,21 @@ async function pushContacts(user: string, options: { yes: boolean; verbose: bool
                 const contactFile = path.join(paths.contactsDir, `${change.resourceName.replace('people/', '')}.json`);
                 const fileToRead = fs.existsSync(contactFile) ? contactFile : change.filePath;
 
-                // Check if contact has a real photo or is starred - skip deletion if so
+                // Read contact to check photo/starred/force status
                 let contactHasPhoto = false;
                 let contactIsStarred = false;
+                let isForced = change._delete === 'force' || index.contacts[change.resourceName]?._delete === 'force';
                 if (fs.existsSync(fileToRead)) {
                     try {
                         const contact = JSON.parse(fs.readFileSync(fileToRead, 'utf-8')) as GooglePerson;
                         contactHasPhoto = hasNonDefaultPhoto(contact);
                         contactIsStarred = isStarred(contact);
+                        if ((contact as any)._delete === 'force') isForced = true;
                     } catch { /* ignore read errors */ }
                 }
 
                 // Determine skip reason (photo takes precedence over starred)
-                // Use * prefix to indicate "skipped, not deleted"
                 // 'force' overrides photo/starred protection
-                const isForced = change._delete === 'force' || index.contacts[change.resourceName]?._delete === 'force';
                 const skipReason = isForced ? null : (contactHasPhoto ? '*photo' : (contactIsStarred ? '*starred' : null));
 
                 if (skipReason) {
@@ -1002,7 +1009,8 @@ async function pushContacts(user: string, options: { yes: boolean; verbose: bool
                     });
                     if (skipReason === '*photo') skippedPhoto++;
                     else if (skipReason === '*starred') skippedStarred++;
-                    console.log(`${ts()} [${String(processed).padStart(5)}/${total}] SKIPPED ${change.displayName} (${skipReason})`);
+                    const fileId = change.resourceName.replace('people/', '');
+                    console.log(`${ts()} [${String(processed).padStart(5)}/${total}] SKIPPED ${change.displayName} (${skipReason}) ${fileId}.json`);
 
                     // Update _delete to show skip reason
                     if (index.contacts[change.resourceName]) {
@@ -1100,11 +1108,53 @@ 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 ; name ; reason ; email
+# 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"
+# Fields: nickname: title: company: suffix: (quote values with spaces, "" to remove)
+# To skip: leave unchanged
+# You can manually add entries to this file
+#
+`;
+        }
+
+        // Add photo/starred entries with email
+        const newEntries = notDeleted.map(nd => {
+            const id = nd.resourceName.replace('people/', '');
+            const reason = nd.reason === '*photo' ? 'has-photo' : 'starred';
+            let email = '';
+            if (nd.filePath && fs.existsSync(nd.filePath)) {
+                try {
+                    const contact = JSON.parse(fs.readFileSync(nd.filePath, 'utf-8'));
+                    email = contact.emailAddresses?.[0]?.value || '';
+                } catch { /* ignore */ }
+            }
+            return `${id}.json ; ${nd.displayName} ; ${reason} ; ${email}`;
+        });
+
+        // Avoid duplicates - check if entry already exists
+        const existingLines = new Set(existingProblems.split('\n').map(l => l.split(';')[0].trim()));
+        const uniqueEntries = newEntries.filter(e => !existingLines.has(e.split(';')[0].trim()));
+
+        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
@@ -1127,6 +1177,8 @@ async function pushContacts(user: string, options: { yes: boolean; verbose: bool
     if (etagErrors.length > 0) {
         console.log(`\n${etagErrors.length} contact(s) had etag conflicts. Run 'gcards sync' to refresh, then retry push.`);
     }
+
+    process.exit(0);
 }
 
 async function main(): Promise<void> {

package/gfix.ts

@@ -14,7 +14,7 @@ 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';
+import { DATA_DIR, resolveUser, getUserPaths, loadIndex, getAllUsers, normalizeUser, matchUsers, processProblemsFile } from './glib/gutils.ts';
 import { mergeContacts as mergeContactData, collectSourcePhotos, type MergeEntry, type PhotoEntry } from './glib/gmerge.ts';
 
 function loadDeleteQueue(paths: UserPaths): DeleteQueue {
@@ -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);
 
@@ -885,20 +925,23 @@ async function runNamesFix(user: string, mode: 'inspect' | 'apply'): Promise<voi
 
             // Note: email-in-name is now handled earlier as DELETE
 
+            // Skip CJK names (Chinese, Japanese, Korean) - they don't use spaces
+            if (/^[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]+$/u.test(name.givenName)) {
+                continue;
+            }
+
             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)`);
+                const email = contact.emailAddresses?.[0]?.value || '';
+                problems.push(`${file} ; ${name.givenName} ; ambiguous ; ${email}`);
                 console.log(`  [SKIP:ambiguous] ${displayName} (${file})`);
                 continue;
             }
@@ -906,7 +949,8 @@ 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`);
+                const email = contact.emailAddresses?.[0]?.value || '';
+                problems.push(`${file} ; ${name.givenName} ; no-last-name ; ${email}`);
                 console.log(`  [SKIP:no-last-name] ${displayName} (${file})`);
                 continue;
             }
@@ -1052,10 +1096,20 @@ 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 ; name ; reason ; email
+# 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"
+# Fields: nickname: title: company: suffix: (quote values with spaces, "" to remove)
+# To skip: leave unchanged
+# You can manually add entries to this file
+#
+`;
+        fs.writeFileSync(problemsPath, header + problems.join('\n'));
         console.log(`\nProblems file: ${problemsPath}`);
     }
 
@@ -1115,6 +1169,35 @@ 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);
+    }
+
+    console.log(`\nProcessing problems.txt for user: ${user}\n`);
+
+    const result = processProblemsFile(paths);
+
+    console.log(`\n${'='.repeat(50)}`);
+    console.log(`Summary:`);
+    console.log(`  Fixed: ${result.fixed}`);
+    console.log(`  Companies: ${result.companies}`);
+    console.log(`  Deleted: ${result.deleted}`);
+    console.log(`  Skipped: ${result.skipped}`);
+
+    if (result.fixed > 0 || result.deleted > 0 || result.companies > 0) {
+        console.log(`\nRun 'gcards push -u ${user}' to apply changes to Google.`);
+    }
+
+    process.exit(0);
+}
+
 async function runFix(user: string, mode: 'inspect' | 'apply'): Promise<void> {
     const paths = getUserPaths(user);
 
@@ -1896,6 +1979,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 +2010,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 +2130,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

@@ -197,3 +197,259 @@ export class FileLogger {
         fs.appendFileSync(this.filePath, message + '\n');
     }
 }
+
+export interface ProblemsResult {
+    deleted: number;
+    fixed: number;
+    companies: number;
+    skipped: number;
+    remaining: string[];  // Lines that weren't processed (unchanged)
+}
+
+/**
+ * Process problems.txt file - apply deletions, company marks, name fixes, field updates
+ * Returns counts and remaining unprocessed lines
+ */
+export function processProblemsFile(paths: UserPaths, verbose = true): ProblemsResult {
+    const problemsPath = path.join(paths.userDir, 'problems.txt');
+    const result: ProblemsResult = { deleted: 0, fixed: 0, companies: 0, skipped: 0, remaining: [] };
+
+    if (!fs.existsSync(problemsPath)) {
+        return result;
+    }
+
+    const content = fs.readFileSync(problemsPath, 'utf-8');
+    const lines = content.split(/\r?\n/);
+    const headerLines: string[] = [];
+
+    if (!fs.existsSync(paths.toDeleteDir)) {
+        fs.mkdirSync(paths.toDeleteDir, { recursive: true });
+    }
+
+    for (const line of lines) {
+        // Preserve comments and blank lines for remaining file
+        if (!line.trim() || line.startsWith('#')) {
+            headerLines.push(line);
+            continue;
+        }
+
+        // Check for deletion marker (x or x<space> at start)
+        const deleteMatch = line.match(/^x\s*(.*)/i);
+        if (deleteMatch) {
+            const rest = deleteMatch[1];
+            const parts = rest.split(';');
+            const file = parts[0]?.trim();
+            if (!file) {
+                if (verbose) console.log(`  [SKIP] Can't parse: ${line.slice(0, 50)}`);
+                result.skipped++;
+                continue;
+            }
+
+            const srcPath = path.join(paths.contactsDir, file);
+            if (!fs.existsSync(srcPath)) {
+                result.skipped++;
+                continue;
+            }
+
+            // Mark with _delete: 'force' to override photo/starred protection
+            const contact = parseJsonc(fs.readFileSync(srcPath, 'utf-8'));
+            (contact as any)._delete = 'force';
+            fs.writeFileSync(srcPath, JSON.stringify(contact, null, 2));
+
+            const dstPath = path.join(paths.toDeleteDir, file);
+            fs.renameSync(srcPath, dstPath);
+            if (verbose) console.log(`  [DELETE] ${file}`);
+            result.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(';');
+            const file = parts[0]?.trim();
+            const origName = parts[1]?.trim() || '';
+            if (!file) {
+                if (verbose) console.log(`  [SKIP] Can't parse: ${line.slice(0, 50)}`);
+                result.skipped++;
+                continue;
+            }
+
+            const filePath = path.join(paths.contactsDir, file);
+            if (!fs.existsSync(filePath)) {
+                result.skipped++;
+                continue;
+            }
+
+            const contact = parseJsonc(fs.readFileSync(filePath, 'utf-8')) as any;
+            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));
+            if (verbose) console.log(`  [COMPANY] ${file}: ${companyName}`);
+            result.companies++;
+            continue;
+        }
+
+        // Parse as semicolon-separated: filename ; name ; reason ; email
+        const parts = line.split(';');
+        if (parts.length < 2) {
+            result.remaining.push(line);
+            result.skipped++;
+            continue;
+        }
+
+        const file = parts[0].trim();
+        const fieldsPart = parts[1].trim();
+
+        // Check if anything was changed (original starts with quote)
+        if (fieldsPart.startsWith('"')) {
+            result.remaining.push(line);
+            result.skipped++;
+            continue;
+        }
+
+        const filePath = path.join(paths.contactsDir, file);
+        if (!fs.existsSync(filePath)) {
+            result.skipped++;
+            continue;
+        }
+
+        const contact = parseJsonc(fs.readFileSync(filePath, 'utf-8')) as any;
+
+        // Parse field:value pairs and name
+        const fieldRegex = /(\w+):(?:"([^"]+)"|(\S+))/g;
+        const fields: Record<string, string> = {};
+        let remaining = fieldsPart;
+
+        let match: RegExpExecArray | null;
+        while ((match = fieldRegex.exec(fieldsPart)) !== null) {
+            const fieldName = match[1].toLowerCase();
+            const value = match[2] ?? match[3];  // quoted or unquoted
+            fields[fieldName] = value;
+            remaining = remaining.replace(match[0], '').trim();
+        }
+
+        const changes: string[] = [];
+
+        // Apply field updates (empty string "" means remove)
+        if ('nickname' in fields) {
+            if (fields.nickname === '') {
+                delete contact.nicknames;
+                changes.push(`nickname:[removed]`);
+            } else {
+                if (!contact.nicknames) contact.nicknames = [];
+                if (contact.nicknames.length === 0) {
+                    contact.nicknames.push({ value: fields.nickname });
+                } else {
+                    contact.nicknames[0].value = fields.nickname;
+                }
+                changes.push(`nickname:${fields.nickname}`);
+            }
+        }
+
+        if ('title' in fields) {
+            if (fields.title === '') {
+                if (contact.organizations?.[0]) delete contact.organizations[0].title;
+                changes.push(`title:[removed]`);
+            } else {
+                if (!contact.organizations) contact.organizations = [];
+                if (contact.organizations.length === 0) {
+                    contact.organizations.push({ title: fields.title });
+                } else {
+                    contact.organizations[0].title = fields.title;
+                }
+                changes.push(`title:${fields.title}`);
+            }
+        }
+
+        if ('company' in fields) {
+            if (fields.company === '') {
+                if (contact.organizations?.[0]) delete contact.organizations[0].name;
+                changes.push(`company:[removed]`);
+            } else {
+                if (!contact.organizations) contact.organizations = [];
+                if (contact.organizations.length === 0) {
+                    contact.organizations.push({ name: fields.company });
+                } else {
+                    contact.organizations[0].name = fields.company;
+                }
+                changes.push(`company:${fields.company}`);
+            }
+        }
+
+        if ('suffix' in fields) {
+            if (fields.suffix === '') {
+                if (contact.names?.[0]) delete contact.names[0].honorificSuffix;
+                changes.push(`suffix:[removed]`);
+            } else {
+                if (!contact.names) contact.names = [{}];
+                contact.names[0].honorificSuffix = fields.suffix;
+                changes.push(`suffix:${fields.suffix}`);
+            }
+        }
+
+        // Parse name from remaining text
+        const newName = remaining.trim();
+        if (newName) {
+            const name = contact.names?.[0];
+            if (name) {
+                const nameMatch = newName.match(/^(\S+)(?:\s+\[([^\]]+)\])?\s+(.+)$/);
+                if (!nameMatch) {
+                    const simpleParts = newName.split(/\s+/);
+                    if (simpleParts.length >= 2) {
+                        name.givenName = simpleParts[0];
+                        name.familyName = simpleParts.slice(1).join(' ');
+                        delete name.middleName;
+                        changes.push(`${simpleParts[0]} ${simpleParts.slice(1).join(' ')}`);
+                    }
+                } else {
+                    const [, first, middle, last] = nameMatch;
+                    name.givenName = first;
+                    name.familyName = last;
+                    if (middle) {
+                        name.middleName = middle;
+                    } else {
+                        delete name.middleName;
+                    }
+                    changes.push(`${first}${middle ? ' ' + middle : ''} ${last}`);
+                }
+            }
+        }
+
+        if (changes.length === 0) {
+            result.remaining.push(line);
+            result.skipped++;
+            continue;
+        }
+
+        fs.writeFileSync(filePath, JSON.stringify(contact, null, 2));
+        if (verbose) console.log(`  [FIX] ${file}: ${changes.join(', ')}`);
+        result.fixed++;
+    }
+
+    // Rewrite problems.txt with only remaining unprocessed lines
+    if (result.deleted > 0 || result.fixed > 0 || result.companies > 0) {
+        const newContent = [...headerLines, ...result.remaining].join('\n');
+        fs.writeFileSync(problemsPath, newContent);
+    }
+
+    return result;
+}

package/package.json

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