saveinme 1.3.4 → 2.0.0

package/src/editor.js

@@ -1,9 +1,10 @@
-import { input, select, confirm } from '@inquirer/prompts';
+import { input, select, confirm, checkbox } from '@inquirer/prompts';
 import chalk from 'chalk';
-import { getAllNotes, saveNote, getNoteByTitle, getDefaultNotebook } from './store.js';
-import { showHeader, showSuccess, showError, showInfo } from './display.js';
+import { getAllNotes, saveNote, getNoteByTitle, getDefaultNotebook, setDefaultNotebook, deleteNoteById } from './store.js';
+import { showHeader, showSuccess, showError, showInfo, showNote } from './display.js';
 import { multilineEditor } from './multiline.js';
 import { getClipboardText } from './clipboard.js';
+import { triggerAutoSync } from './sync.js';
 
 // Helper for generating unique, readable default titles
 function getTimestamp() {
@@ -49,30 +50,56 @@ export async function saveFromClipboard(titleArg, notebookOverride) {
   }
   console.log(chalk.dim('  └──────────────────────────────────────────────────\n'));
 
-  // Resolve title
-  const title = (titleArg && titleArg.trim()) || `Clipboard Note - ${getTimestamp()}`;
-  const existingNote = getNoteByTitle(title);
-
   // Resolve notebook target
   const defaultNotebook = getDefaultNotebook();
-  const category = (notebookOverride !== null) ? notebookOverride.trim() : (existingNote?.category ?? defaultNotebook);
+  const tempCategory = (notebookOverride !== null) ? notebookOverride.trim() : defaultNotebook;
+
+  // Resolve title
+  let title = (titleArg && titleArg.trim()) || '';
+  let isAppend = false;
+
+  if (!title) {
+    if (tempCategory) {
+      title = tempCategory;
+      isAppend = true;
+    } else {
+      title = `Clipboard Note - ${getTimestamp()}`;
+    }
+  }
+
+  const existingNoteResolve = getNoteByTitle(title);
+  const category = (notebookOverride !== null) ? notebookOverride.trim() : (existingNoteResolve?.category ?? defaultNotebook);
+  let finalContent = clipboardContent;
+
+  if (existingNoteResolve && isAppend) {
+    finalContent = existingNoteResolve.content + '\n' + clipboardContent;
+  }
 
   saveNote({
-    id: existingNote?.id, // updates if title matches exactly
+    id: existingNoteResolve?.id, // updates if title matches exactly
     title: title.trim(),
-    content: clipboardContent,
+    content: finalContent,
     category: category.trim(),
-    tags: existingNote?.tags ?? [],
-    priority: existingNote?.priority ?? 'medium',
-    pinned: existingNote?.pinned ?? false,
+    tags: existingNoteResolve?.tags ?? [],
+    priority: existingNoteResolve?.priority ?? 'medium',
+    pinned: existingNoteResolve?.pinned ?? false,
   });
+  triggerAutoSync();
 
   const wc = clipboardContent.split(/\s+/).filter(Boolean).length;
-  showSuccess(
-    `Clipboard note "${title.trim()}" saved!` +
-    (category ? ` [Notebook: ${category.trim()}]` : '') +
-    chalk.dim(`  (${wc} words)`)
-  );
+  if (existingNoteResolve && isAppend) {
+    showSuccess(
+      `Appended clipboard text to note "${title.trim()}"` +
+      (category ? ` in notebook "${category.trim()}"` : '') +
+      chalk.dim(`  (+${wc} words)`)
+    );
+  } else {
+    showSuccess(
+      `Clipboard note "${title.trim()}" saved!` +
+      (category ? ` [Notebook: ${category.trim()}]` : '') +
+      chalk.dim(`  (${wc} words)`)
+    );
+  }
 }
 
 // ─── Save piped stdin directly ────────────────────────────────────────────────
