ispbills-icli 8.5.5 → 8.5.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ispbills-icli",
-  "version": "8.5.5",
+  "version": "8.5.7",
   "description": "iCli — IspBills AI network engineer in your terminal",
   "keywords": [
     "ispbills",

package/src/session.js

@@ -1,9 +1,50 @@
-import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from 'fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 
 const SESSION_DIR = join(homedir(), '.config', 'ispbills-icli', 'sessions');
 
+function safeJson(raw, fallback = null) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+
+function normalizeMessages(messages = []) {
+  return messages
+    .filter((m) => m && typeof m.role === 'string')
+    .map((m) => ({ role: m.role, content: String(m.content ?? '') }));
+}
+
+function autoNameFromMessages(messages = []) {
+  const firstUser = messages.find((m) => m?.role === 'user' && String(m.content || '').trim());
+  const text = String(firstUser?.content || '').replace(/\s+/g, ' ').trim();
+  if (!text) return 'Untitled session';
+  return text.slice(0, 40).trim();
+}
+
+function normalizeSession(session = {}) {
+  const now = new Date().toISOString();
+  const messages = normalizeMessages(session.messages);
+  const id = String(session.id || Date.now().toString(36));
+  return {
+    id,
+    name: String(session.name || autoNameFromMessages(messages) || 'Untitled session'),
+    cwd: String(session.cwd || process.cwd()),
+    branch: String(session.branch || ''),
+    model: String(session.model || ''),
+    createdAt: session.createdAt || now,
+    updatedAt: session.updatedAt || now,
+    messages,
+  };
+}
+
+function sessionPathFor(id) {
+  return join(SESSION_DIR, `${id}.json`);
+}
+
 export function sessionDir() {
   return SESSION_DIR;
 }
@@ -12,30 +53,105 @@ export function initSessionDir() {
   if (!existsSync(SESSION_DIR)) mkdirSync(SESSION_DIR, { recursive: true });
 }
 
-export function newSessionPath() {
-  const id = new Date().toISOString().replace(/[:.]/g, '-');
-  return join(SESSION_DIR, `${id}.jsonl`);
+export function saveSession(session) {
+  try {
+    initSessionDir();
+    const existing = loadSessionById(session?.id);
+    const normalized = normalizeSession({
+      ...existing,
+      ...session,
+      id: session?.id || existing?.id,
+      createdAt: session?.createdAt || existing?.createdAt,
+      updatedAt: new Date().toISOString(),
+      name: session?.name || existing?.name,
+    });
+    if (!normalized.name || normalized.name === 'Untitled session') {
+      normalized.name = autoNameFromMessages(normalized.messages);
+    }
+    writeFileSync(sessionPathFor(normalized.id), JSON.stringify(normalized, null, 2) + '\n');
+    return normalized;
+  } catch {
+    return null;
+  }
 }
 
-/** Append a single message to the JSONL session log (best-effort). */
-export function saveMessage(sessionPath, message) {
+export function loadSessionById(id) {
+  if (!id) return null;
+  const path = sessionPathFor(id);
+  if (!existsSync(path)) return null;
+  const loaded = safeJson(readFileSync(path, 'utf8'), null);
+  return loaded ? normalizeSession(loaded) : null;
+}
+
+export function deleteSession(id) {
   try {
-    appendFileSync(sessionPath, JSON.stringify({ timestamp: new Date().toISOString(), message }) + '\n');
+    const path = sessionPathFor(id);
+    if (!existsSync(path)) return false;
+    unlinkSync(path);
+    return true;
   } catch {
-    /* non-fatal — session logging is a convenience only */
+    return false;
   }
 }
 
-export function listSessions() {
+export function listSessionsDetailed() {
   if (!existsSync(SESSION_DIR)) return [];
-  return readdirSync(SESSION_DIR).filter((f) => f.endsWith('.jsonl')).sort();
+  return readdirSync(SESSION_DIR)
+    .filter((f) => f.endsWith('.json'))
+    .map((file) => {
+      const full = join(SESSION_DIR, file);
+      const session = safeJson(readFileSync(full, 'utf8'), null);
+      if (!session) return null;
+      const normalized = normalizeSession(session);
+      const stats = statSync(full);
+      return {
+        id: normalized.id,
+        name: normalized.name || autoNameFromMessages(normalized.messages),
+        cwd: normalized.cwd,
+        branch: normalized.branch,
+        model: normalized.model,
+        createdAt: normalized.createdAt,
+        updatedAt: normalized.updatedAt,
+        messageCount: normalized.messages.length,
+        messages: normalized.messages,
+        mtimeMs: stats.mtimeMs,
+      };
+    })
+    .filter(Boolean)
+    .sort((a, b) => new Date(b.updatedAt || 0).getTime() - new Date(a.updatedAt || 0).getTime());
 }
 
-export function loadSession(sessionPath) {
-  if (!existsSync(sessionPath)) return [];
-  return readFileSync(sessionPath, 'utf-8')
-    .split('\n')
-    .filter(Boolean)
-    .map((line) => { try { return JSON.parse(line).message; } catch { return null; } })
-    .filter(Boolean);
+export function loadMostRecent() {
+  const [session] = listSessionsDetailed();
+  if (!session?.id) return null;
+  return loadSessionById(session.id);
+}
+
+export function listSessions() {
+  return listSessionsDetailed().map((s) => s.id);
+}
+
+export function loadSession(sessionPathOrId) {
+  if (!sessionPathOrId) return [];
+  if (sessionPathOrId.endsWith?.('.json')) {
+    const session = safeJson(readFileSync(sessionPathOrId, 'utf8'), null);
+    return normalizeSession(session || {}).messages;
+  }
+  return loadSessionById(sessionPathOrId)?.messages || [];
+}
+
+export function newSessionPath() {
+  initSessionDir();
+  return sessionPathFor(Date.now().toString(36));
+}
+
+export function saveMessage(sessionPathOrId, message) {
+  if (!message) return null;
+  const id = String(sessionPathOrId || Date.now().toString(36)).replace(/\.json$/, '');
+  const existing = loadSessionById(id);
+  return saveSession({
+    ...(existing || {}),
+    id,
+    messages: [...(existing?.messages || []), message],
+  });
 }