soulbridge 0.0.2 → 0.0.4

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

@@ -0,0 +1,83 @@
+/**
+ * Identity and location (ADR 0020).
+ *
+ * Cross-tool only works if every host resolves the same person: the database
+ * lives in the user's home (not the cwd), and the soul/user/device identity
+ * lives in a config file that all hosts read.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+export const DEFAULT_SOUL_ID = 'xiaoling';
+export const DEFAULT_USER_ID = 'local';
+export const DEFAULT_NAME = '小灵';
+export function soulbridgeHome() {
+    return process.env.SOULBRIDGE_HOME ?? join(homedir(), '.soulbridge');
+}
+export function configPath() {
+    return join(soulbridgeHome(), 'config.json');
+}
+export function defaultDbPath() {
+    return join(soulbridgeHome(), 'soul.db');
+}
+export function newDeviceId() {
+    return `dev_${randomBytes(4).toString('hex')}`;
+}
+/** DB location: explicit flag > env > home. Never the cwd. */
+export function resolveDbPath(explicit) {
+    return explicit ?? process.env.SOULBRIDGE_DB ?? defaultDbPath();
+}
+export function loadConfig() {
+    const file = configPath();
+    if (!existsSync(file))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        if (!parsed.soulId || !parsed.userId)
+            return null;
+        return {
+            soulId: parsed.soulId,
+            userId: parsed.userId,
+            name: parsed.name ?? DEFAULT_NAME,
+            deviceId: parsed.deviceId ?? newDeviceId(),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function saveConfig(config) {
+    const home = soulbridgeHome();
+    if (!existsSync(home))
+        mkdirSync(home, { recursive: true });
+    writeFileSync(configPath(), `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+}
+/**
+ * Read the config, creating or completing it when needed.
+ * Env overrides win, but are not persisted (an override is per-process).
+ */
+export function ensureConfig(overrides = {}) {
+    const loaded = loadConfig();
+    const env = {};
+    if (process.env.SOULBRIDGE_SOUL)
+        env.soulId = process.env.SOULBRIDGE_SOUL;
+    if (process.env.SOULBRIDGE_USER)
+        env.userId = process.env.SOULBRIDGE_USER;
+    if (process.env.SOULBRIDGE_NAME)
+        env.name = process.env.SOULBRIDGE_NAME;
+    const merged = {
+        soulId: overrides.soulId ?? env.soulId ?? loaded?.soulId ?? DEFAULT_SOUL_ID,
+        userId: overrides.userId ?? env.userId ?? loaded?.userId ?? DEFAULT_USER_ID,
+        name: overrides.name ?? env.name ?? loaded?.name ?? DEFAULT_NAME,
+        deviceId: overrides.deviceId ?? loaded?.deviceId ?? newDeviceId(),
+    };
+    const changed = !loaded ||
+        loaded.soulId !== merged.soulId ||
+        loaded.userId !== merged.userId ||
+        loaded.name !== merged.name ||
+        loaded.deviceId !== merged.deviceId;
+    if (changed)
+        saveConfig(merged);
+    return merged;
+}

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

@@ -0,0 +1,21 @@
+export function pickLatest(a, b) {
+    if (a.updatedAt !== b.updatedAt)
+        return a.updatedAt > b.updatedAt ? a : b;
+    return a.device >= b.device ? a : b;
+}
+/** Union by id, keeping tombstones (deletion must survive a merge). */
+export function mergeRecords(records) {
+    const byId = new Map();
+    for (const record of records) {
+        const existing = byId.get(record.id);
+        byId.set(record.id, existing ? pickLatest(existing, record) : record);
+    }
+    return [...byId.values()];
+}
+/** A record is visible only if the winning version is not a tombstone. */
+export function isVisible(record) {
+    return record.deleted !== true;
+}
+export function liveRecords(records) {
+    return mergeRecords(records).filter(isVisible);
+}

package/dist/packages/core/src/style/measure.js

@@ -0,0 +1,28 @@
+/**
+ * Output-side style measurement.
+ *
+ * This is the instrument for the emotion→behaviour experiment (ADR 0017): we
+ * measure what the agent actually wrote, never what it says about itself.
+ */
+import { SEED_LEXICON } from '../affect/seed-lexicon.js';
+import { normalizeForAffect, tokenizeForAffect } from '../affect/analyze.js';
+const CONFIRM_OPENERS = ['好的', '好', '我先', '让我先', '我理解', '先确认', '确认一下', '明白'];
+export function measureStyle(text, lexicon = SEED_LEXICON) {
+    if (typeof text !== 'string')
+        throw new TypeError('text must be a string');
+    const normalized = normalizeForAffect(text);
+    let hedges = 0;
+    if (lexicon.hedges.length > 0) {
+        const dict = new Set(lexicon.hedges);
+        const maxLen = lexicon.hedges.reduce((n, w) => Math.max(n, w.length), 1);
+        hedges = tokenizeForAffect(normalized, dict, maxLen).filter((t) => dict.has(t)).length;
+    }
+    const questions = (normalized.match(/\?/g) ?? []).length;
+    const head = normalized.trim().slice(0, 24);
+    return {
+        length: text.length,
+        hedgeRate: normalized.length > 0 ? Math.round(((hedges * 100) / normalized.length) * 100) / 100 : 0,
+        questions,
+        confirmFirst: CONFIRM_OPENERS.some((opener) => head.startsWith(opener)),
+    };
+}

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

@@ -12,3 +12,16 @@ export const DEFAULT_EMOTION = {
     curiosity: 0.3,
     contentment: 0.3,
 };
+export const EMPTY_AFFECT = {
+    analyzer: 'none',
+    hits: [],
+    dominant: null,
+    intensity: 0,
+    valence: 0,
+    arousal: 0,
+    features: { fillers: 0, hedges: 0, vague: 0, tokens: 0, density: 1 },
+    confidence: 0,
+    abstain: false,
+};
+/** Wire version of the four verbs. Additive changes bump MINOR (ADR 0005). */
+export const PROTOCOL_VERSION = '0.2';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "soulbridge",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "A personality layer for any agent: continuity, forgetting, and growth across tools.",
   "license": "Apache-2.0",
   "type": "module",