@@ -96,25 +123,50 @@ export async function savePipedInput(inputContent, titleArg, notebookOverride) {
   const category = (notebookOverride !== null) ? notebookOverride.trim() : defaultNotebook;
 
   // Resolve title
-  const title = (titleArg && titleArg.trim()) || `Piped Note - ${getTimestamp()}`;
-  const existingNote = getNoteByTitle(title);
+  let title = (titleArg && titleArg.trim()) || '';
+  let isAppend = false;
+
+  if (!title) {
+    if (category) {
+      title = category;
+      isAppend = true;
+    } else {
+      title = `Piped Note - ${getTimestamp()}`;
+    }
+  }
+
+  const existingNoteResolve = getNoteByTitle(title);
+  let finalContent = content;
+
+  if (existingNoteResolve && isAppend) {
+    finalContent = existingNoteResolve.content + '\n' + content;
+  }
 
   saveNote({
-    id: existingNote?.id,
+    id: existingNoteResolve?.id,
     title: title.trim(),
-    content: content,
+    content: finalContent,
     category: category,
-    tags: existingNote?.tags ?? [],
-    priority: existingNote?.priority ?? 'medium',
-    pinned: existingNote?.pinned ?? false,
+    tags: existingNoteResolve?.tags ?? [],
+    priority: existingNoteResolve?.priority ?? 'medium',
+    pinned: existingNoteResolve?.pinned ?? false,
   });
+  triggerAutoSync();
 
   const wc = content.split(/\s+/).filter(Boolean).length;
-  showSuccess(
-    `Saved piped note "${title.trim()}"` +
-    (category ? ` to notebook "${category}"` : '') +
-    chalk.dim(`  (${wc} words)`)
-  );
+  if (existingNoteResolve && isAppend) {
+    showSuccess(
+      `Appended piped text to note "${title.trim()}"` +
+      (category ? ` in notebook "${category}"` : '') +
+      chalk.dim(`  (+${wc} words)`)
+    );
+  } else {
+    showSuccess(
+      `Saved piped note "${title.trim()}"` +
+      (category ? ` to notebook "${category}"` : '') +
+      chalk.dim(`  (${wc} words)`)
+    );
+  }
 }
 
 // ─── Main editor entry point ──────────────────────────────────────────────────
@@ -302,6 +354,7 @@ export async function openEditor(titleArg, notebookOverride) {
     priority,
     pinned,
   });
+  triggerAutoSync();
 
   const wc = finalContent.trim().split(/\s+/).filter(Boolean).length;
   showSuccess(
@@ -310,3 +363,146 @@ export async function openEditor(titleArg, notebookOverride) {
     chalk.dim(`  (${wc} words)`)
   );
 }
