synap 0.5.1 → 0.6.0

package/.claude/skills/synap-assistant/SKILL.md

@@ -147,6 +147,33 @@ synap log a1b2c3d4 "Completed first draft" --inherit-tags
 - `--inherit-tags`: Copy tags from parent entry
 - `--json`: JSON output
 
+#### `synap batch-add`
+Add multiple entries in one operation.
+
+```bash
+# From file
+synap batch-add --file entries.json
+
+# From stdin (pipe)
+echo '[{"content":"Task 1","type":"todo"},{"content":"Task 2","type":"todo"}]' | synap batch-add
+
+# Dry run
+synap batch-add --file entries.json --dry-run
+```
+
+**Input format (JSON array):**
+```json
+[
+  {"content": "First entry", "type": "idea"},
+  {"content": "Second entry", "type": "todo", "priority": 1, "tags": ["work"]}
+]
+```
+
+**Options**:
+- `--file <path>`: Read from JSON file
+- `--dry-run`: Preview what would be added
+- `--json`: JSON output
+
 ### Query Commands
 
 #### `synap list`
@@ -390,6 +417,24 @@ When user is dumping thoughts rapidly:
 
 **Smart status defaulting**: When capturing with priority set, the CLI auto-promotes to `active` status (skipping triage). When adding entries with full metadata (priority, tags, due), there's no need to manually set status—the entry is already triaged.
 
+### Grouping Detection Pattern
+
+After capture sessions, detect opportunities to group related entries:
+
+| Signal | Action |
+|--------|--------|
+| 3+ entries with same tag in one session | Suggest parent project with that tag as context |
+| 3+ entries mentioning same keyword/topic | Suggest linking as related or creating parent |
+| User mentions "for the X project" multiple times | Proactively suggest creating/linking to X project |
+
+**Grouping workflow:**
+1. After capture, analyze recent additions: `synap list --since 1h --json`
+2. Group by common tags or detect semantic similarity
+3. If grouping detected, propose: "These 4 entries seem related to [topic]. Create a parent project?"
+4. On confirmation:
+   - `synap add "[Topic] Project" --type project --tags "topic"`
+   - For each child: `synap link <child-id> <project-id> --as-parent`
+
 ## Classification Rules
 
 ### Type Detection Heuristics
@@ -429,6 +474,7 @@ When user is dumping thoughts rapidly:
 - If P1 todos exist, suggest `synap focus`.
 - If many stale active items exist, suggest a weekly review.
 - If preferences specify cadence, follow it by default.
+- If 3+ entries added with common tags/context, suggest grouping under a parent project (see Grouping Detection Pattern).
 
 ## Batch Processing Protocols
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synap",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "A CLI for externalizing your working memory",
   "main": "src/cli.js",
   "bin": {

package/src/cli.js

@@ -6,6 +6,7 @@
  */
 
 const { program } = require('commander');
+const fs = require('fs');
 const pkg = require('../package.json');
 
 // Storage and utility modules
@@ -381,6 +382,101 @@ async function main() {
       }
     });
 
+  program
+    .command('batch-add')
+    .description('Add multiple entries from JSON stdin or file')
+    .option('--file <path>', 'Read entries from JSON file')
+    .option('--dry-run', 'Preview what would be added')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      let entriesData;
+
+      if (options.file) {
+        // Read from file
+        if (!fs.existsSync(options.file)) {
+          if (options.json) {
+            console.log(JSON.stringify({ success: false, error: `File not found: ${options.file}`, code: 'FILE_NOT_FOUND' }));
+          } else {
+            console.error(chalk.red(`File not found: ${options.file}`));
+          }
+          process.exit(1);
+        }
+        const content = fs.readFileSync(options.file, 'utf8');
+        entriesData = JSON.parse(content);
+      } else {
+        // Read from stdin
+        const chunks = [];
+        process.stdin.setEncoding('utf8');
+        for await (const chunk of process.stdin) {
+          chunks.push(chunk);
+        }
+        const input = chunks.join('');
+        if (!input.trim()) {
+          if (options.json) {
+            console.log(JSON.stringify({ success: false, error: 'No input provided. Pipe JSON array to stdin or use --file', code: 'NO_INPUT' }));
+          } else {
+            console.error(chalk.red('No input provided. Pipe JSON array to stdin or use --file'));
+          }
+          process.exit(1);
+        }
+        entriesData = JSON.parse(input);
+      }
+
+      // Normalize to array
+      if (!Array.isArray(entriesData)) {
+        entriesData = entriesData.entries || [entriesData];
+      }
+
+      if (entriesData.length === 0) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: true, count: 0, entries: [] }));
+        } else {
+          console.log(chalk.gray('No entries to add'));
+        }
+        return;
+      }
+
+      // Merge config tags with each entry's tags
+      entriesData = entriesData.map(e => ({
+        ...e,
+        tags: [...new Set([...(config.defaultTags || []), ...(e.tags || [])])],
+        source: e.source || 'cli'
+      }));
+
+      if (options.dryRun) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: true, dryRun: true, count: entriesData.length, entries: entriesData }));
+        } else {
+          console.log(chalk.yellow(`Would add ${entriesData.length} entries:`));
+          for (const entry of entriesData) {
+            console.log(`  [${entry.type || 'idea'}] ${entry.content?.slice(0, 50)}${entry.content?.length > 50 ? '...' : ''}`);
+          }
+        }
+        return;
+      }
+
+      try {
+        const created = await storage.addEntries(entriesData);
+
+        if (options.json) {
+          console.log(JSON.stringify({ success: true, count: created.length, entries: created }, null, 2));
+        } else {
+          console.log(chalk.green(`Added ${created.length} entries`));
+          for (const entry of created) {
+            const shortId = entry.id.slice(0, 8);
+            console.log(`  ${chalk.blue(shortId)} [${entry.type}] ${entry.title || entry.content.slice(0, 40)}`);
+          }
+        }
+      } catch (err) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: false, error: err.message }));
+        } else {
+          console.error(chalk.red(err.message));
+        }
+        process.exit(1);
+      }
+    });
+
   // ============================================
   // QUERY COMMANDS
   // ============================================
