@yeaft/webchat-agent 1.0.292 → 1.0.293

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.292",
+  "version": "1.0.293",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/projects/store.js

@@ -0,0 +1,152 @@
+import { existsSync, mkdirSync, readFileSync, renameSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { writeAtomic } from '../storage/atomic.js';
+
+const PROJECTS_FILE = 'projects.json';
+const PROJECTS_VERSION = 1;
+
+export class ProjectStoreError extends Error {
+  constructor(code, message) {
+    super(message || code);
+    this.name = 'ProjectStoreError';
+    this.code = code;
+  }
+}
+
+function projectsPath(yeaftDir) {
+  return join(yeaftDir, PROJECTS_FILE);
+}
+
+function normalizeSessionIds(values) {
+  const out = [];
+  const seen = new Set();
+  for (const value of Array.isArray(values) ? values : []) {
+    const id = typeof value === 'string' ? value.trim() : '';
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    out.push(id);
+  }
+  return out;
+}
+
+function normalizeProject(row, index = 0) {
+  if (!row || typeof row !== 'object' || typeof row.id !== 'string' || !row.id) return null;
+  const name = typeof row.name === 'string' ? row.name.trim() : '';
+  if (!name) return null;
+  return {
+    id: row.id,
+    name,
+    sessionIds: normalizeSessionIds(row.sessionIds),
+    sortOrder: Number.isFinite(row.sortOrder) ? row.sortOrder : index,
+    createdAt: typeof row.createdAt === 'string' ? row.createdAt : '',
+    updatedAt: typeof row.updatedAt === 'string' ? row.updatedAt : '',
+  };
+}
+
+export function loadProjects(yeaftDir) {
+  if (!yeaftDir || !existsSync(projectsPath(yeaftDir))) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(projectsPath(yeaftDir), 'utf8'));
+    const rows = Array.isArray(parsed?.projects) ? parsed.projects : [];
+    return rows.map(normalizeProject).filter(Boolean).sort((a, b) => a.sortOrder - b.sortOrder);
+  } catch {
+    const path = projectsPath(yeaftDir);
+    try { renameSync(path, `${path}.corrupt-${Date.now()}`); } catch { /* keep the unreadable file if quarantine fails */ }
+    return [];
+  }
+}
+
+function saveProjects(yeaftDir, projects) {
+  if (!yeaftDir) throw new ProjectStoreError('missing_root', 'Yeaft directory is required');
+  mkdirSync(yeaftDir, { recursive: true });
+  const now = new Date().toISOString();
+  const normalized = projects.map(normalizeProject).filter(Boolean).map((project, index) => ({
+    ...project,
+    sortOrder: index,
+    updatedAt: project.updatedAt || now,
+  }));
+  writeAtomic(projectsPath(yeaftDir), `${JSON.stringify({
+    version: PROJECTS_VERSION,
+    updatedAt: now,
+    projects: normalized,
+  }, null, 2)}\n`);
+  return normalized;
+}
+
+function requireName(value) {
+  const name = typeof value === 'string' ? value.trim() : '';
+  if (!name) throw new ProjectStoreError('invalid_name', 'Project name is required');
+  return name.slice(0, 120);
+}
+
+function requireProject(projects, projectId) {
+  const project = projects.find(row => row.id === projectId);
+  if (!project) throw new ProjectStoreError('not_found', 'Project not found');
+  return project;
+}
+
+export function createProject(yeaftDir, name) {
+  const projects = loadProjects(yeaftDir);
+  const now = new Date().toISOString();
+  const project = {
+    id: `project-${randomUUID().slice(0, 8)}`,
+    name: requireName(name),
+    sessionIds: [],
+    sortOrder: projects.length,
+    createdAt: now,
+    updatedAt: now,
+  };
+  saveProjects(yeaftDir, [...projects, project]);
+  return project;
+}
+
+export function renameProject(yeaftDir, projectId, name) {
+  const projects = loadProjects(yeaftDir);
+  const project = requireProject(projects, projectId);
+  project.name = requireName(name);
+  project.updatedAt = new Date().toISOString();
+  saveProjects(yeaftDir, projects);
+  return project;
+}
+
+export function deleteProject(yeaftDir, projectId) {
+  const projects = loadProjects(yeaftDir);
+  requireProject(projects, projectId);
+  saveProjects(yeaftDir, projects.filter(row => row.id !== projectId));
+  return { projectId };
+}
+
+export function moveSessionToProject(yeaftDir, sessionId, projectId = null) {
+  const id = typeof sessionId === 'string' ? sessionId.trim() : '';
+  if (!id) throw new ProjectStoreError('invalid_session_id', 'Session id is required');
+  const projects = loadProjects(yeaftDir);
+  const target = projectId ? requireProject(projects, projectId) : null;
+  for (const project of projects) {
+    project.sessionIds = project.sessionIds.filter(value => value !== id);
+  }
+  if (target) target.sessionIds.push(id);
+  saveProjects(yeaftDir, projects);
+  return { sessionId: id, projectId: target?.id || null };
+}
+
+export function removeSessionFromProjects(yeaftDir, sessionId) {
+  const projects = loadProjects(yeaftDir);
+  let changed = false;
+  for (const project of projects) {
+    const next = project.sessionIds.filter(id => id !== sessionId);
+    if (next.length !== project.sessionIds.length) changed = true;
+    project.sessionIds = next;
+  }
+  if (changed) saveProjects(yeaftDir, projects);
+  return changed;
+}
+
+export function findProjectForSession(yeaftDir, sessionId) {
+  return loadProjects(yeaftDir).find(project => project.sessionIds.includes(sessionId)) || null;
+}
+
+export function sharedSessionIdsForProject(yeaftDir, sessionId) {
+  const project = findProjectForSession(yeaftDir, sessionId);
+  return project ? project.sessionIds.filter(id => id !== sessionId) : [];
+}

