会话与记忆——记住上次聊到哪了

// src/session/types.ts
 
import type OpenAI from "openai";
 
/** 对话消息——直接复用 OpenAI 的类型 */
export type Message = OpenAI.ChatCompletionMessageParam;
 
/** 一次完整的对话会话 */
export interface Session {
  id: string;
  name?: string;
  messages: Message[];
  metadata: SessionMetadata;
  createdAt: number;  // Unix 时间戳
  updatedAt: number;
}
 
/** 会话的元信息——记录"在哪个环境下"发生的对话 */
export interface SessionMetadata {
  cwd: string;          // 工作目录
  provider: string;     // LLM 提供商
  model: string;        // 模型名
  gitBranch?: string;   // 当前 git 分支
}

/** 会话列表项——不包含完整消息，用于 list 展示 */
export interface SessionSummary {
  id: string;
  name?: string;
  messageCount: number;
  createdAt: number;
  updatedAt: number;
  metadata: SessionMetadata;
  /** 最后一条用户消息的前 80 个字符，方便识别 */
  lastUserMessage?: string;
}

// src/session/store.ts
 
import * as fs from "fs/promises";
import * as path from "path";
import { randomUUID } from "crypto";
import type { Session, SessionSummary, SessionMetadata, Message } from "./types.js";
 
const SESSIONS_DIR = path.join(
  process.env.HOME ?? "~",
  ".ling",
  "sessions"
);
 
export class SessionStore {
  private dir: string;
 
  constructor(dir: string = SESSIONS_DIR) {
    this.dir = dir;
  }
 
  /** 确保目录存在 */
  private async ensureDir(): Promise<void> {
    await fs.mkdir(this.dir, { recursive: true });
  }
 
  private filePath(id: string): string {
    return path.join(this.dir, `${id}.json`);
  }
 
  /** 创建新会话 */
  async create(metadata: SessionMetadata, name?: string): Promise<Session> {
    await this.ensureDir();
 
    const session: Session = {
      id: randomUUID(),
      name,
      messages: [],
      metadata,
      createdAt: Date.now(),
      updatedAt: Date.now(),
    };
 
    await this.save(session);
    return session;
  }
 
  /** 保存会话（整体覆盖写入） */
  async save(session: Session): Promise<void> {
    await this.ensureDir();
    session.updatedAt = Date.now();
 
    const data = JSON.stringify(session, null, 2);
    // 先写临时文件再 rename——防止写到一半断电出现损坏文件
    const tmpPath = this.filePath(session.id) + ".tmp";
    await fs.writeFile(tmpPath, data, "utf-8");
    await fs.rename(tmpPath, this.filePath(session.id));
  }

  /** 加载指定会话 */
  async load(id: string): Promise<Session | null> {
    try {
      const data = await fs.readFile(this.filePath(id), "utf-8");
      return JSON.parse(data) as Session;
    } catch {
      return null;
    }
  }
 
  /** 列出所有会话摘要，按更新时间倒序 */
  async list(): Promise<SessionSummary[]> {
    await this.ensureDir();
 
    const files = await fs.readdir(this.dir);
    const jsonFiles = files.filter((f) => f.endsWith(".json"));
 
    const summaries: SessionSummary[] = [];
 
    for (const file of jsonFiles) {
      try {
        const data = await fs.readFile(path.join(this.dir, file), "utf-8");
        const session = JSON.parse(data) as Session;
 
        // 找最后一条用户消息
        const lastUserMsg = [...session.messages]
          .reverse()
          .find((m) => m.role === "user");
        const lastContent =
          lastUserMsg && "content" in lastUserMsg
            ? String(lastUserMsg.content).slice(0, 80)
            : undefined;
 
        summaries.push({
          id: session.id,
          name: session.name,
          messageCount: session.messages.length,
          createdAt: session.createdAt,
          updatedAt: session.updatedAt,
          metadata: session.metadata,
          lastUserMessage: lastContent,
        });
      } catch {
        // 跳过损坏的文件
      }
    }
 
    return summaries.sort((a, b) => b.updatedAt - a.updatedAt);
  }

  /** 删除会话 */
  async delete(id: string): Promise<boolean> {
    try {
      await fs.unlink(this.filePath(id));
      return true;
    } catch {
      return false;
    }
  }
 
  /** 获取最近的会话 ID */
  async getLatestId(): Promise<string | null> {
    const summaries = await this.list();
    return summaries.length > 0 ? summaries[0].id : null;
  }
 
  /** 重命名会话 */
  async rename(id: string, name: string): Promise<boolean> {
    const session = await this.load(id);
    if (!session) return false;
    session.name = name;
    await this.save(session);
    return true;
  }
}

// src/ling.ts（节选）
 
interface CliArgs {
  continue: boolean;
  resume?: string;
  name?: string;
  listSessions: boolean;
}
 
