codemini-cli 0.3.8 → 0.4.0

package/src/core/fff-adapter.js

@@ -0,0 +1,386 @@
+import { spawn } from 'node:child_process';
+import { LANGUAGE_FILE_TYPES } from './constants.js';
+
+const DEFAULT_COMMAND = 'fff-mcp';
+const DEFAULT_TIMEOUT_MS = 15_000;
+
+function clampNumber(value, min, max, fallback) {
+  const num = Number(value);
+  if (!Number.isFinite(num)) return fallback;
+  return Math.min(max, Math.max(min, num));
+}
+
+function encodeMessage(payload) {
+  const body = Buffer.from(JSON.stringify(payload), 'utf8');
+  return Buffer.concat([
+    Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, 'utf8'),
+    body
+  ]);
+}
+
+function createMessageParser(onMessage) {
+  let buffer = Buffer.alloc(0);
+  return (chunk) => {
+    buffer = Buffer.concat([buffer, Buffer.from(chunk)]);
+    while (buffer.length > 0) {
+      const headerEnd = buffer.indexOf('\r\n\r\n');
+      if (headerEnd < 0) return;
+      const headerText = buffer.slice(0, headerEnd).toString('utf8');
+      const match = headerText.match(/Content-Length:\s*(\d+)/i);
+      if (!match) {
+        buffer = Buffer.alloc(0);
+        return;
+      }
+      const bodyLength = Number(match[1]);
+      const totalLength = headerEnd + 4 + bodyLength;
+      if (buffer.length < totalLength) return;
+      const body = buffer.slice(headerEnd + 4, totalLength).toString('utf8');
+      buffer = buffer.slice(totalLength);
+      try {
+        onMessage(JSON.parse(body));
+      } catch {
+        // Ignore malformed frames.
+      }
+    }
+  };
+}
+
+class FffMcpClient {
+  constructor({ workspaceRoot, command, timeoutMs }) {
+    this.workspaceRoot = workspaceRoot;
+    this.command = command;
+    this.timeoutMs = timeoutMs;
+    this.child = null;
+    this.pending = new Map();
+    this.nextId = 1;
+    this.connectPromise = null;
+    this.connected = false;
+    this.closed = false;
+    this.parser = createMessageParser((message) => this.handleMessage(message));
+  }
+
+  handleMessage(message) {
+    if (!message || typeof message !== 'object') return;
+    if (typeof message.id !== 'number') return;
+    const pending = this.pending.get(message.id);
+    if (!pending) return;
+    this.pending.delete(message.id);
+    if (message.error) {
+      pending.reject(new Error(String(message.error?.message || 'Unknown MCP error')));
+      return;
+    }
+    pending.resolve(message.result);
+  }
+
+  async connect() {
+    if (this.connected) return;
+    if (this.connectPromise) return this.connectPromise;
+    this.connectPromise = this.start();
+    try {
+      await this.connectPromise;
+      this.connected = true;
+    } finally {
+      this.connectPromise = null;
+    }
+  }
+
+  async start() {
+    if (this.closed) {
+      throw new Error('FFF MCP client already disposed');
+    }
+    this.child = spawn(this.command, [], {
+      cwd: this.workspaceRoot,
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    this.child.stdout.on('data', this.parser);
+    this.child.stderr.on('data', () => {});
+    this.child.on('error', (error) => {
+      this.rejectAll(error);
+    });
+    this.child.on('exit', (code) => {
+      this.connected = false;
+      this.child = null;
+      if (!this.closed && code !== 0) {
+        this.rejectAll(new Error(`FFF MCP exited with code ${code}`));
+      }
+    });
+
+    await this.sendRequest('initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: {
+        name: 'codemini-cli',
+        version: '0.4.0'
+      }
+    });
+    this.sendNotification('notifications/initialized', {});
+  }
+
+  rejectAll(error) {
+    for (const { reject, timer } of this.pending.values()) {
+      clearTimeout(timer);
+      reject(error);
+    }
+    this.pending.clear();
+  }
+
+  sendNotification(method, params) {
+    if (!this.child?.stdin) throw new Error('FFF MCP client is not connected');
+    this.child.stdin.write(
+      encodeMessage({
+        jsonrpc: '2.0',
+        method,
+        params
+      })
+    );
+  }
+
+  sendRequest(method, params) {
+    if (!this.child?.stdin) {
+      return Promise.reject(new Error('FFF MCP client is not connected'));
+    }
+    return new Promise((resolve, reject) => {
+      const id = this.nextId++;
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`FFF MCP request timed out after ${this.timeoutMs}ms`));
+      }, this.timeoutMs);
+      this.pending.set(id, {
+        resolve: (result) => {
+          clearTimeout(timer);
+          resolve(result);
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        },
+        timer
+      });
+      this.child.stdin.write(
+        encodeMessage({
+          jsonrpc: '2.0',
+          id,
+          method,
+          params
+        })
+      );
+    });
+  }
+
+  async callTool(name, args) {
+    await this.connect();
+    return this.sendRequest('tools/call', {
+      name,
+      arguments: args
+    });
+  }
+
+  async dispose() {
+    this.closed = true;
+    this.connected = false;
+    if (this.child?.stdin) {
+      try {
+        this.child.stdin.end();
+      } catch {}
+    }
+    if (this.child && !this.child.killed) {
+      this.child.kill();
+    }
+    this.child = null;
+    this.rejectAll(new Error('FFF MCP client disposed'));
+  }
+}
+
+function extractTextContent(result) {
+  const content = Array.isArray(result?.content) ? result.content : [];
+  return content
+    .filter((item) => item?.type === 'text' && typeof item?.text === 'string')
+    .map((item) => item.text)
+    .join('\n')
+    .trim();
+}
+
+function stripFffFileSuffix(line) {
+  return String(line || '')
+    .replace(/\s+-\s+(?:hot|warm|frequent)(?:\s+git:[a-z_]+)?$/i, '')
+    .replace(/\s+git:[a-z_]+$/i, '')
+    .trim();
+}
+
+function parseFindFilesOutput(text) {
+  const lines = String(text || '')
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .filter(Boolean);
+  const matches = [];
+  for (const line of lines) {
+    if (
+      line.startsWith('→ ') ||
+      line.startsWith('cursor:') ||
+      /^\d+\/\d+\s+matches$/i.test(line) ||
+      /^0 results\b/i.test(line)
+    ) {
+      continue;
+    }
+    const normalized = stripFffFileSuffix(line);
+    if (normalized) matches.push(normalized);
+  }
+  return matches;
+}
+
+function parseGrepOutput(text, fallbackPattern = '') {
+  const lines = String(text || '')
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .filter(Boolean);
+  const matches = [];
+  let currentPath = '';
+  for (const line of lines) {
+    if (
+      line.startsWith('→ ') ||
+      line.startsWith('cursor:') ||
+      /^! regex failed:/i.test(line) ||
+      /^\d+\/\d+\s+matches shown$/i.test(line) ||
+      /^0 (?:exact )?matches\b/i.test(line) ||
+      /^Auto-broadened to\b/i.test(line)
+    ) {
+      continue;
+    }
+    const sectionMatch = line.match(/^\s*(\d+)\s*[:|-]\s*(.*)$/);
+    if (sectionMatch && currentPath) {
+      const [, lineNumber, preview] = sectionMatch;
+      matches.push({
+        path: currentPath,
+        line: Number(lineNumber),
+        column: 1,
+        preview: String(preview || '').trim()
+      });
+      continue;
+    }
+    const fileCandidate = stripFffFileSuffix(line);
+    if (fileCandidate && !/^\d/.test(fileCandidate)) {
+      currentPath = fileCandidate;
+    }
+  }
+  return {
+    pattern: fallbackPattern,
+    matches,
+    truncated: /cursor:/i.test(text)
+  };
+}
+
+function normalizePathPrefix(value) {
+  const text = String(value || '').trim().replace(/\\/g, '/').replace(/^\.\/+/, '');
+  if (!text || text === '.') return '';
+  return text.endsWith('/') ? text : `${text}/`;
+}
+
+function buildGrepQuery(pattern, args = {}) {
+  const pieces = [];
+  const pathPrefix = normalizePathPrefix(args.path);
+  if (pathPrefix) pieces.push(pathPrefix);
+  const fileTypes = Array.isArray(args.file_types) ? args.file_types : [];
+  const language = String(args.language || '').trim().toLowerCase();
+  const mergedTypes = [...new Set([...fileTypes, ...(LANGUAGE_FILE_TYPES[language] || [])])];
+  if (mergedTypes.length === 1) {
+    pieces.push(`*.${mergedTypes[0]}`);
+  } else if (mergedTypes.length > 1) {
+    pieces.push(`*.{${mergedTypes.join(',')}}`);
+  }
+  pieces.push(String(pattern || '').trim());
+  return pieces.filter(Boolean).join(' ');
+}
+
+function buildImmediateItems(relativePath, filePaths, includeHidden = false) {
+  const prefix = normalizePathPrefix(relativePath);
+  const directories = new Set();
+  const files = new Set();
+  for (const filePath of filePaths) {
+    const normalized = String(filePath || '').replace(/\\/g, '/');
+    if (!normalized.startsWith(prefix)) continue;
+    const remainder = normalized.slice(prefix.length);
+    if (!remainder) continue;
+    const [head, ...rest] = remainder.split('/');
+    if (!head) continue;
+    if (!includeHidden && head.startsWith('.')) continue;
+    if (rest.length > 0) {
+      directories.add(head);
+    } else {
+      files.add(head);
+    }
+  }
+  const dirItems = [...directories].sort((a, b) => a.localeCompare(b)).map((name) => ({
+    name,
+    path: `${prefix}${name}`.replace(/\/$/, ''),
+    type: 'dir'
+  }));
+  const fileItems = [...files].sort((a, b) => a.localeCompare(b)).map((name) => ({
+    name,
+    path: `${prefix}${name}`,
+    type: 'file'
+  }));
+  return [...dirItems, ...fileItems];
+}
+
+export function createFffAdapter({ workspaceRoot, config }) {
+  const command = String(config?.search?.fff_command || config?.tooling?.fff_command || DEFAULT_COMMAND).trim() || DEFAULT_COMMAND;
+  const timeoutMs = clampNumber(
+    config?.search?.fff_timeout_ms || config?.tooling?.fff_timeout_ms,
+    1_000,
+    120_000,
+    DEFAULT_TIMEOUT_MS
+  );
+  const client = new FffMcpClient({ workspaceRoot, command, timeoutMs });
+
+  return {
+    async connect() {
+      await client.connect();
+    },
+
+    async grep(args) {
+      const pattern = String(args?.pattern || '').trim();
+      if (!pattern) return null;
+      const result = await client.callTool('grep', {
+        query: buildGrepQuery(pattern, args),
+        max_results: clampNumber(args?.max_results, 1, 200, 50)
+      });
+      return parseGrepOutput(extractTextContent(result), pattern);
+    },
+
+    async glob(args) {
+      const pattern = String(args?.pattern || '').trim();
+      if (!pattern) return null;
+      const limit = clampNumber(args?.max_results, 1, 500, 200);
+      const result = await client.callTool('find_files', {
+        query: pattern,
+        max_results: limit
+      });
+      const matches = parseFindFilesOutput(extractTextContent(result));
+      return {
+        pattern,
+        matches,
+        truncated: matches.length >= limit
+      };
+    },
+
+    async list(args) {
+      const relativePath = String(args?.path || '.').trim();
+      if (!relativePath || relativePath === '.') return null;
+      const result = await client.callTool('find_files', {
+        query: normalizePathPrefix(relativePath),
+        max_results: 500
+      });
+      const filePaths = parseFindFilesOutput(extractTextContent(result));
+      return {
+        path: relativePath,
+        items: buildImmediateItems(relativePath, filePaths, Boolean(args?.include_hidden))
+      };
+    },
+
+    async dispose() {
+      await client.dispose();
+    }
+  };
+}
+