package/yeaft/web-bridge.js

@@ -64,6 +64,17 @@ import { persistYeaftAttachments, attachmentsForPersistence, persistedAttachment
 import { normalizeSessionMessageQuote, sessionMessageQuotePrompt } from './session-message-quote.js';
 import { ConversationStore, parseSeqFromId, projectVisibleSessionMessages } from './conversation/persist.js';
 import { isHiddenConversationRow, isVisibleConversationRow } from './conversation/internal-control.js';
+import {
+  ProjectStoreError,
+  createProject,
+  deleteProject,
+  loadProjects,
+  moveSessionToProject,
+  removeSessionFromProjects,
+  renameProject,
+} from './projects/store.js';
+import { readSummary as readScopeSummary } from './memory/store.js';
+import { estimateTokens } from './dream/segment.js';
 import { imageMetadataForPersistence } from './image-assets.js';
 import { sliceLastNTurns } from './turn-utils.js';
 import { pairSanitize } from './pair-sanitize.js';
@@ -3008,6 +3019,54 @@ function decorateSessionsWithRuntimeState(sessions) {
   });
 }
 
+const PROJECT_CONTEXT_MAX_SIBLINGS = 8;
+const PROJECT_CONTEXT_MAX_TOKENS = 4096;
+const PROJECT_CONTEXT_TRUNCATION_NOTICE = '\n[Summary truncated to Project context budget]';
+
+async function sharedProjectContext(yeaftDir, sessionId, options = {}) {
+  const project = loadProjects(yeaftDir).find(row => row.sessionIds.includes(sessionId));
+  if (!project) return '';
+  const memoryRoot = join(yeaftDir, 'memory');
+  const language = options.language || 'en';
+  const configuredBudget = Number.isFinite(options.tokenBudget) && options.tokenBudget > 0
+    ? options.tokenBudget
+    : PROJECT_CONTEXT_MAX_TOKENS;
+  const tokenBudget = Math.min(configuredBudget, PROJECT_CONTEXT_MAX_TOKENS);
+  let context = '';
+  const siblingIds = project.sessionIds
+    .filter(id => id !== sessionId)
+    .slice(0, PROJECT_CONTEXT_MAX_SIBLINGS);
+  for (const siblingId of siblingIds) {
+    const summary = await readScopeSummary(
+      { kind: 'session', id: siblingId },
+      { root: memoryRoot, language },
+    ).catch(() => '');
+    if (!summary) continue;
+    const separator = context ? '\n\n' : '';
+    const header = `[Session ${siblingId}]\n`;
+    const fullContext = `${context}${separator}${header}${summary}`;
+    if (estimateTokens(fullContext) <= tokenBudget) {
+      context = fullContext;
+      continue;
+    }
+
+    const prefix = `${context}${separator}${header}`;
+    if (estimateTokens(`${prefix}${PROJECT_CONTEXT_TRUNCATION_NOTICE}`) <= tokenBudget) {
+      let low = 0;
+      let high = summary.length;
+      while (low < high) {
+        const middle = Math.ceil((low + high) / 2);
+        const candidate = `${prefix}${summary.slice(0, middle)}${PROJECT_CONTEXT_TRUNCATION_NOTICE}`;
+        if (estimateTokens(candidate) <= tokenBudget) low = middle;
+        else high = middle - 1;
+      }
+      context = `${prefix}${summary.slice(0, low)}${PROJECT_CONTEXT_TRUNCATION_NOTICE}`;
+    }
+    break;
+  }
+  return context;
+}
+
 function sendSessionCrudResult(payload) {
   const next = payload && payload.ok && Array.isArray(payload.sessions)
     ? { ...payload, sessions: decorateSessionsWithRuntimeState(payload.sessions) }
@@ -3020,7 +3079,7 @@ function sendSessionSnapshotBroadcast() {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     if (!yeaftDir) return;
     const sessions = decorateSessionsWithRuntimeState(snapshotSessions(yeaftDir));
-    sendSessionEvent({ type: 'session_list_updated', sessions });
+    sendSessionEvent({ type: 'session_list_updated', sessions, projects: loadProjects(yeaftDir) });
   } catch (err) {
     console.warn('[Yeaft] sendSessionSnapshotBroadcast failed:', err?.message || err);
   }
@@ -3059,6 +3118,7 @@ function sessionErrorPayload(err) {
   let code = 'unknown';
   if (err instanceof SessionCrudError) code = err.code;
   else if (err instanceof SessionConfigError) code = err.code;
+  else if (err instanceof ProjectStoreError) code = err.code;
   return {
     code,
     sessionId: err && err.sessionId,
@@ -3071,12 +3131,49 @@ export function handleYeaftListSessions(msg) {
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     const groups = snapshotSessions(yeaftDir);
-    sendSessionCrudResult({ op: 'list', requestId, ok: true, sessions: groups });
+    sendSessionCrudResult({ op: 'list', requestId, ok: true, sessions: groups, projects: loadProjects(yeaftDir) });
   } catch (err) {
     sendSessionCrudResult({ op: 'list', requestId, ok: false, error: sessionErrorPayload(err) });
   }
 }
 
+export function handleYeaftProjectMutation(msg) {
+  const requestId = msg && msg.requestId;
+  const op = msg && msg.op;
+  try {
+    const yeaftDir = ctx.CONFIG?.yeaftDir;
+    let result = null;
+    if (op === 'create') result = createProject(yeaftDir, msg.name);
+    else if (op === 'rename') result = renameProject(yeaftDir, msg.projectId, msg.name);
+    else if (op === 'delete') result = deleteProject(yeaftDir, msg.projectId);
+    else if (op === 'move_session') {
+      if (!snapshotSessions(yeaftDir).some(row => row.id === msg.sessionId)) {
+        throw new ProjectStoreError('session_not_found', 'Session not found');
+      }
+      result = moveSessionToProject(yeaftDir, msg.sessionId, msg.projectId || null);
+    } else {
+      throw new ProjectStoreError('invalid_op', 'Unknown Project operation');
+    }
+    sendSessionEvent({
+      type: 'project_mutation_result',
+      requestId,
+      op,
+      ok: true,
+      result,
+      projects: loadProjects(yeaftDir),
+    }, { requestId });
+    sendSessionSnapshotBroadcast();
+  } catch (err) {
+    sendSessionEvent({
+      type: 'project_mutation_result',
+      requestId,
+      op,
+      ok: false,
+      error: sessionErrorPayload(err),
+    }, { requestId });
+  }
+}
+
 export function handleYeaftCreateSession(msg) {
   const requestId = msg && msg.requestId;
   const payload = (msg && msg.payload) || {};
@@ -3260,6 +3357,7 @@ export function handleYeaftDeleteSession(msg) {
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     const result = deleteSession(yeaftDir, sessionId);
+    removeSessionFromProjects(yeaftDir, sessionId);
     ctx.assetOutbox?.removeSession(sessionId);
     // Cascade: remove every persisted message stamped with this group id.
     // Hard delete (per user spec): no soft-archive, the bytes are gone.
@@ -5055,6 +5153,18 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
         envelope: inboundEnvelope,
         threadId,
       });
+      if (queryOpts) {
+        const projectContext = await sharedProjectContext(ctx.CONFIG?.yeaftDir, sessionId, {
+          language: session?.config?.language,
+          tokenBudget: Math.max(512, Math.floor((session?.config?.messageTokenBudget || 32768) / 8)),
+        });
+        if (projectContext) {
+          const sharedBlock = `[Project Shared Context]\nRead-only memory summaries from sibling Sessions in the same Project. Preserve each source Session identity.\n\n${projectContext}`;
+          queryOpts.sessionAnnouncement = queryOpts.sessionAnnouncement
+            ? `${queryOpts.sessionAnnouncement}\n\n${sharedBlock}`
+            : sharedBlock;
+        }
+      }
       let turnSessionMeta = null;
       try { turnSessionMeta = sessionCoordinator?.group?.getMeta?.() || null; } catch { turnSessionMeta = null; }
       const projectRuntime = getProjectRuntimeForTurn(turnSessionMeta);
@@ -7172,6 +7282,8 @@ export async function handleYeaftMcpReload(msg = {}) {
 }
 
 export const __testHooks = {
+  loadProjects,
+  sharedProjectContext,
   loadVisibleGroupHistoryPage,
   projectVisibleHistoryChunkMessages,
   persistInboundMessageOnceByMsgId,