create-walle 0.9.11 → 0.9.13

package/template/wall-e/coding/workspace-replay.js

@@ -0,0 +1,324 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const DEFAULT_LIMIT_BYTES = 1024 * 1024;
+
+class WorkspaceReplay {
+  constructor({ sessionsDir = defaultSessionsDir(), now = () => new Date().toISOString() } = {}) {
+    this.sessionsDir = sessionsDir;
+    this.now = now;
+  }
+
+  resolveSessionPath(sessionId, { transcriptPath = '' } = {}) {
+    return findSessionPath(sessionId, { transcriptPath, sessionsDir: this.sessionsDir });
+  }
+
+  appendRecord(sessionId, record = {}, opts = {}) {
+    const transcriptPath = opts.transcriptPath || sessionPath(this.sessionsDir, sessionId);
+    fs.mkdirSync(path.dirname(transcriptPath), { recursive: true });
+    const offset = fs.existsSync(transcriptPath) ? fs.statSync(transcriptPath).size : 0;
+    const normalized = {
+      provider: 'walle',
+      version: 'walle-jsonl-v1',
+      sessionId,
+      uuid: record.uuid || crypto.randomUUID(),
+      timestamp: record.timestamp || this.now(),
+      ...record,
+    };
+    const line = JSON.stringify(normalized) + '\n';
+    fs.appendFileSync(transcriptPath, line, 'utf8');
+    return {
+      sessionId,
+      transcriptPath,
+      offset,
+      bytes: Buffer.byteLength(line),
+      nextOffset: offset + Buffer.byteLength(line),
+      record: normalized,
+    };
+  }
+
+  appendPart(sessionId, partType, data = {}, opts = {}) {
+    return this.appendRecord(sessionId, {
+      type: 'walle_part',
+      cwd: opts.cwd || '',
+      chatSessionId: opts.chatSessionId || '',
+      parentUuid: opts.parentUuid || null,
+      partType: partType || 'event',
+      data: data && typeof data === 'object' ? data : {},
+    }, opts);
+  }
+
+  replayRange(sessionId, opts = {}) {
+    const transcriptPath = this.resolveSessionPath(sessionId, opts);
+    if (!transcriptPath) return emptyReplay(sessionId, opts);
+
+    const stat = fs.statSync(transcriptPath);
+    const startOffset = clampNumber(opts.offset, 0, stat.size);
+    const requestedSequence = clampNumber(opts.sequence, 0, Number.MAX_SAFE_INTEGER);
+    const limitBytes = Math.max(1, Number(opts.limitBytes || opts.limit || DEFAULT_LIMIT_BYTES));
+    const raw = readRange(transcriptPath, startOffset, limitBytes);
+    const parsed = parseJsonlRange(raw.text, startOffset, startOffset > 0 ? requestedSequence : 0);
+    const nextOffset = raw.nextOffset - Buffer.byteLength(parsed.tail, 'utf8');
+    const records = parsed.records.filter((entry) => startOffset > 0 || entry.sequence >= requestedSequence);
+
+    return {
+      sessionId,
+      transcriptPath,
+      offset: startOffset,
+      sequence: requestedSequence,
+      records,
+      nextOffset,
+      nextSequence: records.length ? records[records.length - 1].sequence + 1 : parsed.nextSequence,
+      fileSize: stat.size,
+      eof: nextOffset >= stat.size,
+    };
+  }
+
+  rebuildState(sessionId, opts = {}) {
+    const transcriptPath = this.resolveSessionPath(sessionId, opts);
+    if (!transcriptPath) return { ...emptyState(sessionId), workspace: workspaceStatus(opts.cwd || '') };
+
+    const replay = this.replayRange(sessionId, {
+      ...opts,
+      offset: 0,
+      sequence: 0,
+      limitBytes: Number.MAX_SAFE_INTEGER,
+      transcriptPath,
+    });
+    const state = emptyState(sessionId);
+    state.transcriptPath = transcriptPath;
+    state.nextOffset = replay.nextOffset;
+    state.nextSequence = replay.nextSequence;
+    state.fileSize = replay.fileSize;
+
+    for (const entry of replay.records) {
+      const record = entry.record;
+      if (record.type === 'session_meta') {
+        state.meta = {
+          ...state.meta,
+          ...pick(record, ['sessionId', 'chatSessionId', 'cwd', 'label', 'modelId', 'modelProvider', 'runtimeMode', 'gitBranch', 'agent', 'mode', 'timestamp']),
+        };
+        if (record.cwd) state.cwd = record.cwd;
+        continue;
+      }
+      if (record.cwd && !state.cwd) state.cwd = record.cwd;
+      if (record.type === 'user' || record.type === 'assistant') {
+        state.messages.push({
+          sequence: entry.sequence,
+          offset: entry.offset,
+          uuid: record.uuid || '',
+          parentUuid: record.parentUuid || null,
+          role: record.message?.role || record.type,
+          text: extractText(record.message?.content ?? record.message ?? record.content),
+          timestamp: record.timestamp || '',
+        });
+        continue;
+      }
+      if (record.type === 'walle_part') {
+        const part = {
+          sequence: entry.sequence,
+          offset: entry.offset,
+          uuid: record.uuid || '',
+          parentUuid: record.parentUuid || null,
+          partType: record.partType || 'event',
+          data: record.data || {},
+          timestamp: record.timestamp || '',
+        };
+        state.parts.push(part);
+        if (part.partType === 'tool' || part.partType === 'tool_call' || part.partType === 'tool_result') {
+          state.tools.push(part);
+        }
+        if (part.partType === 'permission' || part.data.state === 'permission_check') {
+          state.permissions.push(part);
+        }
+        if (part.partType === 'usage') {
+          state.usage.push(part.data);
+        }
+      }
+    }
+
+    state.workspace = workspaceStatus(opts.cwd || state.cwd || state.meta.cwd || '');
+    return state;
+  }
+}
+
+function defaultSessionsDir(env = process.env) {
+  if (env.WALLE_SESSIONS_DIR) return env.WALLE_SESSIONS_DIR;
+  if (env.WALL_E_SESSIONS_DIR) return env.WALL_E_SESSIONS_DIR;
+  if (env.WALLE_DEV_DIR) return path.join(env.WALLE_DEV_DIR, 'sessions');
+  if (env.WALL_E_DATA_DIR && env.WALL_E_DATA_DIR !== path.join(os.homedir(), '.walle', 'data')) {
+    return path.join(env.WALL_E_DATA_DIR, 'sessions');
+  }
+  if (env.CTM_DATA_DIR && env.CTM_DATA_DIR !== path.join(os.homedir(), '.walle', 'data')) {
+    return path.join(env.CTM_DATA_DIR, 'sessions');
+  }
+  return path.join(os.homedir(), '.walle', 'sessions');
+}
+
+function sessionPath(rootDir, sessionId) {
+  return path.join(rootDir, `${safeSessionId(sessionId)}.jsonl`);
+}
+
+function safeSessionId(sessionId) {
+  const id = String(sessionId || '');
+  if (!id || id.includes('..') || /[\\/]/.test(id) || !/^[A-Za-z0-9_.:-]+$/.test(id)) {
+    throw new Error(`Invalid session id: ${id || '<empty>'}`);
+  }
+  return id;
+}
+
+function findSessionPath(sessionId, { transcriptPath = '', sessionsDir = defaultSessionsDir() } = {}) {
+  if (transcriptPath && fs.existsSync(transcriptPath)) return transcriptPath;
+  if (!sessionId) return '';
+  const roots = [
+    sessionsDir,
+    process.env.WALLE_SESSIONS_DIR,
+    process.env.WALL_E_SESSIONS_DIR,
+    process.env.WALLE_DEV_DIR ? path.join(process.env.WALLE_DEV_DIR, 'sessions') : '',
+    process.env.WALL_E_DATA_DIR ? path.join(process.env.WALL_E_DATA_DIR, 'sessions') : '',
+    process.env.CTM_DATA_DIR ? path.join(process.env.CTM_DATA_DIR, 'sessions') : '',
+    path.join(os.homedir(), '.walle', 'sessions'),
+  ].filter(Boolean);
+  for (const root of [...new Set(roots)]) {
+    const candidate = sessionPath(root, sessionId);
+    try {
+      if (fs.existsSync(candidate)) return candidate;
+    } catch {}
+  }
+  return '';
+}
+
+function readRange(filePath, offset, limitBytes) {
+  const fd = fs.openSync(filePath, 'r');
+  try {
+    const stat = fs.fstatSync(fd);
+    const length = Math.min(limitBytes, Math.max(0, stat.size - offset));
+    const buffer = Buffer.alloc(length);
+    const bytesRead = fs.readSync(fd, buffer, 0, length, offset);
+    return {
+      text: buffer.toString('utf8', 0, bytesRead),
+      nextOffset: offset + bytesRead,
+    };
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+function parseJsonlRange(text, baseOffset, baseSequence) {
+  const records = [];
+  const lines = text.split('\n');
+  const completeLineCount = text.endsWith('\n') ? lines.length - 1 : lines.length - 1;
+  let cursor = baseOffset;
+  let sequence = clampNumber(baseSequence, 0, Number.MAX_SAFE_INTEGER);
+  for (let i = 0; i < completeLineCount; i++) {
+    const line = lines[i];
+    const bytes = Buffer.byteLength(line + '\n');
+    if (line.trim()) {
+      try {
+        records.push({
+          sequence,
+          offset: cursor,
+          nextOffset: cursor + bytes,
+          record: JSON.parse(line),
+          raw: line,
+        });
+        sequence++;
+      } catch {
+        sequence++;
+      }
+    }
+    cursor += bytes;
+  }
+  return {
+    records,
+    tail: text.endsWith('\n') ? '' : lines[lines.length - 1],
+    nextSequence: sequence,
+  };
+}
+
+function emptyReplay(sessionId, opts = {}) {
+  return {
+    sessionId,
+    transcriptPath: '',
+    offset: clampNumber(opts.offset, 0, Number.MAX_SAFE_INTEGER),
+    sequence: clampNumber(opts.sequence, 0, Number.MAX_SAFE_INTEGER),
+    records: [],
+    nextOffset: 0,
+    nextSequence: clampNumber(opts.sequence, 0, Number.MAX_SAFE_INTEGER),
+    fileSize: 0,
+    eof: true,
+  };
+}
+
+function emptyState(sessionId) {
+  return {
+    sessionId,
+    transcriptPath: '',
+    cwd: '',
+    meta: {},
+    messages: [],
+    parts: [],
+    tools: [],
+    permissions: [],
+    usage: [],
+    workspace: workspaceStatus(''),
+    nextOffset: 0,
+    nextSequence: 0,
+    fileSize: 0,
+  };
+}
+
+function workspaceStatus(cwd) {
+  if (!cwd) return { cwd: '', available: false, reason: 'missing_cwd' };
+  try {
+    const stat = fs.statSync(cwd);
+    return { cwd, available: stat.isDirectory(), reason: stat.isDirectory() ? '' : 'not_directory' };
+  } catch {
+    return { cwd, available: false, reason: 'missing' };
+  }
+}
+
+function extractText(content) {
+  if (!content) return '';
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (!part) return '';
+        if (typeof part === 'string') return part;
+        return part.text || part.content || '';
+      })
+      .filter(Boolean)
+      .join('\n');
+  }
+  return content.text || content.content || '';
+}
+
+function pick(record, keys) {
+  const out = {};
+  for (const key of keys) {
+    if (record[key] !== undefined) out[key] = record[key];
+  }
+  return out;
+}
+
+function clampNumber(value, min, max) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return min;
+  return Math.min(max, Math.max(min, Math.floor(n)));
+}
+
+module.exports = {
+  WorkspaceReplay,
+  defaultSessionsDir,
+  sessionPath,
+  safeSessionId,
+  findSessionPath,
+  parseJsonlRange,
+  workspaceStatus,
+  extractText,
+};

package/template/wall-e/coding-context.js

@@ -349,28 +349,10 @@ const INSTRUCTION_FILES = ['CLAUDE.md', 'AGENTS.md'];
  * @returns {Array<{ path: string, content: string }>}
  */
 function discoverInstructions(filePath, projectRoot) {
-  const instructions = [];
-  const resolvedRoot = path.resolve(projectRoot);
-  let dir = path.dirname(path.resolve(filePath));
-
-  while (dir.startsWith(resolvedRoot)) {
-    for (const name of INSTRUCTION_FILES) {
-      const candidate = path.join(dir, name);
-      try {
-        if (fs.existsSync(candidate)) {
-          const content = fs.readFileSync(candidate, 'utf8');
-          instructions.push({ path: candidate, content });
-        }
-      } catch {
-        // Skip unreadable files
-      }
-    }
-    const parent = path.dirname(dir);
-    if (parent === dir) break; // filesystem root
-    dir = parent;
-  }
-
-  return instructions;
+  const { InstructionService } = require('./coding/instruction-service');
+  return new InstructionService({ instructionFiles: INSTRUCTION_FILES })
+    .discoverForFile(filePath, projectRoot, { dedupe: false })
+    .instructions;
 }
 
 module.exports = {