@@ -1216,7 +1312,10 @@ async function main() {
           console.log(`    ${type.padEnd(12)} ${count}`);
         }
         console.log('');
-        console.log(`  High Priority (P1): ${stats.highPriority}`);
+        const p1Display = stats.highPriority === stats.highPriorityActive
+          ? `${stats.highPriority}`
+          : `${stats.highPriority} (${stats.highPriorityActive} active)`;
+        console.log(`  High Priority (P1): ${p1Display}`);
         console.log(`  Created this week:  ${stats.createdThisWeek}`);
         console.log(`  Updated today:      ${stats.updatedToday}`);
 
@@ -1835,10 +1934,11 @@ async function main() {
             skillResult = { ...skillResult, ...(await skillInstaller.install()) };
             if (skillResult.installed) {
               console.log(`      ${chalk.green('✓')} Skill installed at ~/.claude/skills/synap-assistant/`);
+              if (skillResult.backupFile) {
+                console.log(`      ${chalk.yellow('•')} Your modifications backed up to ${skillResult.backupFile}`);
+              }
             } else if (skillResult.skipped) {
               console.log(`      ${chalk.yellow('•')} Skill already up to date`);
-            } else if (skillResult.needsForce) {
-              console.log(`      ${chalk.yellow('•')} Skill modified. Use ${chalk.cyan('synap install-skill --force')}`);
             }
           } catch (err) {
             console.log(`      ${chalk.red('✗')} Skill install failed: ${err.message}`);
@@ -2040,7 +2140,6 @@ async function main() {
     .command('install-skill')
     .description('Install Claude Code skill')
     .option('--uninstall', 'Remove the skill')
-    .option('--force', 'Override ownership check')
     .action(async (options) => {
       const skillInstaller = require('./skill-installer');
 
@@ -2048,13 +2147,14 @@ async function main() {
         await skillInstaller.uninstall();
         console.log(chalk.green('Skill uninstalled'));
       } else {
-        const result = await skillInstaller.install({ force: options.force });
+        const result = await skillInstaller.install();
         if (result.installed) {
           console.log(chalk.green('Skill installed to ~/.claude/skills/synap-assistant/'));
+          if (result.backupFile) {
+            console.log(chalk.yellow(`Your modifications were backed up to ${result.backupFile}`));
+          }
         } else if (result.skipped) {
           console.log(chalk.yellow('Skill already up to date'));
-        } else if (result.needsForce) {
-          console.log(chalk.yellow('Skill was modified by user. Use --force to overwrite.'));
         }
       }
     });

package/src/skill-installer.js

@@ -116,6 +116,8 @@ async function install(options = {}) {
     fs.mkdirSync(TARGET_SKILL_DIR, { recursive: true });
   }
 
+  let backupFile = null;
+
   // Check if target exists
   if (fs.existsSync(TARGET_SKILL_FILE)) {
     const targetContent = fs.readFileSync(TARGET_SKILL_FILE, 'utf8');
@@ -124,32 +126,33 @@ async function install(options = {}) {
     const canonicalTargetHash = getHash(canonicalTarget);
     const targetMatchesSource = canonicalTargetHash === sourceHash;
 
-    if (targetSource !== SKILL_SOURCE && !options.force) {
-      return { installed: false, needsForce: true };
+    // Already up to date
+    if (targetMatchesSource && targetContent === normalizedSourceContent) {
+      return { installed: false, skipped: true };
     }
 
-    if (targetSource === SKILL_SOURCE && !options.force) {
-      if (targetMatchesSource && targetContent === normalizedSourceContent) {
-        return { installed: false, skipped: true };
-      }
-
-      if (targetHash) {
-        if (targetHash !== canonicalTargetHash) {
-          return { installed: false, needsForce: true };
-        }
-      } else if (!targetMatchesSource) {
-        return { installed: false, needsForce: true };
+    // Check if user modified the file (hash mismatch or different source)
+    const userModified = targetSource !== SKILL_SOURCE ||
+      (targetHash && targetHash !== canonicalTargetHash) ||
+      (!targetHash && !targetMatchesSource);
+
+    if (userModified) {
+      // Create timestamped backup
+      const timestamp = new Date().toISOString().slice(0, 10).replace(/-/g, '');
+      backupFile = `${TARGET_SKILL_FILE}.backup.${timestamp}`;
+      // If backup already exists today, add time
+      if (fs.existsSync(backupFile)) {
+        const time = new Date().toISOString().slice(11, 16).replace(':', '');
+        backupFile = `${TARGET_SKILL_FILE}.backup.${timestamp}-${time}`;
       }
+      fs.writeFileSync(backupFile, targetContent);
     }
-
-    const backupFile = TARGET_SKILL_FILE + '.backup';
-    fs.writeFileSync(backupFile, targetContent);
   }
 
   // Install
   fs.writeFileSync(TARGET_SKILL_FILE, normalizedSourceContent);
 
-  return { installed: true };
+  return { installed: true, backupFile };
 }
 
 /**

package/src/storage.js

@@ -357,6 +357,65 @@ async function addEntry(options) {
   return entry;
 }
 
+/**
+ * Add multiple entries in a single batch
+ * @param {Array} entriesData - Array of entry options
+ * @returns {Array} - Array of created entries
+ */
+async function addEntries(entriesData) {
+  const data = loadEntries();
+  const created = [];
+  const now = new Date().toISOString();
+
+  for (const options of entriesData) {
+    // Resolve partial parent ID to full ID
+    let parentId = options.parent;
+    if (parentId) {
+      const parentEntry = data.entries.find(e => e.id.startsWith(parentId));
+      if (parentEntry) {
+        parentId = parentEntry.id;
+      }
+    }
+
+    // Parse due date if provided
+    let dueDate = undefined;
+    const dueInput = typeof options.due === 'string' ? options.due.trim() : options.due;
+    if (dueInput) {
+      dueDate = parseDate(dueInput);
+      if (!dueDate) {
+        throw new Error(`Invalid due date: ${options.due}`);
+      }
+    }
+
+    const entry = {
+      id: uuidv4(),
+      content: options.content,
+      title: options.title || extractTitle(options.content),
+      type: VALID_TYPES.includes(options.type) ? options.type : 'idea',
+      status: VALID_STATUSES.includes(options.status) ? options.status : (options.priority ? 'active' : 'raw'),
+      priority: options.priority && [1, 2, 3].includes(options.priority) ? options.priority : undefined,
+      tags: options.tags || [],
+      parent: parentId || undefined,
+      related: [],
+      due: dueDate,
+      createdAt: now,
+      updatedAt: now,
+      source: options.source || 'cli'
+    };
+
+    // Clean up undefined fields
+    Object.keys(entry).forEach(key => {
+      if (entry[key] === undefined) delete entry[key];
+    });
+
+    data.entries.push(entry);
+    created.push(entry);
+  }
+
+  saveEntries(data);
+  return created;
+}
+
 /**
  * Extract title from content (first line, max 60 chars)
  */
@@ -764,6 +823,7 @@ async function getStats() {
     byStatus: {},
     byType: {},
     highPriority: 0,
+    highPriorityActive: 0,
     createdThisWeek: 0,
     updatedToday: 0
   };
@@ -780,7 +840,12 @@ async function getStats() {
     stats.byType[entry.type] = (stats.byType[entry.type] || 0) + 1;
 
     // High priority
-    if (entry.priority === 1) stats.highPriority++;
+    if (entry.priority === 1) {
+      stats.highPriority++;
+      if (entry.status === 'raw' || entry.status === 'active') {
+        stats.highPriorityActive++;
+      }
+    }
 
     // Created this week
     if (new Date(entry.createdAt) >= oneWeekAgo) stats.createdThisWeek++;
@@ -932,6 +997,7 @@ async function importEntries(entries, options = {}) {
 
 module.exports = {
   addEntry,
+  addEntries,
   getEntry,
   getEntriesByIds,
   getChildren,