metame-cli 1.4.15 → 1.4.18

package/scripts/utils.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const crypto = require('crypto');
 
 /**
  * utils.js — Pure utility functions extracted for testability.
@@ -30,6 +31,9 @@ async function writeBrainFileSafe(content, brainFile = BRAIN_FILE_DEFAULT) {
   const retryDelay = 150; // ms between retries
   const staleTimeout = 30000; // 30s: lock older than this is stale
 
+  const lockDir = path.dirname(BRAIN_LOCK_FILE);
+  if (!fs.existsSync(lockDir)) fs.mkdirSync(lockDir, { recursive: true });
+
   let acquired = false;
   for (let i = 0; i < maxRetries; i++) {
     try {
@@ -49,6 +53,10 @@ async function writeBrainFileSafe(content, brainFile = BRAIN_FILE_DEFAULT) {
     }
   }
 
+  if (!acquired) {
+    throw new Error('Failed to acquire brain.lock for profile write');
+  }
+
   const tmp = brainFile + '.tmp.' + process.pid;
   try {
     fs.writeFileSync(tmp, content, 'utf8');
@@ -118,10 +126,109 @@ function createPathMap() {
   return { shortenPath, expandPath };
 }
 
+// ---------------------------------------------------------
+// PROJECT SCOPE (stable workspace identity)
+// ---------------------------------------------------------
+function normalizeProjectPath(cwd) {
+  if (!cwd || typeof cwd !== 'string') return null;
+  const trimmed = cwd.trim();
+  if (!trimmed) return null;
+
+  const expanded = trimmed.startsWith('~')
+    ? path.join(os.homedir(), trimmed.slice(1))
+    : trimmed;
+
+  const resolved = path.resolve(expanded);
+  try {
+    return fs.realpathSync.native ? fs.realpathSync.native(resolved) : fs.realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+
+function projectScopeFromCwd(cwd) {
+  const normalized = normalizeProjectPath(cwd);
+  if (!normalized) return null;
+  const digest = crypto.createHash('sha1').update(normalized).digest('hex').slice(0, 16);
+  return `proj_${digest}`;
+}
+
+function deriveProjectInfo(cwd) {
+  const projectPath = normalizeProjectPath(cwd);
+  if (!projectPath) return { project: null, project_id: null, project_path: null };
+  return {
+    project: path.basename(projectPath),
+    project_id: projectScopeFromCwd(projectPath),
+    project_path: projectPath,
+  };
+}
+
+// ---------------------------------------------------------
+// TOPIC DRIFT HELPERS
+// ---------------------------------------------------------
+function buildTopicSignature(text, maxTokens = 16) {
+  const input = String(text || '').toLowerCase();
+  if (!input) return [];
+
+  const stop = new Set(['help', 'please', 'this', 'that', 'with', 'from', 'into', 'have', 'been', 'will', 'just']);
+  const seen = new Set();
+  const tokens = [];
+  const push = (token) => {
+    const t = String(token || '').trim();
+    if (!t || seen.has(t) || stop.has(t)) return;
+    seen.add(t);
+    tokens.push(t);
+  };
+
+  // ASCII-like identifiers, commands, paths
+  const ascii = input.match(/[a-z0-9_./-]{2,}/g) || [];
+  for (const t of ascii) {
+    push(t);
+    if (tokens.length >= maxTokens) return tokens;
+  }
+
+  // Chinese: use 2-char shingles so short prompts still produce enough features.
+  const hanRuns = input.match(/[\u4e00-\u9fff]{2,}/g) || [];
+  for (const run of hanRuns) {
+    if (run.length === 2) {
+      push(run);
+    } else {
+      for (let i = 0; i < run.length - 1; i++) {
+        push(run.slice(i, i + 2));
+        if (tokens.length >= maxTokens) return tokens;
+      }
+    }
+    if (tokens.length >= maxTokens) return tokens;
+  }
+
+  return tokens;
+}
+
+function hasTopicDrift(prevSig, currSig, minTokens = 3, threshold = 0.25) {
+  if (!Array.isArray(prevSig) || !Array.isArray(currSig)) return false;
+  if (prevSig.length < minTokens || currSig.length < minTokens) return false;
+  const a = new Set(prevSig);
+  const b = new Set(currSig);
+  let common = 0;
+  for (const t of a) if (b.has(t)) common++;
+  const minBase = Math.min(a.size, b.size) || 1;
+  const overlapByMin = common / minBase;
+  if (overlapByMin >= 0.34) return false;
+  const union = a.size + b.size - common;
+  if (union <= 0) return false;
+  const jaccard = common / union;
+  return jaccard < threshold;
+}
+
 module.exports = {
   parseInterval,
   formatRelativeTime,
   createPathMap,
+  normalizeProjectPath,
+  projectScopeFromCwd,
+  deriveProjectInfo,
+  buildTopicSignature,
+  hasTopicDrift,
   writeBrainFileSafe,
   BRAIN_LOCK_FILE,
 };

package/scripts/utils.test.js

@@ -2,7 +2,16 @@
 
 const { describe, it, beforeEach } = require('node:test');
 const assert = require('node:assert/strict');
-const { parseInterval, formatRelativeTime, createPathMap } = require('./utils');
+const {
+  parseInterval,
+  formatRelativeTime,
+  createPathMap,
+  normalizeProjectPath,
+  projectScopeFromCwd,
+  deriveProjectInfo,
+  buildTopicSignature,
+  hasTopicDrift,
+} = require('./utils');
 
 // ---------------------------------------------------------
 // parseInterval
@@ -123,3 +132,54 @@ describe('createPathMap', () => {
     assert.ok(Buffer.byteLength(id) < 10, `id "${id}" too long`);
   });
 });
+
+// ---------------------------------------------------------
+// project scope helpers
+// ---------------------------------------------------------
+describe('project scope helpers', () => {
+  it('normalizes absolute paths', () => {
+    assert.equal(normalizeProjectPath('/tmp/./metame/../metame'), '/tmp/metame');
+  });
+
+  it('returns deterministic scope ids for the same cwd', () => {
+    const a = projectScopeFromCwd('/tmp/metame');
+    const b = projectScopeFromCwd('/tmp/./metame');
+    assert.equal(a, b);
+    assert.match(a, /^proj_[a-f0-9]{16}$/);
+  });
+
+  it('derives project info from cwd', () => {
+    const info = deriveProjectInfo('/tmp/demo-repo');
+    assert.equal(info.project, 'demo-repo');
+    assert.equal(info.project_path, '/tmp/demo-repo');
+    assert.match(info.project_id, /^proj_[a-f0-9]{16}$/);
+  });
+});
+
+// ---------------------------------------------------------
+// topic drift helpers
+// ---------------------------------------------------------
+describe('topic drift helpers', () => {
+  it('extracts signature tokens for Chinese prompts', () => {
+    const sig = buildTopicSignature('修复登录超时并优化缓存策略');
+    assert.ok(sig.length >= 3, `expected >=3 tokens, got ${sig.length}`);
+  });
+
+  it('extracts signature tokens for mixed Chinese/English prompts', () => {
+    const sig = buildTopicSignature('修复 daemon memory-extract timeout');
+    assert.ok(sig.includes('daemon'));
+    assert.ok(sig.some(t => /[\u4e00-\u9fff]/.test(t)));
+  });
+
+  it('detects drift when signatures diverge', () => {
+    const a = buildTopicSignature('修复登录超时和重试策略');
+    const b = buildTopicSignature('重构支付流水和对账报表');
+    assert.equal(hasTopicDrift(a, b), true);
+  });
+
+  it('does not flag drift for similar topics', () => {
+    const a = buildTopicSignature('优化 memory 检索和缓存命中');
+    const b = buildTopicSignature('memory 检索改进与缓存策略');
+    assert.equal(hasTopicDrift(a, b), false);
+  });
+});