+
+// ─── Interactive Group Delete ─────────────────────────────────────────────────
+
+/**
+ * Renders a checkbox menu to select and delete multiple notes at once.
+ */
+export async function interactiveGroupDelete() {
+  const notes = getAllNotes();
+  if (notes.length === 0) {
+    showError('No notes saved to delete.');
+    return;
+  }
+
+  // Sort notes: pinned first, then by last modified
+  const sorted = [...notes].sort((a, b) => {
+    if (a.pinned && !b.pinned) return -1;
+    if (!a.pinned && b.pinned) return 1;
+    return new Date(b.updatedAt) - new Date(a.updatedAt);
+  });
+
+  const selectedIds = await checkbox({
+    message: 'Select notes to remove (Space to select, Enter to confirm):',
+    choices: sorted.map(n => ({
+      name: `${n.pinned ? '📌 ' : ''}${chalk.bold(n.title)} ${chalk.dim(`(${n.category || 'uncategorized'} · ${n.wordCount}w)`)}`,
+      value: n.id,
+    })),
+  });
+
+  if (selectedIds.length === 0) {
+    showInfo('No notes selected. Nothing deleted.');
+    return;
+  }
+
+  const confirmDelete = await confirm({
+    message: `Are you sure you want to delete ${selectedIds.length} note(s)?`,
+    default: false,
+  });
+
+  if (!confirmDelete) {
+    showInfo('Deletion cancelled.');
+    return;
+  }
+
+  let count = 0;
+  for (const id of selectedIds) {
+    if (deleteNoteById(id)) {
+      count++;
+    }
+  }
+
+  if (count > 0) {
+    triggerAutoSync();
+  }
+
+  showSuccess(`Successfully removed ${count} note(s).`);
+}
+
+/**
+ * Renders a select menu to set the default notebook target.
+ */
+export async function interactiveSetDefaultNotebook() {
+  const notes = getAllNotes();
+  const current = getDefaultNotebook();
+  const existingCats = [...new Set(notes.map(n => n.category).filter(Boolean))];
+
+  const choices = [];
+  if (existingCats.length > 0) {
+    choices.push(...existingCats.map(c => ({ name: `📁  ${c}`, value: c })));
+  }
+  choices.push(
+    { name: chalk.cyan('+ Create new notebook…'), value: '__new__' },
+    { name: chalk.red('❌ Clear default notebook'), value: '__clear__' },
+    { name: chalk.dim('↩️  Keep current default'), value: '__keep__' }
+  );
+
+  console.log('');
+  if (current) {
+    console.log(chalk.cyan(`  Current default notebook: "${current}"`));
+  } else {
+    console.log(chalk.dim('  No default notebook currently set.'));
+  }
+  console.log('');
+
+  const choice = await select({
+    message: 'Select default notebook:',
+    choices,
+  });
+
+  if (choice === '__keep__') {
+    showInfo('No changes made to default notebook.');
+    return;
+  }
+
+  if (choice === '__clear__') {
+    setDefaultNotebook('');
+    showSuccess('Default notebook cleared.');
+    return;
+  }
+
+  let notebookName = choice;
+  if (choice === '__new__') {
+    const typed = await input({
+      message: 'New notebook name:',
+      validate: v => v.trim().length > 0 || 'Notebook name cannot be empty.',
+    });
+    notebookName = typed.trim();
+  }
+
+  setDefaultNotebook(notebookName);
+  showSuccess(`Target notebook set to "${notebookName}".\n  New notes will default to this notebook.`);
+}
+
+/**
+ * Renders a select menu to pick a note to view.
+ */
+export async function interactiveViewNote() {
+  const notes = getAllNotes();
+  if (notes.length === 0) {
+    showError('No notes saved to view.');
+    return;
+  }
+
+  const sorted = [...notes].sort((a, b) => {
+    if (a.pinned && !b.pinned) return -1;
+    if (!a.pinned && b.pinned) return 1;
+    return new Date(b.updatedAt) - new Date(a.updatedAt);
+  });
+
+  const choices = sorted.map(n => ({
+    name: `${n.pinned ? '📌 ' : '   '}${chalk.bold(n.title)} ${chalk.dim(`(${n.category || 'uncategorized'} · ${n.wordCount}w)`)}`,
+    value: n.id,
+  }));
+
+  const selectedId = await select({
+    message: 'Select a note to view:',
+    choices,
+  });
+
+  const note = notes.find(n => n.id === selectedId);
+  if (note) {
+    showNote(note);
+  }
+}

package/src/store.js

@@ -111,19 +111,27 @@ export function getDataPath() {
   return DATA_FILE;
 }
 