function parseArgs(argv: string[]): CliArgs {
  const args: CliArgs = { continue: false, listSessions: false };
 
  for (let i = 2; i < argv.length; i++) {
    switch (argv[i]) {
      case "--continue":
      case "-c":
        args.continue = true;
        break;
      case "--resume":
      case "-r":
        args.resume = argv[++i];
        break;
      case "--name":
      case "-n":
        args.name = argv[++i];
        break;
      case "--list-sessions":
      case "-l":
        args.listSessions = true;
        break;
    }
  }
  return args;
}

async function main() {
  const args = parseArgs(process.argv);
  const store = new SessionStore();
 
  // --list-sessions：打印后退出
  if (args.listSessions) {
    const sessions = await store.list();
    if (sessions.length === 0) {
      console.log("No sessions found.");
      return;
    }
    console.log("Sessions:\n");
    for (const s of sessions) {
      const date = new Date(s.updatedAt).toLocaleString();
      const label = s.name ? `"${s.name}"` : s.id.slice(0, 8);
      const preview = s.lastUserMessage ?? "(empty)";
      console.log(`  ${label}  ${s.messageCount} msgs  ${date}`);
      console.log(`    ${preview}\n`);
    }
    return;
  }
 
  // 决定是新建还是恢复会话
  let session: Session;
 
  if (args.continue) {
    const latestId = await store.getLatestId();
    if (!latestId) {
      console.log("No previous session found. Starting new session.");
      session = await store.create(detectMetadata(), args.name);
    } else {
      session = (await store.load(latestId))!;
      console.log(`Resuming session ${session.id.slice(0, 8)}...`
        + ` (${session.messages.length} messages)`);
    }
  } else if (args.resume) {
    const loaded = await store.load(args.resume);
    if (!loaded) {
      console.error(`Session not found: ${args.resume}`);
      process.exit(1);
    }
    session = loaded;
    console.log(`Resuming session ${session.id.slice(0, 8)}...`
      + ` (${session.messages.length} messages)`);
  } else {
    session = await store.create(detectMetadata(), args.name);
    console.log(`New session: ${session.id.slice(0, 8)}`);
  }
 
  // ... REPL 循环（见下文）
}

import { execSync } from "child_process";
 
function detectMetadata(): SessionMetadata {
  let gitBranch: string | undefined;
  try {
    gitBranch = execSync("git branch --show-current",
      { encoding: "utf-8" }).trim();
  } catch {
    // 不在 git 仓库内，忽略
  }
 
  return {
    cwd: process.cwd(),
    provider: "openai",
    model,
    gitBranch,
  };
}

  const prompt = () => {
    rl.question("You: ", async (input) => {
      if (!input.trim()) return prompt();
 
      try {
        const reply = await agentLoop(input, session.messages);
        console.log(`\nLing: ${reply}\n`);
 
        // 每轮对话后自动保存
        await store.save(session);
      } catch (err) {
        console.error(`Error: ${(err as Error).message}\n`);
      }
      prompt();
    });
  };

# 新建会话
$ ling --name "migration"
New session: a3f2b1c8
You: 帮我把数据库从 MySQL 迁移到 PostgreSQL
Ling: ...
 
# 第二天继续
$ ling --continue
Resuming session a3f2b1c8... (12 messages)
You: 昨天迁移到哪一步了？
Ling: 我们昨天完成了 schema 转换和数据导出，接下来需要...
 
# 查看历史
$ ling --list-sessions
Sessions:
 
  "migration"  12 msgs  2024/12/15 14:30:00
    帮我把数据库从 MySQL 迁移到 PostgreSQL
 
  e7d9a4b2  6 msgs  2024/12/14 09:15:00
    这个项目的测试覆盖率怎么样

// src/session/types.ts（续）
 
/** 记忆类型 */
export type MemoryType = "user" | "project" | "feedback";
 
/** 一条记忆 */
export interface MemoryEntry {
  name: string;           // 记忆标题
  description: string;    // 一句话说明
  type: MemoryType;
  content: string;        // 正文内容（Markdown）
  createdAt: number;
  updatedAt: number;
}
 
/** 记忆索引文件中的条目 */
export interface MemoryIndexEntry {
  file: string;           // 文件名
  name: string;
  description: string;
  type: MemoryType;
}

// src/session/memory.ts
 
import * as fs from "fs/promises";
import * as path from "path";
import type { MemoryEntry, MemoryIndexEntry, MemoryType } from "./types.js";
 
const MEMORY_BASE = path.join(process.env.HOME ?? "~", ".ling", "memory");
 