package/src/core/memory-prompt.js

@@ -11,6 +11,15 @@ function renderScope(title, items = []) {
   return `${title}\n${lines.join('\n')}`;
 }
 
+function renderLifecycleGroup(title, items = []) {
+  if (!Array.isArray(items) || items.length === 0) return '';
+  const lines = items.map((item) => {
+    const prefix = item.lifecycle ? `[${item.lifecycle}]` : '';
+    return `- ${prefix} ${JSON.stringify(String(item.summary || item.content || ''))}`;
+  });
+  return `${title}\n${lines.join('\n')}`;
+}
+
 export async function buildMemorySnapshot({
   config = {},
   workspaceRoot = process.cwd()
@@ -24,12 +33,26 @@ export async function buildMemorySnapshot({
   ]);
 
   const maxItems = Math.max(1, Number(config?.memory?.max_items_per_scope || 12));
+
+  // Separate lifecycle-tagged items for projections
+  const allItems = [...user, ...globalItems, ...project];
+  const operational = allItems.filter((item) => item.lifecycle === 'operational');
+  const longterm = allItems.filter((item) => item.lifecycle === 'longterm');
+
   const sections = [
     renderScope('User Memory:', user.slice(0, maxItems)),
     renderScope('Global Memory:', globalItems.slice(0, maxItems)),
     renderScope('Project Memory:', project.slice(0, maxItems))
   ].filter(Boolean);
 
+  // Add lifecycle projection sections
+  if (operational.length > 0) {
+    sections.push(renderLifecycleGroup('Active Guidance (Operational — temporary but important for current phase):', operational));
+  }
+  if (longterm.length > 0) {
+    sections.push(renderLifecycleGroup('Stable Learnings (LongTerm — proven patterns across tasks):', longterm));
+  }
+
   if (sections.length === 0) return '';
 
   const snapshot = [

package/src/core/memory-store.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { sha256 } from './crypto-utils.js';
-import { getMemoryDir, getProjectMemoryDir } from './paths.js';
+import { getMemoryDir, getProjectMemoryDir, getInboxDir, getArchiveDir } from './paths.js';
 import { assertSafeMemoryContent, normalizeMemoryText, summarizeMemoryContent } from './memory-policy.js';
 
 const ALLOWED_SCOPES = new Set(['user', 'global', 'project']);
@@ -179,3 +179,230 @@ export async function searchMemories({ scope, query, workspaceRoot = process.cwd
   if (!needle) return items;
   return items.filter((item) => item.content.toLowerCase().includes(needle) || item.summary.toLowerCase().includes(needle));
 }
+
+// ---------------------------------------------------------------------------
+// Dream Loop: inbox capture, lifecycle, archive, promotion
+// ---------------------------------------------------------------------------
+
+const VALID_LIFECYCLE = new Set(['observed', 'candidate', 'operational', 'longterm', 'archived']);
+const VALID_INBOX_SCOPES = new Set(['global', 'repo', 'thread', 'project', 'user']);
+
+function validateLifecycle(value) {
+  const lc = String(value || '').trim().toLowerCase();
+  if (!VALID_LIFECYCLE.has(lc)) throw new Error(`Invalid lifecycle state: ${value}`);
+  return lc;
+}
+
+function normalizeInboxScope(value) {
+  const scope = String(value || 'global').trim().toLowerCase();
+  if (!VALID_INBOX_SCOPES.has(scope)) throw new Error(`Unsupported inbox scope: ${value}`);
+  return scope;
+}
+
+function todayDir(baseDir) {
+  const date = new Date().toISOString().slice(0, 10);
+  return path.join(baseDir, date);
+}
+
+async function readJsonArray(filePath) {
+  try {
+    const raw = await fs.readFile(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+async function writeJsonArray(filePath, items) {
+  await ensureParent(filePath);
+  await fs.writeFile(filePath, `${JSON.stringify(items, null, 2)}\n`, 'utf8');
+}
+
+export async function captureToInbox({
+  scope = 'global',
+  type = 'observation',
+  summary,
+  details = '',
+  suggestedAction = '',
+  tags = [],
+  source = 'tool'
+} = {}) {
+  const normalizedSummary = normalizeMemoryText(summary);
+  if (!normalizedSummary) throw new Error('Inbox capture summary is required');
+  assertSafeMemoryContent(normalizedSummary);
+
+  const dir = todayDir(getInboxDir());
+  await fs.mkdir(dir, { recursive: true });
+  const now = nowIso();
+  const id = `inbox_${sha256(`${normalizedSummary}:${now}:${Math.random()}`).slice(0, 12)}`;
+  const entry = {
+    id,
+    timestamp: now,
+    scope: normalizeInboxScope(scope),
+    source,
+    type: String(type || 'observation').trim().toLowerCase(),
+    summary: normalizedSummary,
+    details: normalizeMemoryText(details),
+    suggestedAction: normalizeMemoryText(suggestedAction),
+    tags: Array.isArray(tags) ? tags.map((t) => String(t).trim()).filter(Boolean) : [],
+    lifecycle: 'observed'
+  };
+
+  const indexPath = path.join(dir, 'index.json');
+  const entries = await readJsonArray(indexPath);
+  entries.push(entry);
+  await writeJsonArray(indexPath, entries);
+  return entry;
+}
+
+export async function listInbox({ since, scope } = {}) {
+  const inboxBase = getInboxDir();
+  let dayDirs;
+  try {
+    const entries = await fs.readdir(inboxBase);
+    dayDirs = entries.filter((e) => /^\d{4}-\d{2}-\d{2}$/.test(e)).sort();
+  } catch {
+    return [];
+  }
+  if (since) {
+    const sinceStr = String(since).slice(0, 10);
+    dayDirs = dayDirs.filter((d) => d >= sinceStr);
+  }
+  const all = [];
+  for (const day of dayDirs) {
+    const indexPath = path.join(inboxBase, day, 'index.json');
+    const entries = await readJsonArray(indexPath);
+    all.push(...entries);
+  }
+  if (scope) {
+    const sc = String(scope).trim().toLowerCase();
+    return all.filter((e) => e.scope === sc);
+  }
+  return all;
+}
+
+export async function updateInboxEntry(id, updates = {}) {
+  const inboxBase = getInboxDir();
+  let dayDirs;
+  try {
+    dayDirs = (await fs.readdir(inboxBase)).filter((e) => /^\d{4}-\d{2}-\d{2}$/.test(e)).sort();
+  } catch {
+    return null;
+  }
+  for (const day of dayDirs) {
+    const indexPath = path.join(inboxBase, day, 'index.json');
+    const entries = await readJsonArray(indexPath);
+    const idx = entries.findIndex((e) => e.id === id);
+    if (idx === -1) continue;
+    if (updates.lifecycle) updates.lifecycle = validateLifecycle(updates.lifecycle);
+    entries[idx] = { ...entries[idx], ...updates };
+    await writeJsonArray(indexPath, entries);
+    return entries[idx];
+  }
+  return null;
+}
+
+export async function removeInboxEntry(id) {
+  const inboxBase = getInboxDir();
+  let dayDirs;
+  try {
+    dayDirs = (await fs.readdir(inboxBase)).filter((e) => /^\d{4}-\d{2}-\d{2}$/.test(e)).sort();
+  } catch {
+    return false;
+  }
+  for (const day of dayDirs) {
+    const indexPath = path.join(inboxBase, day, 'index.json');
+    const entries = await readJsonArray(indexPath);
+    const idx = entries.findIndex((e) => e.id === id);
+    if (idx === -1) continue;
+    entries.splice(idx, 1);
+    await writeJsonArray(indexPath, entries);
+    return true;
+  }
+  return false;
+}
+
+export async function archiveEntry(entry, reason = '', auditNote = '') {
+  const archiveDir = getArchiveDir();
+  const date = new Date().toISOString().slice(0, 10);
+  const dir = path.join(archiveDir, date);
+  await fs.mkdir(dir, { recursive: true });
+  const archived = {
+    ...entry,
+    lifecycle: 'archived',
+    archivedAt: nowIso(),
+    archiveReason: normalizeMemoryText(reason),
+    auditNote: normalizeMemoryText(auditNote)
+  };
+  const indexPath = path.join(dir, 'index.json');
+  const entries = await readJsonArray(indexPath);
+  entries.push(archived);
+  await writeJsonArray(indexPath, entries);
+  await removeInboxEntry(entry.id);
+  return archived;
+}
+
+export async function listArchive({ since, scope } = {}) {
+  const archiveBase = getArchiveDir();
+  let dayDirs;
+  try {
+    const entries = await fs.readdir(archiveBase);
+    dayDirs = entries.filter((e) => /^\d{4}-\d{2}-\d{2}$/.test(e)).sort();
+  } catch {
+    return [];
+  }
+  if (since) {
+    const sinceStr = String(since).slice(0, 10);
+    dayDirs = dayDirs.filter((d) => d >= sinceStr);
+  }
+  const all = [];
+  for (const day of dayDirs) {
+    const indexPath = path.join(archiveBase, day, 'index.json');
+    const entries = await readJsonArray(indexPath);
+    all.push(...entries);
+  }
+  if (scope) {
+    const sc = String(scope).trim().toLowerCase();
+    return all.filter((e) => e.scope === sc);
+  }
+  return all;
+}
+
+export async function promoteMemory({
+  entry,
+  scope = 'global',
+  lifecycle = 'operational',
+  workspaceRoot = process.cwd(),
+  projectAlias = '',
+  config = {},
+  confidence = 0.9
+} = {}) {
+  if (!entry?.summary) throw new Error('Entry with summary is required for promotion');
+  const lc = validateLifecycle(lifecycle);
+  const content = normalizeMemoryText(entry.details || entry.summary);
+  const saved = await rememberMemory({
+    scope,
+    content,
+    kind: entry.type || 'note',
+    summary: normalizeMemoryText(entry.summary),
+    source: `dream-promote:${entry.id}`,
+    confidence: Math.min(1, Math.max(0.5, confidence)),
+    replaceSimilar: true,
+    workspaceRoot,
+    projectAlias,
+    config
+  });
+  // Tag the saved item with lifecycle
+  const filePath = buildFilePath(scope, workspaceRoot, projectAlias);
+  const projectKey = scope === 'project' ? getProjectMemoryKey(workspaceRoot, projectAlias) : '';
+  const items = (await readMemoryBucket(filePath)).map((item) => normalizeMemoryItem(item, scope, projectKey));
+  const target = items.find((item) => item.id === saved.id);
+  if (target) {
+    target.lifecycle = lc;
+    await writeMemoryBucket(filePath, items);
+  }
+  // Remove from inbox
+  await removeInboxEntry(entry.id);
+  return { promoted: saved, lifecycle: lc };
+}

package/src/core/paths.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 
 const GLOBAL_APP_DIR = 'codemini-global';
 const PROJECT_APP_DIR = '.codemini';
-const PROJECT_INDEX_DIR = '.codemini-project';
+const PROJECT_INDEX_DIR = '.codemini';
 
 export function getBaseConfigDir() {
   if (process.env.CODEMINI_GLOBAL_DIR) {
@@ -109,3 +109,15 @@ export function getProjectIndexDir(cwd = process.cwd()) {
 export function getProjectMemoryDir(cwd = process.cwd()) {
   return path.join(getProjectIndexDir(cwd), 'memory');
 }
+
+export function getInboxDir() {
+  return path.join(getMemoryDir(), 'inbox');
+}
+
+export function getArchiveDir() {
+  return path.join(getMemoryDir(), 'archive');
+}
+
+export function getDreamAuditDir() {
+  return path.join(getMemoryDir(), 'audit');
+}

package/src/core/project-index.js

@@ -387,7 +387,7 @@ export async function initializeProjectIndex(cwd = process.cwd()) {
       projectRoot: targetRoot,
       projectMap,
       fileIndex,
-      summary: `initialized ${path.basename(targetRoot) || '.'}/.codemini-project (${Array.isArray(fileIndex?.files) ? fileIndex.files.length : 0} files)`
+      summary: `initialized ${path.basename(targetRoot) || '.'}/.codemini (${Array.isArray(fileIndex?.files) ? fileIndex.files.length : 0} files)`
     };
   })();
   initCache.set(cacheKey, promise);
@@ -447,7 +447,7 @@ export async function refreshIndexedFile(cwd = process.cwd(), relativePath = '')
     path: projectRelativePath,
     projectRoot,
     action,
-    summary: `${action} ${path.basename(projectRoot) || '.'}/.codemini-project for ${projectRelativePath}`
+    summary: `${action} ${path.basename(projectRoot) || '.'}/.codemini for ${projectRelativePath}`
   };
 }