-export function getDefaultNotebook() {
+export function getConfig() {
   ensureDir();
-  if (!existsSync(CONFIG_FILE)) return '';
+  if (!existsSync(CONFIG_FILE)) return {};
   try {
-    const config = JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
-    return config.defaultNotebook ?? '';
+    return JSON.parse(readFileSync(CONFIG_FILE, 'utf-8')) ?? {};
   } catch {
-    return '';
+    return {};
   }
 }
 
-export function setDefaultNotebook(name) {
+export function saveConfig(updates) {
   ensureDir();
-  const config = { defaultNotebook: name.trim() };
-  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+  const current = getConfig();
+  const next = { ...current, ...updates };
+  writeFileSync(CONFIG_FILE, JSON.stringify(next, null, 2), 'utf-8');
+}
+
+export function getDefaultNotebook() {
+  return getConfig().defaultNotebook ?? '';
+}
+
+export function setDefaultNotebook(name) {
+  saveConfig({ defaultNotebook: name.trim() });
 }

package/src/sync.js

@@ -0,0 +1,165 @@
+import { execSync } from 'child_process';
+import { existsSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { confirm, input } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { getDataPath, getConfig, saveConfig } from './store.js';
+import { showSuccess, showError, showInfo } from './display.js';
+
+// Get base directory of saveinme database (~/.saveinme)
+const DATA_DIR = dirname(getDataPath());
+
+/**
+ * Runs a git command inside the saveinme directory.
+ * @param {string} cmd Git subcommand
+ * @returns {string|null} command output or null if failed
+ */
+function runGit(cmd) {
+  try {
+    return execSync(`git ${cmd}`, { cwd: DATA_DIR, stdio: 'pipe', encoding: 'utf-8' }).trim();
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Checks if Git is installed on the system.
+ */
+function isGitInstalled() {
+  try {
+    execSync('git --version', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Initializes Git repository in the database directory if not already initialized.
+ */
+function ensureGitRepo() {
+  if (!existsSync(join(DATA_DIR, '.git'))) {
+    showInfo('Initializing local Git repository...');
+    runGit('init');
+    
+    // Create .gitignore to prevent uploading local configs (like API keys)
+    const gitignorePath = join(DATA_DIR, '.gitignore');
+    writeFileSync(gitignorePath, 'config.json\n', 'utf-8');
+    runGit('add .gitignore');
+    runGit('commit -m "Initial commit: setup gitignore"');
+  }
+}
+
+/**
+ * Main Git Sync function. Pulls latest notes, commits local changes, and pushes them.
+ * @param {boolean} forceSetup If true, prompt for repository configuration even if configured.
+ */
+export async function syncNotes(forceSetup = false) {
+  if (!isGitInstalled()) {
+    showError('Git is not installed or not in your PATH. Please install Git first.');
+    return;
+  }
+
+  ensureGitRepo();
+
+  // Check if remote is configured
+  let remoteUrl = runGit('remote get-url origin');
+  const config = getConfig();
+
+  if (!remoteUrl || forceSetup) {
+    console.log(chalk.yellow('\n🌐 Git Sync Remote Setup'));
+    const setupRemote = await confirm({
+      message: 'Would you like to configure a remote Git repository (e.g. on GitHub) to sync notes?',
+      default: true,
+    });
+
+    if (!setupRemote) {
+      showInfo('Git Sync cancelled.');
+      return;
+    }
+
+    const url = await input({
+      message: 'Enter remote repository URL (SSH preferred, e.g. git@github.com:username/notes-repo.git):',
+      validate: v => v.trim().length > 0 || 'Repository URL cannot be empty.',
+    });
+
+    if (remoteUrl) {
+      runGit('remote remove origin');
+    }
+    
+    const added = runGit(`remote add origin ${url.trim()}`);
+    if (added === null) {
+      showError('Failed to configure remote repository URL.');
+      return;
+    }
+    remoteUrl = url.trim();
+
+    // Enable auto-sync by default if remote is set up
+    saveConfig({ autoSync: true });
+    showSuccess('Remote repository configured successfully. Auto-sync enabled.');
+  }
+
+  // Get current active branch (default to main/master)
+  let branch = runGit('branch --show-current');
+  if (!branch) {
+    // Check if there are branches, or default to main
+    branch = 'main';
+  }
+
+  showInfo(`Syncing notes with ${chalk.cyan(remoteUrl)} [branch: ${chalk.cyan(branch)}]...`);
+
+  // Stage changes
+  runGit('add notes.json');
+
+  // Check if there are staged changes to commit
+  const status = runGit('status --porcelain');
+  if (status && status.includes('notes.json')) {
+    runGit('commit -m "sync: update notes"');
+    showInfo('Committed local changes.');
+  } else {
+    showInfo('No local changes to commit.');
+  }
+
+  // Try to pull remote changes
+  showInfo('Pulling latest changes from remote...');
+  // Use --rebase to keep note history clean.
+  const pullResult = runGit(`pull --rebase origin ${branch}`);
+  if (pullResult === null) {
+    showError('Failed to pull from remote. You may have merge conflicts.');
+    showInfo('Aborting rebase...');
+    runGit('rebase --abort');
+    return;
+  }
+
+  // Push local changes to remote
+  showInfo('Pushing local updates to remote...');
+  const pushResult = runGit(`push -u origin ${branch}`);
+  if (pushResult === null) {
+    showError('Failed to push to remote repository.');
+    return;
+  }
+
+  showSuccess('Sync complete! All notes are up to date.');
+}
+
+/**
+ * Triggers background/silent auto-sync when notes are modified.
+ */
+export function triggerAutoSync() {
+  const config = getConfig();
+  if (!config.autoSync) return;
+
+  if (!isGitInstalled() || !existsSync(join(DATA_DIR, '.git'))) return;
+
+  // Run auto-sync asynchronously so it doesn't block the CLI interface
+  import('child_process').then(({ exec }) => {
+    let branch = runGit('branch --show-current') || 'main';
+    exec(`git add notes.json && git commit -m "sync: auto-update notes" && git pull --rebase origin ${branch} && git push origin ${branch}`, {
+      cwd: DATA_DIR,
+    }, (error) => {
+      if (error) {
+        // Fail silently in background to avoid disrupting user workflow
+      }
+    });
+  });
+}