synap 0.6.0 → 0.7.0

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

@@ -39,8 +39,11 @@ When assisting users with their synap entries:
 synap stores long-term user preferences at `~/.config/synap/user-preferences.md`.
 
 - Read preferences at the start of a session when present.
-- Append stable, reusable preferences with `synap preferences --append "## Section" "..."`.
-- Avoid overwriting user-written content; prefer section-based appends.
+- Prefer idempotent updates with `synap preferences set --section "Tag Meanings" --entry "#urgent = must do today"`.
+- Remove entries with `synap preferences remove --section tags --match "urgent"`.
+- List entries with `synap preferences list --section tags --json`.
+- `synap preferences --append "## Section" "..."` is still supported for raw appends.
+- Avoid overwriting user-written content; prefer section-based updates.
 
 ## Operating Modes
 
@@ -79,6 +82,7 @@ Detect user intent and respond appropriately:
 | Get stats | `synap stats` |
 | Setup wizard | `synap setup` |
 | Edit preferences | `synap preferences --edit` |
+| Set preference | `synap preferences set --section tags --entry "#urgent = must do today"` |
 
 ## Pre-flight Check
 
@@ -435,6 +439,37 @@ After capture sessions, detect opportunities to group related entries:
    - `synap add "[Topic] Project" --type project --tags "topic"`
    - For each child: `synap link <child-id> <project-id> --as-parent`
 
+### Daily Tracking Pattern
+
+For projects requiring ongoing progress logging (standups, journals, learning logs):
+
+| Signal | Action |
+|--------|--------|
+| Project mentions "daily", "track progress", "standup" | Suggest daily tracking setup |
+| User says "I need to log progress on X" | Explain `synap log` workflow |
+| Project has `--tags daily-tracking` | Ask for today's update |
+
+**Daily tracking workflow:**
+
+1. **Setup:** Create a project to track
+   ```bash
+   synap add "Learn Rust" --type project --tags "learning,daily-tracking"
+   ```
+
+2. **Daily logging:** Add timestamped progress
+   ```bash
+   synap log <project-id> "Completed chapter 3"
+   ```
+
+3. **Review progress:** View the log tree
+   ```bash
+   synap tree <project-id>
+   ```
+
+**When to suggest:** User creates learning/progress project, mentions accountability, or asks about daily tracking.
+
+**Do NOT auto-create** - always confirm with user first.
+
 ## Classification Rules
 
 ### Type Detection Heuristics

package/package.json

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

package/src/cli.js

@@ -1749,7 +1749,16 @@ async function main() {
   // PREFERENCES COMMANDS
   // ============================================
 
-  program
+  const respondPreferencesError = (options, message, code = 'INVALID_ARGS') => {
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: message, code }));
+    } else {
+      console.error(chalk.red(message));
+    }
+    process.exit(1);
+  };
+
+  const preferencesCommand = program
     .command('preferences')
     .description('View or update user preferences')
     .option('--edit', 'Open preferences in $EDITOR')