/** 把项目路径变成安全的目录名 */
function slugify(projectPath: string): string {
  return projectPath
    .replace(/^\//, "")
    .replace(/\//g, "-")
    .replace(/[^a-zA-Z0-9-]/g, "")
    .toLowerCase();
}
 
export class MemoryStore {
  private dir: string;
 
  constructor(projectPath: string) {
    this.dir = path.join(MEMORY_BASE, slugify(projectPath));
  }
 
  private async ensureDir(): Promise<void> {
    await fs.mkdir(this.dir, { recursive: true });
  }
 
  private indexPath(): string {
    return path.join(this.dir, "MEMORY.md");
  }

  /**
   * 写入一条记忆
   * 生成独立的 .md 文件 + 更新 MEMORY.md 索引
   */
  async write(entry: MemoryEntry): Promise<string> {
    await this.ensureDir();
 
    const fileName = entry.name
      .toLowerCase()
      .replace(/[^a-z0-9]+/g, "-")
      .replace(/^-|-$/g, "")
      + ".md";
 
    // 生成带 frontmatter 的内容
    const fileContent = [
      "---",
      `name: ${entry.name}`,
      `description: ${entry.description}`,
      `type: ${entry.type}`,
      `createdAt: ${entry.createdAt}`,
      `updatedAt: ${entry.updatedAt}`,
      "---",
      "",
      entry.content,
      "",
    ].join("\n");
 
    await fs.writeFile(
      path.join(this.dir, fileName), fileContent, "utf-8"
    );
 
    // 更新索引
    await this.updateIndex({
      file: fileName,
      name: entry.name,
      description: entry.description,
      type: entry.type,
    });
 
    return fileName;
  }

  /** 读取所有记忆条目（前 200 行） */
  async loadForContext(): Promise<string> {
    try {
      const indexContent = await fs.readFile(this.indexPath(), "utf-8");
      const lines = indexContent.split("\n");
      return lines.slice(0, 200).join("\n");
    } catch {
      return "";
    }
  }

  /** 读取指定记忆文件的完整内容 */
  async read(fileName: string): Promise<MemoryEntry | null> {
    try {
      const raw = await fs.readFile(
        path.join(this.dir, fileName), "utf-8"
      );
      return parseFrontmatter(raw);
    } catch {
      return null;
    }
  }
 
  /** 更新 MEMORY.md 索引文件 */
  private async updateIndex(entry: MemoryIndexEntry): Promise<void> {
    const entries = await this.list();
 
    // 去重：同名的覆盖
    const filtered = entries.filter((e) => e.file !== entry.file);
    filtered.push(entry);
 
    const lines = ["# Memory Index", ""];
    for (const e of filtered) {
      lines.push(
        `- [${e.name}](${e.file}) — ${e.description} (${e.type})`
      );
    }
    lines.push("");
 
    await fs.writeFile(this.indexPath(), lines.join("\n"), "utf-8");
  }
}

# Memory Index
 
- [代码风格偏好](code-style.md) — 使用 camelCase，不用分号 (user)
- [部署流程](deploy-flow.md) — 必须先跑 migrate 再部署 (project)
- [不要用 rm -rf](no-rm-rf.md) — 用 trash-cli 替代 (feedback)

---
name: 代码风格偏好
description: 使用 camelCase，不用分号
type: user
createdAt: 1734567890000
updatedAt: 1734567890000
---
 
- 变量和函数名使用 camelCase
- 不使用分号（依赖 ASI）
- 字符串优先使用双引号
- 缩进用 2 个空格

// src/ling.ts（节选）
 
const memoryTool: OpenAI.ChatCompletionTool = {
  type: "function",
  function: {
    name: "save_memory",
    description:
      "Save a piece of information that should be remembered " +
      "across sessions. Use this for user preferences, project " +
      "conventions, and feedback corrections.",
    parameters: {
      type: "object",
      properties: {
        name: { type: "string", description: "Short title" },
        description: { type: "string", description: "One-line summary" },
        type: {
          type: "string",
          enum: ["user", "project", "feedback"],
          description: "user=preference, project=convention, feedback=correction",
        },
        content: { type: "string", description: "Full content in Markdown" },
      },
      required: ["name", "description", "type", "content"],
    },
  },
};

const systemPrompt = `You are Ling, a coding assistant.
When the user tells you something worth remembering
(preferences, project conventions, corrections),
call the save_memory tool to persist it across sessions.`;

{
  "name": "save_memory",
  "arguments": {
    "name": "语言偏好",
    "description": "回复使用中文",
    "type": "user",
    "content": "用户要求所有回复使用中文。"
  }
}

// JSON（我们的方案）——整个文件是一个 JSON 对象
{ "id": "xxx", "messages": [...], ... }

// JSONL（Claude Code 的方案）——每行一条消息
{"type":"summary","sessionId":"xxx","metadata":{...}}
{"type":"message","role":"user","content":"..."}
{"type":"message","role":"assistant","content":"..."}

---
name: 代码风格
description: 项目的代码风格约定
type: project
---