scoops 0.1.0

package/src/lib/merge-settings.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const ASCR_HOOK_MARKER = 'ascr/hooks';
+
+const ASCR_HOOKS = {
+  SessionStart: {
+    matcher: '',
+    hooks: [{ type: 'command', command: 'node .ascr/hooks/session-start.js', timeout: 10 }],
+  },
+  UserPromptSubmit: {
+    matcher: '',
+    hooks: [{ type: 'command', command: 'node .ascr/hooks/prompt-retriever.js', timeout: 10 }],
+  },
+  Stop: {
+    matcher: '',
+    hooks: [{ type: 'command', command: 'node .ascr/hooks/stop-gate.js', timeout: 15, blocking: true }],
+  },
+};
+
+// Returns true if a hook entry looks like an ASCR hook
+function isAscrHook(entry) {
+  return (entry.hooks || []).some(h => h.command && h.command.includes(ASCR_HOOK_MARKER));
+}
+
+// Deep-merge ASCR hooks into an existing settings object without clobbering anything
+function mergeHooksIntoSettings(existing = {}) {
+  const result = JSON.parse(JSON.stringify(existing)); // deep clone
+  if (!result.hooks) result.hooks = {};
+
+  for (const [event, hookEntry] of Object.entries(ASCR_HOOKS)) {
+    if (!result.hooks[event]) {
+      // Event not present at all — add it
+      result.hooks[event] = [hookEntry];
+    } else {
+      // Event exists — check if ASCR hook is already there
+      const existingIdx = result.hooks[event].findIndex(isAscrHook);
+      if (existingIdx === -1) {
+        // Not present — append
+        result.hooks[event].push(hookEntry);
+      } else {
+        // Already present — update in place (idempotent re-init)
+        result.hooks[event][existingIdx] = hookEntry;
+      }
+    }
+  }
+
+  return result;
+}
+
+// Returns the list of events ASCR hooks are registered under (for status checks)
+function getAscrHookEvents(settings = {}) {
+  const registered = [];
+  for (const [event, entries] of Object.entries(settings.hooks || {})) {
+    if ((entries || []).some(isAscrHook)) registered.push(event);
+  }
+  return registered;
+}
+
+module.exports = { mergeHooksIntoSettings, getAscrHookEvents, ASCR_HOOKS };

package/src/lib/paths.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const { join } = require('node:path');
+
+const ascrDir      = (cwd) => join(cwd, '.ascr');
+const hooksDir     = (cwd) => join(cwd, '.ascr', 'hooks');
+const decisionsFile    = (cwd) => join(cwd, '.ascr', 'decisions.json');
+const architectureFile = (cwd) => join(cwd, '.ascr', 'architecture.json');
+const threadsFile      = (cwd) => join(cwd, '.ascr', 'threads.json');
+const warningsFile     = (cwd) => join(cwd, '.ascr', 'warnings.json');
+const indexFile        = (cwd) => join(cwd, '.ascr', 'index.json');
+const gitignoreFile    = (cwd) => join(cwd, '.ascr', '.gitignore');
+const sessionHashFile  = (cwd, sessionId) => join(cwd, '.ascr', `.session-hash-${sessionId}`);
+const claudeDir        = (cwd) => join(cwd, '.claude');
+const settingsFile     = (cwd) => join(cwd, '.claude', 'settings.json');
+
+const KNOWLEDGE_FILES = (cwd) => ({
+  decisions:    decisionsFile(cwd),
+  architecture: architectureFile(cwd),
+  threads:      threadsFile(cwd),
+  warnings:     warningsFile(cwd),
+  index:        indexFile(cwd),
+});
+
+module.exports = {
+  ascrDir,
+  hooksDir,
+  decisionsFile,
+  architectureFile,
+  threadsFile,
+  warningsFile,
+  indexFile,
+  gitignoreFile,
+  sessionHashFile,
+  claudeDir,
+  settingsFile,
+  KNOWLEDGE_FILES,
+};

package/src/lib/scoring.js

@@ -0,0 +1,60 @@
+'use strict';
+
+// Common English stop words to exclude from keyword extraction
+const STOP_WORDS = new Set([
+  'a', 'an', 'the', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
+  'of', 'with', 'by', 'from', 'is', 'it', 'its', 'be', 'as', 'are',
+  'was', 'were', 'been', 'has', 'have', 'had', 'do', 'does', 'did',
+  'will', 'would', 'could', 'should', 'may', 'might', 'can', 'i', 'we',
+  'you', 'he', 'she', 'they', 'this', 'that', 'these', 'those', 'what',
+  'how', 'why', 'when', 'where', 'which', 'who', 'not', 'no', 'so',
+  'if', 'then', 'else', 'my', 'our', 'your', 'their', 'me', 'us',
+  'add', 'make', 'create', 'update', 'get', 'set', 'use', 'using',
+  'want', 'need', 'please', 'help', 'let', 'just', 'also', 'now',
+  'like', 'new', 'old', 'all', 'some', 'any', 'into', 'out', 'up',
+]);
+
+// Extract meaningful keywords from a prompt string
+function extractKeywords(prompt) {
+  return prompt
+    .toLowerCase()
+    .replace(/[^a-z0-9\s\-_]/g, ' ')   // strip punctuation
+    .split(/[\s\-_]+/)                   // split on whitespace and separators
+    .map(w => w.trim())
+    .filter(w => w.length >= 3 && !STOP_WORDS.has(w))
+    .filter((w, i, arr) => arr.indexOf(w) === i); // dedupe
+}
+
+// Format a retrieved knowledge entry as concise injected text
+function formatEntry(type, entry) {
+  const lines = [];
+  switch (type) {
+    case 'decisions':
+      lines.push(`[Decision] ${entry.decision}`);
+      if (entry.why) lines.push(`  Why: ${entry.why}`);
+      if (entry.alternatives_rejected?.length) lines.push(`  Rejected: ${entry.alternatives_rejected.join(', ')}`);
+      if (entry.affects?.length) lines.push(`  Affects: ${entry.affects.join(', ')}`);
+      break;
+    case 'architecture':
+      lines.push(`[Architecture] ${entry.component} (${entry.location || 'location unknown'})`);
+      if (entry.does) lines.push(`  ${entry.does}`);
+      if (entry.depends_on?.length) lines.push(`  Depends on: ${entry.depends_on.join(', ')}`);
+      if (entry.depended_by?.length) lines.push(`  Used by: ${entry.depended_by.join(', ')}`);
+      if (entry.gotchas?.length) lines.push(`  Gotcha: ${entry.gotchas.join(' | ')}`);
+      break;
+    case 'threads':
+      lines.push(`[Thread] ${entry.thread} — ${(entry.status || 'unknown').toUpperCase()}`);
+      if (entry.done?.length) lines.push(`  Done: ${entry.done.join(', ')}`);
+      if (entry.remaining?.length) lines.push(`  Remaining: ${entry.remaining.join(', ')}`);
+      if (entry.blocked_by) lines.push(`  Blocked by: ${entry.blocked_by}`);
+      break;
+    case 'warnings':
+      lines.push(`[Warning] ${entry.warning}`);
+      if (entry.context) lines.push(`  Context: ${entry.context}`);
+      if (entry.avoid) lines.push(`  Avoid: ${entry.avoid}`);
+      break;
+  }
+  return lines.join('\n');
+}
+
+module.exports = { extractKeywords, formatEntry };