@@ -1761,22 +1770,13 @@ async function main() {
       const hasAppend = Array.isArray(options.append);
       const activeFlags = [options.edit, options.reset, hasAppend].filter(Boolean).length;
 
-      const respondError = (message, code = 'INVALID_ARGS') => {
-        if (options.json) {
-          console.log(JSON.stringify({ success: false, error: message, code }));
-        } else {
-          console.error(chalk.red(message));
-        }
-        process.exit(1);
-      };
-
       if (activeFlags > 1) {
-        respondError('Use only one of --edit, --reset, or --append');
+        respondPreferencesError(options, 'Use only one of --edit, --reset, or --append');
       }
       try {
         if (options.edit) {
           if (options.json) {
-            respondError('Cannot use --json with --edit', 'INVALID_MODE');
+            respondPreferencesError(options, 'Cannot use --json with --edit', 'INVALID_MODE');
           }
 
           preferences.loadPreferences();
@@ -1832,7 +1832,7 @@ async function main() {
         if (hasAppend) {
           const values = options.append || [];
           if (values.length < 2) {
-            respondError('Usage: synap preferences --append "## Section" "Text to append"');
+            respondPreferencesError(options, 'Usage: synap preferences --append "## Section" "Text to append"');
           }
 
           const [section, ...textParts] = values;
@@ -1865,7 +1865,160 @@ async function main() {
           console.log(content);
         }
       } catch (err) {
-        respondError(err.message || 'Failed to update preferences', 'PREFERENCES_ERROR');
+        respondPreferencesError(options, err.message || 'Failed to update preferences', 'PREFERENCES_ERROR');
+      }
+    });
+
+  preferencesCommand
+    .command('set')
+    .description('Add a preference entry to a section')
+    .option('--section <section>', 'Section name or alias')
+    .option('--entry <entry>', 'Entry text')
+    .option('--json', 'Output as JSON')
+    .action((options) => {
+      if (!options.section || !options.entry) {
+        respondPreferencesError(
+          options,
+          'Usage: synap preferences set --section "tags" --entry "text to add"'
+        );
+      }
+
+      try {
+        const result = preferences.setEntry(options.section, options.entry);
+        const payload = { ...result, path: preferences.getPreferencesPath() };
+
+        if (options.json) {
+          console.log(JSON.stringify(payload, null, 2));
+        } else if (result.added) {
+          console.log(chalk.green(`Added entry to ${result.section}`));
+        } else {
+          console.log(chalk.yellow(`Entry already exists in ${result.section}`));
+        }
+      } catch (err) {
+        respondPreferencesError(options, err.message || 'Failed to set preferences', 'PREFERENCES_ERROR');
+      }
+    });
+
+  preferencesCommand
+    .command('remove')
+    .description('Remove preference entries from a section')
+    .option('--section <section>', 'Section name or alias')
+    .option('--match <pattern>', 'Match text (case-insensitive substring)')
+    .option('--entry <entry>', 'Exact entry text')
+    .option('--json', 'Output as JSON')
+    .action((options) => {
+      if (!options.section) {
+        respondPreferencesError(
+          options,
+          'Usage: synap preferences remove --section "tags" --match "urgent"'
+        );
+      }
+      if (options.match && options.entry) {
+        respondPreferencesError(options, 'Use only one of --match or --entry');
+      }
+      if (!options.match && !options.entry) {
+        respondPreferencesError(
+          options,
+          'Usage: synap preferences remove --section "tags" --match "urgent"'
+        );
+      }
+
+      try {
+        const result = preferences.removeFromSection(options.section, {
+          match: options.match,
+          entry: options.entry
+        });
+        const payload = { ...result, path: preferences.getPreferencesPath() };
+
+        if (options.json) {
+          console.log(JSON.stringify(payload, null, 2));
+        } else if (result.removed) {
+          console.log(chalk.green(`Removed ${result.count} entr${result.count === 1 ? 'y' : 'ies'} from ${result.section}`));
+        } else {
+          console.log(chalk.yellow(`No entries matched in ${result.section}`));
+        }
+      } catch (err) {
+        respondPreferencesError(options, err.message || 'Failed to remove preferences', 'PREFERENCES_ERROR');
+      }
+    });
+
+  preferencesCommand
+    .command('list')
+    .description('List preference entries')
+    .option('--section <section>', 'Section name or alias')
+    .option('--json', 'Output as JSON')
+    .action((options) => {
+      try {
+        if (options.section) {
+          const section = preferences.resolveSection(options.section);
+          const entries = preferences.getEntriesInSection(section);
+          const payload = { section, entries, count: entries.length };
+
+          if (options.json) {
+            console.log(JSON.stringify(payload, null, 2));
+          } else if (entries.length === 0) {
+            console.log(chalk.gray(`No entries found in ${section}`));
+          } else {
+            console.log(chalk.bold(section));
+            entries.forEach((entry) => {
+              console.log(`- ${entry}`);
+            });
+          }
+          return;
+        }
+
+        const content = preferences.loadPreferences();
+        const lines = content.split(/\r?\n/);
+        const sections = [];
+        let current = null;
+
+        for (const line of lines) {
+          const headingMatch = line.match(/^(#{1,6})\s*(.+?)\s*$/);
+          if (headingMatch) {
+            const level = headingMatch[1].length;
+            const name = headingMatch[2].trim();
+
+            if (level === 2) {
+              current = { section: name, entries: [] };
+              sections.push(current);
+            } else if (level === 1) {
+              current = null;
+            }
+            continue;
+          }
+
+          if (!current) {
+            continue;
+          }
+
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith('<!--') || /^(#{1,6})\s+/.test(trimmed)) {
+            continue;
+          }
+
+          current.entries.push(trimmed);
+        }
+
+        const populatedSections = sections.filter(section => section.entries.length > 0);
+        const totalEntries = populatedSections.reduce((sum, section) => sum + section.entries.length, 0);
+
+        if (options.json) {
+          console.log(JSON.stringify({ sections: populatedSections, count: totalEntries }, null, 2));
+        } else if (populatedSections.length === 0) {
+          console.log(chalk.gray('No preference entries found'));
+        } else {
+          populatedSections.forEach((section, index) => {
+            if (index > 0) {
+              console.log('');
+            }
+            console.log(chalk.bold(section.section));
+            section.entries.forEach((entry) => {
+              console.log(`- ${entry}`);
+            });
+          });
+        }
+      } catch (err) {
+        respondPreferencesError(options, err.message || 'Failed to list preferences', 'PREFERENCES_ERROR');
       }
     });
 

package/src/preferences.js

@@ -9,6 +9,17 @@ const storage = require('./storage');
 const TEMPLATE_PATH = path.join(__dirname, 'templates', 'user-preferences-template.md');
 const PREFERENCES_FILE = path.join(storage.CONFIG_DIR, 'user-preferences.md');
 const MAX_LINES = 500;
+const SECTION_ALIASES = new Map([
+  ['about', 'About Me'],
+  ['me', 'About Me'],
+  ['projects', 'Important Projects'],
+  ['important', 'Important Projects'],
+  ['tags', 'Tag Meanings'],
+  ['tag', 'Tag Meanings'],
+  ['review', 'Review Preferences'],
+  ['behavior', 'Behavioral Preferences'],
+  ['behavioral', 'Behavioral Preferences']
+]);
 
 function ensureConfigDir() {
   if (!fs.existsSync(storage.CONFIG_DIR)) {
@@ -79,7 +90,16 @@ function resetPreferences() {
   return savePreferences(template);
 }
 
+function resolveSection(input) {
+  const target = parseSectionTarget(input);
+  const key = target.name.toLowerCase();
+  return SECTION_ALIASES.get(key) || target.name;
+}
+
 function parseSectionTarget(section) {
+  if (typeof section !== 'string') {
+    throw new Error('Section name is required');
+  }
   const trimmed = section.trim();
   if (!trimmed) {
     throw new Error('Section name is required');
@@ -93,9 +113,22 @@ function parseSectionTarget(section) {
   return { level: null, name: trimmed };
 }
 
+function normalizeEntry(entry) {
+  return entry.trim();
+}
+
+function isCommentLine(line) {
+  const trimmed = line.trim();
+  return trimmed.startsWith('<!--');
+}
+
+function isHeadingLine(line) {
+  return /^(#{1,6})\s+/.test(line.trim());
+}
+
 function findSection(lines, target) {
   for (let i = 0; i < lines.length; i += 1) {
-    const match = lines[i].match(/^(#{1,6})\s*(.+?)\s*$/);
+    const match = lines[i].match(/^(#{1,6})\s+(.+?)\s*$/);
     if (!match) {
       continue;
     }
@@ -113,6 +146,148 @@ function findSection(lines, target) {
   return null;
 }
 
+function getSectionRange(lines, match) {
+  if (!match) {
+    return null;
+  }
+
+  let endIndex = lines.length;
+  for (let i = match.index + 1; i < lines.length; i += 1) {
+    const headingMatch = lines[i].match(/^(#{1,6})\s+(.+?)\s*$/);
+    if (!headingMatch) {
+      continue;
+    }
+    const level = headingMatch[1].length;
+    if (level <= match.level) {
+      endIndex = i;
+      break;
+    }
+  }
+
+  return { start: match.index, end: endIndex };
+}
+
+function getEntriesInSection(section) {
+  const resolved = resolveSection(section);
+  const content = loadPreferences();
+  const lines = content.split(/\r?\n/);
+  const target = parseSectionTarget(resolved);
+  const match = findSection(lines, target);
+
+  if (!match) {
+    return [];
+  }
+
+  const range = getSectionRange(lines, match);
+  const entries = [];
+
+  for (let i = match.index + 1; i < range.end; i += 1) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    if (!trimmed || isCommentLine(trimmed) || isHeadingLine(trimmed)) {
+      continue;
+    }
+
+    entries.push(trimmed);
+  }
+
+  return entries;
+}
+
+function setEntry(section, entry) {
+  if (typeof entry !== 'string' || !entry.trim()) {
+    throw new Error('Entry text is required');
+  }
+
+  const resolved = resolveSection(section);
+  const normalized = normalizeEntry(entry);
+  const entries = getEntriesInSection(resolved);
+  const existed = entries.some((existing) => existing === normalized);
+
+  if (existed) {
+    return {
+      added: false,
+      existed: true,
+      section: resolved,
+      entry: normalized
+    };
+  }
+
+  appendToSection(resolved, normalized);
+  return {
+    added: true,
+    existed: false,
+    section: resolved,
+    entry: normalized
+  };
+}
+
+function removeFromSection(section, { match, entry } = {}) {
+  const hasMatch = typeof match === 'string' && match.trim();
+  const hasEntry = typeof entry === 'string' && entry.trim();
+
+  if (!hasMatch && !hasEntry) {
+    throw new Error('Match or entry is required');
+  }
+  if (hasMatch && hasEntry) {
+    throw new Error('Use either match or entry, not both');
+  }
+
+  const resolved = resolveSection(section);
+  const content = loadPreferences();
+  const lines = content.split(/\r?\n/);
+  const target = parseSectionTarget(resolved);
+  const sectionMatch = findSection(lines, target);
+
+  if (!sectionMatch) {
+    return { removed: false, count: 0, entries: [], section: resolved };
+  }
+
+  const range = getSectionRange(lines, sectionMatch);
+  const sectionLines = lines.slice(sectionMatch.index + 1, range.end);
+  const removedEntries = [];
+  const normalizedEntry = hasEntry ? normalizeEntry(entry) : null;
+  const matchNeedle = hasMatch ? match.trim().toLowerCase() : null;
+
+  const updatedSectionLines = sectionLines.filter((line) => {
+    const trimmed = line.trim();
+
+    if (!trimmed || isCommentLine(trimmed) || isHeadingLine(trimmed)) {
+      return true;
+    }
+
+    const matches = normalizedEntry
+      ? trimmed === normalizedEntry
+      : trimmed.toLowerCase().includes(matchNeedle);
+
+    if (matches) {
+      removedEntries.push(trimmed);
+      return false;
+    }
+
+    return true;
+  });
+
+  if (removedEntries.length === 0) {
+    return { removed: false, count: 0, entries: [], section: resolved };
+  }
+
+  const updatedLines = [
+    ...lines.slice(0, sectionMatch.index + 1),
+    ...updatedSectionLines,
+    ...lines.slice(range.end)
+  ];
+
+  savePreferences(updatedLines.join('\n'));
+  return {
+    removed: true,
+    count: removedEntries.length,
+    entries: removedEntries,
+    section: resolved
+  };
+}
+
 function appendToSection(section, text) {
   if (typeof text !== 'string' || !text.trim()) {
     throw new Error('Append text is required');
@@ -140,7 +315,7 @@ function appendToSection(section, text) {
 
   let insertIndex = lines.length;
   for (let i = match.index + 1; i < lines.length; i += 1) {
-    const headingMatch = lines[i].match(/^(#{1,6})\s*(.+?)\s*$/);
+    const headingMatch = lines[i].match(/^(#{1,6})\s+(.+?)\s*$/);
     if (!headingMatch) {
       continue;
     }
@@ -167,6 +342,10 @@ module.exports = {
   getPreferencesPath,
   loadPreferences,
   savePreferences,
+  resolveSection,
+  setEntry,
+  removeFromSection,
+  getEntriesInSection,
   appendToSection,
   resetPreferences,
   validatePreferences,