get-claudia 1.51.6 → 1.51.8

package/bin/index.js

@@ -341,11 +341,67 @@ async function restartOllama() {
   return startOllama();
 }
 
+// ─── Self-update trampoline ──────────────────────────────────────────────
+// npx aggressively caches packages. If the user runs `npx get-claudia .`
+// and a newer version exists, we re-exec with the latest to avoid stale installs.
+
+function isNewerVersion(latest, current) {
+  const a = latest.split('.').map(Number);
+  const b = current.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((a[i] || 0) > (b[i] || 0)) return true;
+    if ((a[i] || 0) < (b[i] || 0)) return false;
+  }
+  return false;
+}
+
+async function checkForNewerVersion(currentVersion) {
+  // Skip if already re-execing (prevent infinite recursion)
+  if (process.env.CLAUDIA_SKIP_UPDATE_CHECK) return null;
+  // Skip for --help / --version (no need to update-check)
+  if (process.argv.includes('--help') || process.argv.includes('-h') || process.argv.includes('--version')) return null;
+
+  try {
+    const resp = await fetch('https://registry.npmjs.org/get-claudia/latest', {
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!resp.ok) return null;
+    const data = await resp.json();
+    const latest = data.version;
+    if (latest && isNewerVersion(latest, currentVersion)) return latest;
+  } catch {
+    // Network error or timeout: proceed with current version
+  }
+  return null;
+}
+
 // ─── Main ───────────────────────────────────────────────────────────────
 
 async function main() {
   const version = getVersion();
 
+  // Self-update trampoline: re-exec with latest if we're stale
+  const newerVersion = await checkForNewerVersion(version);
+  if (newerVersion) {
+    process.stdout.write(`\n ${colors.yellow}→${colors.reset} v${newerVersion} available (running v${version}). Updating...\n\n`);
+    const npxCmd = isWindows ? 'npx.cmd' : 'npx';
+    try {
+      const child = spawn(npxCmd, ['--yes', `get-claudia@${newerVersion}`, ...process.argv.slice(2)], {
+        stdio: 'inherit',
+        env: { ...process.env, CLAUDIA_SKIP_UPDATE_CHECK: '1' },
+      });
+      await new Promise((resolve, reject) => {
+        child.on('close', (code) => resolve(code));
+        child.on('error', reject);
+      }).then((code) => {
+        process.exit(code || 0);
+      });
+    } catch {
+      // Re-exec failed, fall through to current version
+      process.stdout.write(` ${colors.dim}Update failed, continuing with v${version}${colors.reset}\n`);
+    }
+  }
+
   // Print compact banner
   process.stdout.write(getBanner(version));
 
@@ -414,7 +470,7 @@ async function main() {
   }
 
   // Disable Gmail/Calendar MCP servers (Claudia has native CLI commands now)
-  disableGoogleMcpServers(targetPath);
+  disableLegacyMcpServers(targetPath);
 
   // Write context/whats-new.md for Claudia's self-awareness (silent)
   writeWhatsNewFile(targetPath, version);
@@ -820,11 +876,15 @@ async function main() {
 }
 
 /**
- * Disable Gmail and Google Calendar MCP servers in .mcp.json if present.
- * Claudia now has native CLI commands for both services, so external MCP
- * servers are no longer needed. This runs on both fresh installs and upgrades.
+ * Disable legacy MCP servers in .mcp.json that have been replaced by native CLI commands.
+ * This runs on both fresh installs and upgrades.
+ *
+ * Replaced servers:
+ * - claudia-memory  → `claudia memory` CLI (Node.js, direct SQLite)
+ * - gmail           → `claudia gmail` CLI
+ * - google-calendar → `claudia calendar` CLI
  */
-function disableGoogleMcpServers(targetPath) {
+function disableLegacyMcpServers(targetPath) {
   const mcpPath = join(targetPath, '.mcp.json');
   if (!existsSync(mcpPath)) return;
 
@@ -833,20 +893,31 @@ function disableGoogleMcpServers(targetPath) {
     const config = JSON.parse(raw);
     if (!config.mcpServers) return;
 
-    const googleKeys = ['gmail', 'google-calendar', 'google_calendar', 'googleCalendar'];
+    // Map of MCP server keys to their CLI replacement description
+    const legacyServers = {
+      'claudia-memory':    'claudia memory CLI',
+      'claudia_memory':    'claudia memory CLI',
+      'gmail':             'claudia google login',
+      'google-calendar':   'claudia google login',
+      'google_calendar':   'claudia google login',
+      'googleCalendar':    'claudia google login',
+    };
+
     let changed = false;
+    const disabled = [];
 
-    for (const key of googleKeys) {
+    for (const [key, replacement] of Object.entries(legacyServers)) {
       if (config.mcpServers[key] && !config.mcpServers[key]._disabled) {
         config.mcpServers[key]._disabled = true;
-        config.mcpServers[key]._replaced_by = 'claudia google login';
+        config.mcpServers[key]._replaced_by = replacement;
         changed = true;
+        disabled.push(key);
       }
     }
 
     if (changed) {
       writeFileSync(mcpPath, JSON.stringify(config, null, 2) + '\n');
-      console.log(` ${colors.yellow}→${colors.reset} Disabled Gmail/Calendar MCP servers (replaced by ${colors.cyan}claudia google login${colors.reset})`);
+      console.log(` ${colors.yellow}→${colors.reset} Disabled legacy MCP: ${disabled.join(', ')} (replaced by native CLI)`);
     }
   } catch {
     // Not valid JSON or can't read -- skip silently

package/cli/commands/google-auth.js

@@ -10,6 +10,7 @@
  *   claudia gmail search     - Search emails
  *   claudia gmail read       - Read a specific email
  *   claudia gmail send       - Send an email with optional attachments
+ *   claudia gmail draft      - Create a draft email with optional attachments
  *   claudia gmail logout     - Sign out of Gmail
  *   claudia calendar login   - Sign in with Google (Calendar only)
  *   claudia calendar status  - Check Calendar connection status
@@ -25,7 +26,7 @@ import { randomBytes } from 'node:crypto';
 import { authenticate, getAccessToken, isAuthenticated, revokeTokens, authStatus } from '../core/google-oauth.js';
 import { outputJson as output } from '../core/output.js';
 
-// ── MIME Helpers (for gmail send) ──
+// ── MIME Helpers (for gmail send & draft) ──
 
 const MIME_TYPES = {
   png: 'image/png',
@@ -368,6 +369,79 @@ export async function gmailSendCommand(opts) {
   });
 }
 
+export async function gmailDraftCommand(opts) {
+  const token = await getAccessToken('gmail');
+  if (!token) {
+    console.error('Not authenticated. Run: claudia gmail login');
+    process.exitCode = 1;
+    return;
+  }
+
+  // Drafts are more lenient than send: subject and body can be empty
+  const to = opts.to || [];
+  const subject = opts.subject || '';
+  const body = opts.body || '';
+
+  // Prepare attachments
+  let attachments = [];
+  if (opts.attach && opts.attach.length > 0) {
+    try {
+      attachments = prepareAttachments(opts.attach);
+    } catch (err) {
+      console.error(err.message);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  // Build MIME message and base64url-encode it
+  const rawMessage = buildMimeMessage({
+    to,
+    subject,
+    body,
+    cc: opts.cc,
+    bcc: opts.bcc,
+    html: opts.html,
+    replyTo: opts.replyTo,
+    attachments,
+  });
+
+  const encodedMessage = Buffer.from(rawMessage, 'utf-8')
+    .toString('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/, '');
+
+  // Gmail drafts API: { message: { raw, threadId? } }
+  const message = { raw: encodedMessage };
+  if (opts.thread) {
+    message.threadId = opts.thread;
+  }
+
+  const resp = await fetch('https://gmail.googleapis.com/gmail/v1/users/me/drafts', {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ message }),
+  });
+
+  if (!resp.ok) {
+    const err = await resp.text();
+    console.error(`Gmail API error (${resp.status}): ${err}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const data = await resp.json();
+  output({
+    id: data.id,
+    messageId: data.message?.id,
+    threadId: data.message?.threadId,
+  });
+}
+
 export async function gmailLogoutCommand() {
   const removed = revokeTokens('gmail');
   if (removed) {

package/cli/index.js

@@ -522,7 +522,7 @@ program
 // ── Gmail subcommand group ──
 const gmail = program
   .command('gmail')
-  .description('Gmail integration (login, search, read, send)');
+  .description('Gmail integration (login, search, read, send, draft)');
 
 gmail
   .command('login')
@@ -576,6 +576,23 @@ gmail
     await gmailSendCommand(opts);
   });
 
+gmail
+  .command('draft')
+  .description('Create a draft email (with optional attachments)')
+  .option('--to <email...>', 'Recipient email address(es)')
+  .option('--subject <text>', 'Email subject')
+  .option('--body <text>', 'Email body text')
+  .option('--cc <email...>', 'CC recipient(s)')
+  .option('--bcc <email...>', 'BCC recipient(s)')
+  .option('--attach <filepath...>', 'File(s) to attach')
+  .option('--html', 'Treat body as HTML', false)
+  .option('--thread <threadId>', 'Thread ID (for replies)')
+  .option('--reply-to <messageId>', 'Message-ID for In-Reply-To header')
+  .action(async (opts) => {
+    const { gmailDraftCommand } = await import('./commands/google-auth.js');
+    await gmailDraftCommand(opts);
+  });
+
 gmail
   .command('logout')
   .description('Sign out of Gmail (remove stored tokens)')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.51.6",
+  "version": "1.51.8",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",

package/template-v2/CLAUDE.md

@@ -214,17 +214,22 @@ What would you like to start with?
 
 ### 2. Relationships as Context
 
-People are my primary organizing unit. When someone is mentioned:
+People are my primary organizing unit. **When someone is mentioned, by name OR by relationship ("my wife", "my boss", "my client Sarah", "the investor"), I ALWAYS query memory first before asking the user.** I never ask for information I might already know.
 
-1. Check if I have context in `people/[name].md`
-2. Surface relevant history if it helps
-3. Offer to create a file if this person seems important
+Lookup order:
+1. `claudia memory recall "<name or relationship>" --project-dir "$PWD"` to resolve who they mean
+2. `claudia memory about "<entity name>" --project-dir "$PWD"` for full context (email, role, history)
+3. Check `people/[name].md` for additional context
+4. Only ask the user if memory returns nothing
+
+**The rule: search before asking.** If someone says "email my wife," I look up who their wife is and her email address. I don't ask "What's your wife's email?" when I might already have it.
 
 What I track about people:
 - Communication preferences and style
 - What matters to them
 - Your history with them
 - Current context (projects, concerns, opportunities)
+- Contact details (email, phone, handles)
 - Notes from past interactions
 
 ### 3. Commitment Tracking
@@ -329,6 +334,7 @@ I adapt to whatever tools are available. When you ask me to do something that ne
 | `claudia gmail search "<query>"` | Search emails (Gmail search syntax) |
 | `claudia gmail read <messageId>` | Read a specific email |
 | `claudia gmail send --to <email> --subject <text> --body <text>` | Send email (supports --attach, --cc, --bcc, --html, --thread, --reply-to) |
+| `claudia gmail draft --to <email> --subject <text> --body <text>` | Create draft in Gmail (same options as send, all optional, supports --attach for images/files) |
 | `claudia gmail logout` | Disconnect Gmail, remove tokens |
 | `claudia calendar login` | Opens browser for Calendar-only OAuth |
 | `claudia calendar status` | Check if Calendar is connected |