soulbridge 0.0.4 → 0.0.5

package/README.md

@@ -59,6 +59,7 @@ npx soulbridge init
 npx soulbridge remember --type strategy "提交前先跑 make check，能省一轮 CI"
 npx soulbridge context --query "要不要先跑测试"
 npx soulbridge affect "我不太开心，这个方案又被拒了"
+npx soulbridge import --from AGENTS.md      # 把已有的项目约定导进来
 npx soulbridge demo          # 起一个 soul，跑完整 context→observe→reflect→context
 ```
 
@@ -88,6 +89,15 @@ SQLite（默认） / Postgres（可选）
 
 详见 [docs/architecture.md](docs/architecture.md)。
 
+## 接入宿主
+
+| 宿主 | 方式 | 位置 |
+|---|---|---|
+| DSH | 把 skill 放进 skills 目录 | [`adapters/dsh/SKILL.md`](adapters/dsh/SKILL.md) |
+| Claude Code / Pi / Cursor | 同理：把同一份 `SKILL.md` 当作指令文件 | v0.5+ |
+
+接上之后，宿主在会话开始运行 `soulbridge context`、每轮运行 `soulbridge observe`、结束时运行 `soulbridge ingest`。**拿不到会话转写也不影响使用**：`observe` 已经逐轮记录了观察。
+
 ## 设计文档
 
 | 文档 | 内容 |
@@ -95,11 +105,12 @@ SQLite（默认） / Postgres（可选）
 | [thesis](docs/thesis.md) | 核心命题、三条可证伪预测、四臂实验、放弃条件 |
 | [RFC 0001](docs/rfcs/0001-foundations.md) | 定位、用户、非目标、成功指标、四个动词、接入阶梯 |
 | [RFC 0002](docs/rfcs/0002-affect.md) | 输入侧情感层：两套情绪的边界、数据流、已知局限 |
-| [ADR 索引](docs/rfcs/README.md) | 21 条已生效的架构决定 |
+| [ADR 索引](docs/rfcs/README.md) | 23 条已生效的架构决定 |
 | [protocol.v0](docs/spec/protocol.v0.md) | 四个动词的完整契约：字段、错误码、降级、测试映射 |
 | [affect.v0](docs/spec/affect.v0.md) | 词库格式、8 条规则、置信度公式、黄金集与消融 |
 | [storage.v0](docs/spec/storage.v0.md) | 路径、身份、迁移、并发、导出格式 |
 | [sync.v0](docs/spec/sync.v0.md) | 跨设备合并语义（v0.5 实现） |
+| [transcript.v1](docs/spec/transcript.v1.md) | 可移植会话转写格式（ingest 的输入） |
 | [quality](docs/quality.md) | 质量模型、九条门禁、五条评审清单 |
 | [references](docs/references.md) | 外部资料的去留与过期判断 |
 | [runbook](docs/runbook.md) | 发版流程、维护操作、已知待办 |

package/adapters/dsh/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: soulbridge
+description: "跨工具的人格与记忆层。会话开始时注入记忆与情绪，每轮后记录观察，会话结束时反思。当用户提到「记得我 / 上次 / 之前 / 我的习惯」，或需要跨会话连续性时使用。"
+---
+
+# soulbridge
+
+你在一个有 `soulbridge` CLI 的机器上工作。它保存了这个用户跨工具的偏好、被纠正过的错、以及最近的表达状态。
+
+## 会话开始
+
+运行一次，把输出**原样**放到你的系统提示最前面（不要改写、不要总结）：
+
+```bash
+soulbridge context --query "<用户这次的第一句话>"
+```
+
+输出通常是 `<soul>…</soul>`、`<style>…</style>`、`<affect>…</affect>`、`<memories>…</memories>` 几段。
+
+## 每轮结束
+
+只对**用户的**消息运行：
+
+```bash
+soulbridge observe "<用户这条消息的原文>"
+```
+
+## 会话结束（可选）
+
+如果你能拿到一份 `transcript.v1.jsonl`（见 `docs/spec/transcript.v1.md`），运行：
+
+```bash
+soulbridge ingest --file <transcript.jsonl>
+```
+
+拿不到就不要强行导出：`observe` 已经记录了每轮观察，`reflect` 可以下次再补。
+
+## 规则（重要）
+
+1. **不要向用户转述注入内容**。不要说"我记得你说过……"，除非它确实与当前任务相关。
+2. **注入只影响措辞，不影响事实判断**。`<affect>` 里的建议是语气提示，不是改变结论的理由。
+3. **`soulbridge` 失败不阻塞**。命令报错时忽略它，继续正常回答。
+4. **不要猜测记忆内容**。没有注入的记忆就是没有，不要编造"以前聊过"。
+5. **不要把它写进项目文件**。个人记忆属于本机 `~/.soulbridge/soul.db`，不是仓库的一部分。
+
+## 边界
+
+- 不要修改 `~/.soulbridge/` 下的文件
+- 不要 `export` 并把内容贴到聊天里（导出是给用户备份用的）
+- 不确定时运行 `soulbridge --help`

package/dist/packages/cli/src/cli.js

@@ -24,7 +24,7 @@ process.on('warning', (warning) => {
         return;
     process.stderr.write(`${warning.name}: ${warning.message}\n`);
 });
-const { openSqlite, Soul, ensureConfig, resolveDbPath, analyzeAffect, validateLexicon } = await import('../../core/src/index.js');
+const { openSqlite, Soul, ensureConfig, resolveDbPath, analyzeAffect, validateLexicon, parseSteering, normalizeForDedupe, parseTranscriptJsonl, } = await import('../../core/src/index.js');
 const { llmAnalyzerFromEnv } = await import('./llm-analyzer.js');
 function parse(argv) {
     const [cmd = 'help', ...rest] = argv;
@@ -232,9 +232,34 @@ async function main() {
             return;
         }
         case 'import': {
+            // Steering file (AGENTS.md / CLAUDE.md) → memories (ADR 0022).
+            if (flags.from) {
+                const file = resolve(flags.from);
+                const drafts = parseSteering(readFileSync(file, 'utf8'));
+                const { soul } = open(flags);
+                const dryRun = flags['dry-run'] === 'true';
+                const existing = new Set(soul.store
+                    .query({ soulId: soul.soulId, userId: soul.userId, limit: 100_000 })
+                    .map((m) => normalizeForDedupe(m.content)));
+                let written = 0;
+                let skipped = 0;
+                for (const draft of drafts) {
+                    const key = normalizeForDedupe(draft.text);
+                    if (!key || existing.has(key)) {
+                        skipped += 1;
+                        continue;
+                    }
+                    existing.add(key);
+                    if (!dryRun)
+                        soul.remember(draft.text, { type: draft.type, importance: draft.importance });
+                    written += 1;
+                }
+                out({ ok: true, source: file, kind: 'steering', parsed: drafts.length, written, skipped, dryRun });
+                return;
+            }
             const file = flags.in;
             if (!file)
-                throw new Error('usage: soulbridge import --in soulbridge.jsonl');
+                throw new Error('usage: soulbridge import --from <steering.md> | --in <export.jsonl>');
             const { soul, deviceId } = open(flags);
             let memories = 0;
             let affects = 0;
@@ -251,7 +276,31 @@ async function main() {
                     affects += 1;
                 }
             }
-            out({ ok: true, memories, affects });
+            out({ ok: true, kind: 'jsonl', memories, affects });
+            return;
+        }
+        case 'ingest': {
+            const file = flags.file;
+            if (!file)
+                throw new Error('usage: soulbridge ingest --file transcript.jsonl [--dry-run]');
+            const { turns, skipped } = parseTranscriptJsonl(readFileSync(resolve(file), 'utf8'));
+            const { soul } = open(flags);
+            const dryRun = flags['dry-run'] === 'true';
+            if (!dryRun) {
+                for (const turn of turns) {
+                    if (turn.role !== 'user')
+                        continue;
+                    const signal = await soul.analyze(turn.content);
+                    try {
+                        soul.store.saveAffect(soul.soulId, soul.userId, signal, turn.at ?? Date.now(), soul.deviceId);
+                    }
+                    catch {
+                        // Evaluation data is best-effort; ingestion must still complete.
+                    }
+                }
+            }
+            const reflected = dryRun ? null : await soul.reflect(turns);
+            out({ ok: true, file: resolve(file), turns: turns.length, skipped, reflected, dryRun });
             return;
         }
         case 'stats': {
@@ -276,6 +325,8 @@ async function main() {
                 '  reflect --text|--file           会话反思',
                 '  export --out <file>             导出 JSONL',
                 '  import --in <file>              导入 JSONL',
+                '  import --from <steering.md>     导入 AGENTS.md / CLAUDE.md',
+                '  ingest --file <transcript.jsonl> 会话转写 → 记忆与情绪采样',
                 '  stats                           看状态',
                 '  demo                            端到端演示（无需模型）',
                 '',

package/dist/packages/core/src/index.js

@@ -13,6 +13,8 @@ export * from './affect/index.js';
 export { measureStyle } from './style/measure.js';
 export * from './storage/config.js';
 export * from './storage/merge.js';
+export * from './storage/steering.js';
+export * from './storage/transcript.js';
 import { buildContext } from './context.js';
 import { reflect, ruleExtract, nextEmotion } from './reflect.js';
 import { rank, tokenize } from './scoring.js';
@@ -55,14 +57,9 @@ export class Soul {
         this.store.touch(ranked.map((r) => r.memory.id));
         return ranked;
     }
-    /** Pure analysis, no storage: useful for the CLI and for tests. */
-    analyze(text) {
-        try {
-            return this.analyzer.analyze(text);
-        }
-        catch {
-            return analyzeAffect(text);
-        }
+    /** Pure analysis, no storage. Async because the analyzer may call a model. */
+    async analyze(text) {
+        return this.analyzeTurn(text);
     }
     /**
      * Verb 2: after each turn.

package/dist/packages/core/src/storage/steering.js

@@ -0,0 +1,83 @@
+export const STEERING_MAX_DRAFTS = 200;
+const MIN_LENGTH = 8;
+const MAX_LENGTH = 240;
+/** Lowercase, strip punctuation and whitespace — for duplicate detection only. */
+export function normalizeForDedupe(text) {
+    return text
+        .toLowerCase()
+        .replace(/[\s\p{P}\p{S}]/gu, '')
+        .slice(0, 400);
+}
+function classify(text) {
+    // Preference first: "我喜欢 X，不要 Y" is a trait, not a rule.
+    if (/(我喜欢|偏好|习惯|倾向|prefer|i like)/i.test(text)) {
+        return { type: 'trait', importance: 6 };
+    }
+    if (/(必须|禁止|不要|务必|一律|每次|never|must|always|shall)/i.test(text)) {
+        return { type: 'strategy', importance: 8 };
+    }
+    if (/(项目|仓库|目录|技术栈|使用|基于|project|repo|stack)/i.test(text)) {
+        return { type: 'fact', importance: 6 };
+    }
+    return { type: 'fact', importance: 5 };
+}
+function stripFences(text) {
+    return text.replace(/```[\s\S]*?```/g, '');
+}
+function clean(line) {
+    return line
+        .replace(/^[-*+]\s+/, '')
+        .replace(/^\d+[.)]\s+/, '')
+        .replace(/^\[[ xX]\]\s+/, '')
+        .replace(/\*\*|__|`/g, '')
+        .trim();
+}
+function isSkippable(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return true;
+    if (/^#{1,6}\s/.test(trimmed))
+        return true;
+    if (/^\|/.test(trimmed))
+        return true;
+    if (/^!\[/.test(trimmed))
+        return true;
+    if (/^<[^>]+>$/.test(trimmed))
+        return true;
+    if (/^https?:\/\//i.test(trimmed))
+        return true;
+    if (/^[-*_]{3,}$/.test(trimmed))
+        return true;
+    return false;
+}
+/**
+ * Extract memory candidates from a steering file.
+ * Headings are dropped on purpose: they carry structure, not statements.
+ */
+export function parseSteering(text) {
+    const body = stripFences(text);
+    const drafts = [];
+    const seen = new Set();
+    body.split(/\r?\n/).forEach((raw, index) => {
+        if (isSkippable(raw))
+            return;
+        const bullet = /^\s*(?:[-*+]|\d+[.)]|\[[ xX]\])\s+/.test(raw);
+        const content = clean(raw);
+        // Bullets are intentional statements; free paragraphs need more substance.
+        const minLength = bullet ? MIN_LENGTH : 12;
+        if (content.length < minLength || content.length > MAX_LENGTH)
+            return;
+        // Paragraphs are noisier than bullets; require a statement-like shape.
+        if (!bullet && !/[。.!！?？:]$/.test(content))
+            return;
+        if (!bullet && !/[\u4e00-\u9fa5]/.test(content) && content.split(/\s+/).length < 4)
+            return;
+        const key = normalizeForDedupe(content);
+        if (!key || seen.has(key))
+            return;
+        seen.add(key);
+        const { type, importance } = classify(content);
+        drafts.push({ text: content, type, importance, line: index + 1 });
+    });
+    return drafts.slice(0, STEERING_MAX_DRAFTS);
+}

package/dist/packages/core/src/storage/transcript.js

@@ -0,0 +1,70 @@
+const MAX_TURNS = 5000;
+const MAX_CONTENT = 20_000;
+function textOf(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (typeof part === 'string')
+                return part;
+            if (part && typeof part === 'object') {
+                const p = part;
+                if (typeof p.text === 'string')
+                    return p.text;
+            }
+            return '';
+        })
+            .join('\n');
+    }
+    return '';
+}
+function roleOf(record) {
+    const nested = record.message && typeof record.message === 'object'
+        ? record.message
+        : null;
+    const role = record.role ?? nested?.role ?? record.type;
+    if (role === 'user' || role === 'human')
+        return 'user';
+    if (role === 'assistant' || role === 'ai' || role === 'model')
+        return 'assistant';
+    return null;
+}
+export function parseTranscriptJsonl(text) {
+    const turns = [];
+    let skipped = 0;
+    for (const line of text.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let record;
+        try {
+            record = JSON.parse(trimmed);
+        }
+        catch {
+            skipped += 1;
+            continue;
+        }
+        const role = roleOf(record);
+        if (!role) {
+            skipped += 1;
+            continue;
+        }
+        const nested = record.message && typeof record.message === 'object'
+            ? record.message
+            : null;
+        const content = textOf(record.content ?? record.text ?? nested?.content).trim();
+        if (!content) {
+            skipped += 1;
+            continue;
+        }
+        const at = typeof record.at === 'number' ? record.at : undefined;
+        const last = turns.at(-1);
+        if (last && last.role === role && last.content === content)
+            continue;
+        turns.push({ role, content: content.slice(0, MAX_CONTENT), ...(at === undefined ? {} : { at }) });
+        if (turns.length >= MAX_TURNS)
+            break;
+    }
+    return { turns, skipped };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "soulbridge",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "A personality layer for any agent: continuity, forgetting, and growth across tools.",
   "license": "Apache-2.0",
   "type": "module",
@@ -9,6 +9,7 @@
   },
   "files": [
     "dist",
+    "adapters",
     "README.md",
     "LICENSE",
     "NOTICE"