@clawmem-ai/clawmem 0.1.18 → 0.1.19

package/dist/src/state.d.ts

@@ -0,0 +1,4 @@
+import type { PluginState } from "./types.js";
+export declare function resolveStatePath(stateDir: string): string;
+export declare function loadState(filePath: string): Promise<PluginState>;
+export declare function saveState(filePath: string, state: PluginState): Promise<void>;

package/dist/src/state.js

@@ -0,0 +1,182 @@
+import fs from "node:fs";
+import path from "node:path";
+import { normalizeAgentId, sessionScopeKey } from "./utils.js";
+const EMPTY_STATE = {
+    version: 4,
+    sessions: {},
+};
+export function resolveStatePath(stateDir) {
+    return path.join(stateDir, "clawmem", "state.json");
+}
+export async function loadState(filePath) {
+    try {
+        const raw = await fs.promises.readFile(filePath, "utf8");
+        return sanitizeState(JSON.parse(raw));
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            return structuredClone(EMPTY_STATE);
+        }
+        return structuredClone(EMPTY_STATE);
+    }
+}
+export async function saveState(filePath, state) {
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    const next = JSON.stringify(state, null, 2) + "\n";
+    const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    await fs.promises.writeFile(tmpPath, next, { encoding: "utf8", mode: 0o600 });
+    await fs.promises.rename(tmpPath, filePath);
+}
+function sanitizeState(value) {
+    if (!value || typeof value !== "object") {
+        return structuredClone(EMPTY_STATE);
+    }
+    const raw = value;
+    const sessions = raw.sessions && typeof raw.sessions === "object"
+        ? raw.sessions
+        : {};
+    const migrations = {};
+    if (raw.migrations && typeof raw.migrations === "object") {
+        for (const [k, v] of Object.entries(raw.migrations)) {
+            const s = readString(v);
+            if (s)
+                migrations[k] = s;
+        }
+    }
+    const out = {
+        version: 4,
+        sessions: {},
+        ...(Object.keys(migrations).length > 0 ? { migrations } : {}),
+    };
+    for (const [storedKey, sessionValue] of Object.entries(sessions)) {
+        if (!sessionValue || typeof sessionValue !== "object" || !storedKey.trim())
+            continue;
+        const rawSession = sessionValue;
+        const sessionId = readString(rawSession.sessionId) ?? storedKey.trim();
+        if (!sessionId)
+            continue;
+        const agentId = normalizeAgentId(readString(rawSession.agentId));
+        const lastMirroredCount = readNumber(rawSession.lastMirroredCount) ?? 0;
+        const finalizedAt = readString(rawSession.finalizedAt);
+        const derived = sanitizeDerivedState(rawSession, lastMirroredCount, finalizedAt);
+        out.sessions[sessionScopeKey(sessionId, agentId)] = {
+            sessionId,
+            sessionKey: readString(rawSession.sessionKey),
+            sessionFile: readString(rawSession.sessionFile),
+            agentId,
+            issueNumber: readNumber(rawSession.issueNumber),
+            issueTitle: readString(rawSession.issueTitle),
+            titleSource: readTitleSource(rawSession.titleSource),
+            lastMirroredCount,
+            turnCount: readNumber(rawSession.turnCount) ?? 0,
+            finalizedAt,
+            lastSummaryHash: readString(rawSession.lastSummaryHash),
+            derived,
+            createdAt: readString(rawSession.createdAt),
+            updatedAt: readString(rawSession.updatedAt),
+        };
+    }
+    return out;
+}
+function sanitizeDerivedState(rawSession, lastMirroredCount, finalizedAt) {
+    const rawDerived = asRecord(rawSession.derived);
+    const rawSummary = asRecord(rawDerived?.summary);
+    const rawMemory = asRecord(rawDerived?.memory);
+    const legacySummaryStatus = readEnum(rawSession.summaryStatus, ["pending", "complete"]);
+    const legacyMemoryCursor = readNumber(rawSession.lastMemorySyncCount);
+    const summaryText = readString(rawSummary?.text);
+    const summaryTitle = readString(rawSummary?.title);
+    const summaryStatus = readTaskStatus(rawSummary?.status, summaryText || legacySummaryStatus === "complete" ? "complete" : "idle");
+    const summaryCursor = clampCursor(readNumber(rawSummary?.basedOnCursor), summaryStatus === "complete" ? lastMirroredCount : 0, lastMirroredCount);
+    const capturedCursor = clampCursor(readNumber(rawMemory?.capturedCursor)
+        ?? readNumber(rawMemory?.appliedCursor)
+        ?? legacyMemoryCursor, summaryStatus === "complete" ? lastMirroredCount : 0, lastMirroredCount);
+    const memoryStatus = readTaskStatus(rawMemory?.status ?? rawMemory?.extractStatus ?? rawMemory?.reconcileStatus, capturedCursor >= lastMirroredCount && lastMirroredCount > 0 ? "complete" : "idle");
+    const candidates = readMemoryCandidates(rawMemory?.candidates);
+    return {
+        summary: {
+            basedOnCursor: summaryCursor,
+            status: finalizedAt && summaryStatus === "idle" && lastMirroredCount > 0 ? "error" : summaryStatus,
+            ...(summaryText ? { text: summaryText } : {}),
+            ...(summaryTitle ? { title: summaryTitle } : {}),
+            ...(readString(rawSummary?.lastError) ? { lastError: readString(rawSummary?.lastError) } : {}),
+            ...(readString(rawSummary?.updatedAt) ? { updatedAt: readString(rawSummary?.updatedAt) } : {}),
+        },
+        memory: {
+            capturedCursor,
+            status: memoryStatus,
+            ...(candidates ? { candidates } : {}),
+            ...(readString(rawMemory?.lastError) ? { lastError: readString(rawMemory?.lastError) } : {}),
+            ...(readString(rawMemory?.updatedAt) ? { updatedAt: readString(rawMemory?.updatedAt) } : {}),
+        },
+    };
+}
+function readString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function readEnum(value, allowed) {
+    const s = readString(value);
+    return s && allowed.includes(s) ? s : undefined;
+}
+function readNumber(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return undefined;
+    return Math.max(0, Math.floor(value));
+}
+function readTaskStatus(value, fallback) {
+    const status = readEnum(value, ["idle", "pending", "running", "complete", "error"]);
+    if (!status)
+        return fallback;
+    if (status === "pending" || status === "running")
+        return "idle";
+    return status;
+}
+function readTitleSource(value) {
+    const source = readEnum(value, ["placeholder", "digest", "llm"]);
+    if (!source)
+        return undefined;
+    return source === "digest" ? "llm" : source;
+}
+function readMemoryCandidates(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const out = value
+        .map((entry) => sanitizeMemoryCandidate(entry))
+        .filter((candidate) => candidate !== null);
+    return out;
+}
+function sanitizeMemoryCandidate(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    const candidateId = readString(record.candidateId);
+    const detail = readString(record.detail);
+    if (!candidateId || !detail)
+        return null;
+    const title = readString(record.title);
+    const kind = readString(record.kind);
+    const topics = Array.isArray(record.topics)
+        ? record.topics.map((topic) => readString(topic)).filter((topic) => Boolean(topic))
+        : undefined;
+    const evidence = readString(record.evidence);
+    return {
+        candidateId,
+        detail,
+        ...(title ? { title } : {}),
+        ...(kind ? { kind } : {}),
+        ...(topics && topics.length > 0 ? { topics } : {}),
+        ...(evidence ? { evidence } : {}),
+    };
+}
+function clampCursor(value, fallback, max) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return Math.min(max, Math.max(0, fallback));
+    return Math.min(max, Math.max(0, Math.floor(value)));
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}

package/dist/src/transcript.d.ts

@@ -0,0 +1,3 @@
+import type { NormalizedMessage, TranscriptSnapshot } from "./types.js";
+export declare function readTranscriptSnapshot(filePath: string): Promise<TranscriptSnapshot>;
+export declare function normalizeMessages(items: unknown[]): NormalizedMessage[];

package/dist/src/transcript.js

@@ -0,0 +1,164 @@
+import fs from "node:fs";
+export async function readTranscriptSnapshot(filePath) {
+    const raw = await fs.promises.readFile(filePath, "utf8");
+    const lines = raw
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    let sessionId;
+    const messages = [];
+    for (const line of lines) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const record = asRecord(parsed);
+        if (!record) {
+            continue;
+        }
+        if (!sessionId && record.type === "session" && typeof record.id === "string") {
+            sessionId = record.id.trim() || undefined;
+            continue;
+        }
+        const message = normalizeMessage(record.message ?? record);
+        if (message) {
+            messages.push(message);
+        }
+    }
+    return { sessionId, messages };
+}
+export function normalizeMessages(items) {
+    const out = [];
+    for (const item of items) {
+        const record = asRecord(item);
+        if (!record) {
+            continue;
+        }
+        const message = normalizeMessage(record.message ?? record);
+        if (message) {
+            out.push(message);
+        }
+    }
+    return out;
+}
+function normalizeMessage(value) {
+    const record = asRecord(value);
+    if (!record) {
+        return null;
+    }
+    const role = typeof record.role === "string" ? record.role : undefined;
+    if (role !== "assistant" && role !== "user") {
+        return null;
+    }
+    if (record.tool_call_id || record.toolCallId) {
+        return null;
+    }
+    const directText = typeof record.text === "string" ? normalizeChatText(record.text) : null;
+    const text = directText ?? extractChatText(record.content);
+    if (!text) {
+        return null;
+    }
+    const timestamp = normalizeTimestamp(record.timestamp);
+    const stopReason = typeof record.stopReason === "string" ? record.stopReason : undefined;
+    return {
+        role,
+        text,
+        ...(timestamp ? { timestamp } : {}),
+        ...(stopReason ? { stopReason } : {}),
+    };
+}
+function extractChatText(content) {
+    if (typeof content === "string") {
+        return normalizeChatText(content) ?? "";
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    const parts = [];
+    for (const block of content) {
+        if (typeof block === "string") {
+            const normalized = normalizeChatText(block);
+            if (normalized) {
+                parts.push(normalized);
+            }
+            continue;
+        }
+        const record = asRecord(block);
+        if (!record) {
+            continue;
+        }
+        const type = typeof record.type === "string" ? record.type.toLowerCase() : "";
+        if (type.includes("tool")) {
+            continue;
+        }
+        const textCandidates = [
+            record.text,
+            record.value,
+            record.content,
+            record.outputText,
+            record.inputText,
+        ];
+        for (const candidate of textCandidates) {
+            if (typeof candidate === "string") {
+                const normalized = normalizeChatText(candidate);
+                if (normalized) {
+                    parts.push(normalized);
+                }
+            }
+        }
+    }
+    return compactText(parts);
+}
+function normalizeChatText(value) {
+    let trimmed = stripUntrustedMetadataPrefixes(squashWhitespace(value));
+    if (!trimmed) {
+        return null;
+    }
+    trimmed = trimmed.replace(/^\[\[\s*reply_to[^\]]*\]\]\s*/i, "").trim();
+    if (!trimmed) {
+        return null;
+    }
+    const upper = trimmed.toUpperCase();
+    if (upper === "NO_REPLY" || upper === "HEARTBEAT_OK" || upper === "IDLE-CHAT") {
+        return null;
+    }
+    return trimmed;
+}
+function normalizeTimestamp(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return new Date(value).toISOString();
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        return trimmed || undefined;
+    }
+    return undefined;
+}
+function compactText(parts) {
+    return parts
+        .map((part) => (typeof part === "string" ? part.trim() : ""))
+        .filter((part) => part.length > 0)
+        .join("\n\n");
+}
+function squashWhitespace(value) {
+    return value.replace(/\r/g, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function stripUntrustedMetadataPrefixes(value) {
+    let current = value.trim();
+    for (;;) {
+        const next = current
+            .replace(/^Conversation info \(untrusted metadata\):\s*```(?:json)?\s*[\s\S]*?```\s*/i, "")
+            .replace(/^Sender \(untrusted metadata\):\s*```(?:json)?\s*[\s\S]*?```\s*/i, "")
+            .trim();
+        if (next === current) {
+            return current;
+        }
+        current = next;
+    }
+}
+function asRecord(value) {
+    return value && typeof value === "object" ? value : null;
+}

package/dist/src/types.d.ts

@@ -0,0 +1,130 @@
+export type ClawMemAgentConfig = {
+    baseUrl?: string;
+    login?: string;
+    defaultRepo?: string;
+    repo?: string;
+    token?: string;
+    authScheme?: "token" | "bearer";
+};
+export type ClawMemPluginConfig = {
+    baseUrl: string;
+    login?: string;
+    defaultRepo?: string;
+    repo?: string;
+    token?: string;
+    authScheme: "token" | "bearer";
+    agents: Record<string, ClawMemAgentConfig>;
+    memoryRecallLimit: number;
+    memoryAutoRecallLimit: number;
+    summaryWaitTimeoutMs: number;
+    memoryExtractWaitTimeoutMs: number;
+    reviewNudgeInterval: number;
+};
+export type ClawMemResolvedRoute = {
+    agentId: string;
+    baseUrl: string;
+    login?: string;
+    defaultRepo?: string;
+    repo?: string;
+    token?: string;
+    authScheme: "token" | "bearer";
+};
+export type BootstrapIdentityResponse = {
+    token: string;
+    repo_full_name: string;
+};
+export type AgentRegistrationResponse = BootstrapIdentityResponse & {
+    login: string;
+};
+export type AnonymousSessionResponse = BootstrapIdentityResponse & {
+    owner_login: string;
+    repo_name: string;
+};
+export type SessionTaskStatus = "idle" | "complete" | "error";
+export type MemoryCandidate = {
+    candidateId: string;
+    detail: string;
+    title?: string;
+    kind?: string;
+    topics?: string[];
+    evidence?: string;
+};
+export type SessionSummaryState = {
+    basedOnCursor: number;
+    status: SessionTaskStatus;
+    text?: string;
+    title?: string;
+    lastError?: string;
+    updatedAt?: string;
+};
+export type SessionMemoryState = {
+    capturedCursor: number;
+    status: SessionTaskStatus;
+    candidates?: MemoryCandidate[];
+    lastError?: string;
+    updatedAt?: string;
+};
+export type SessionDerivedState = {
+    summary: SessionSummaryState;
+    memory: SessionMemoryState;
+};
+export type SessionMirrorState = {
+    sessionId: string;
+    sessionKey?: string;
+    sessionFile?: string;
+    agentId?: string;
+    issueNumber?: number;
+    issueTitle?: string;
+    titleSource?: "placeholder" | "llm";
+    lastMirroredCount: number;
+    turnCount: number;
+    turnsSinceReview?: number;
+    finalizedAt?: string;
+    lastSummaryHash?: string;
+    derived?: SessionDerivedState;
+    createdAt?: string;
+    updatedAt?: string;
+};
+export type PluginState = {
+    version: 4;
+    sessions: Record<string, SessionMirrorState>;
+    migrations?: Record<string, string>;
+};
+export type NormalizedMessage = {
+    role: string;
+    text: string;
+    toolName?: string;
+    timestamp?: string;
+    stopReason?: string;
+};
+export type TranscriptSnapshot = {
+    sessionId?: string;
+    messages: NormalizedMessage[];
+};
+export type MemoryDraft = {
+    title?: string;
+    detail: string;
+    kind?: string;
+    topics?: string[];
+};
+export type MemorySchema = {
+    kinds: string[];
+    topics: string[];
+};
+export type MemoryListOptions = {
+    status?: "active" | "stale" | "all";
+    kind?: string;
+    topic?: string;
+    limit?: number;
+};
+export type ParsedMemoryIssue = {
+    issueNumber: number;
+    title: string;
+    memoryId: string;
+    memoryHash?: string;
+    date: string;
+    detail: string;
+    kind?: string;
+    topics?: string[];
+    status: "active" | "stale";
+};

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/utils.d.ts

@@ -0,0 +1,26 @@
+import type { NormalizedMessage } from "./types.js";
+export declare const DEFAULT_AGENT_ID = "main";
+export declare const DEFAULT_BOOTSTRAP_REPO_NAME = "memory";
+export declare function sha256(v: string): string;
+export declare function normalizeAgentId(value: string | undefined | null): string;
+export declare function normalizeLoginName(value: string | undefined | null): string | undefined;
+export declare function buildAgentBootstrapRegistration(agentId: string): {
+    prefixLogin: string;
+    defaultRepoName: string;
+};
+export declare function sessionScopeKey(sessionId: string, agentId?: string): string;
+export declare function inferAgentIdFromTranscriptPath(filePath: string): string | undefined;
+export declare function subKey(s: {
+    sessionId: string;
+    agentId?: string;
+}, suffix: string): string;
+export declare function fmtTranscript(msgs: NormalizedMessage[]): string;
+export declare function fmtTranscriptFrom(msgs: NormalizedMessage[], startIndex: number): string;
+export declare function sliceTranscriptDelta(msgs: NormalizedMessage[], fromIndex: number, anchorCount?: number): {
+    anchorStart: number;
+    deltaStart: number;
+    anchorMessages: NormalizedMessage[];
+    deltaMessages: NormalizedMessage[];
+};
+export declare function localDate(d?: Date): string;
+export declare function localDateTime(d: Date): string;

package/dist/src/utils.js

@@ -0,0 +1,62 @@
+// Shared utility helpers used by memory.ts and conversation.ts.
+import crypto from "node:crypto";
+import path from "node:path";
+export const DEFAULT_AGENT_ID = "main";
+export const DEFAULT_BOOTSTRAP_REPO_NAME = "memory";
+const MAX_AGENT_LOGIN_PREFIX_LEN = 32;
+export function sha256(v) { return crypto.createHash("sha256").update(v).digest("hex"); }
+export function normalizeAgentId(value) {
+    const trimmed = (value ?? "").trim().toLowerCase();
+    if (!trimmed)
+        return DEFAULT_AGENT_ID;
+    return trimmed.replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || DEFAULT_AGENT_ID;
+}
+export function normalizeLoginName(value) {
+    const trimmed = (value ?? "").trim().toLowerCase();
+    return trimmed || undefined;
+}
+export function buildAgentBootstrapRegistration(agentId) {
+    const prefixLogin = normalizeAgentId(agentId)
+        .replace(/_/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, MAX_AGENT_LOGIN_PREFIX_LEN)
+        .replace(/-+$/g, "") || DEFAULT_AGENT_ID;
+    return { prefixLogin, defaultRepoName: DEFAULT_BOOTSTRAP_REPO_NAME };
+}
+export function sessionScopeKey(sessionId, agentId) {
+    return `${normalizeAgentId(agentId)}:${sessionId.trim()}`;
+}
+export function inferAgentIdFromTranscriptPath(filePath) {
+    const parts = path.resolve(filePath).split(path.sep);
+    const idx = parts.lastIndexOf("agents");
+    if (idx < 0 || !parts[idx + 1] || parts[idx + 2] !== "sessions")
+        return undefined;
+    return normalizeAgentId(parts[idx + 1]);
+}
+export function subKey(s, suffix) {
+    const san = (v) => v.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "main";
+    return `agent:${san(s.agentId || "main")}:subagent:clawmem-${suffix}-${san(s.sessionId)}`;
+}
+export function fmtTranscript(msgs) {
+    return msgs.map((m, i) => `${i + 1}. ${m.role === "assistant" ? "assistant" : "user"}: ${m.text}`).join("\n\n");
+}
+export function fmtTranscriptFrom(msgs, startIndex) {
+    return msgs.map((m, i) => `${startIndex + i + 1}. ${m.role === "assistant" ? "assistant" : "user"}: ${m.text}`).join("\n\n");
+}
+export function sliceTranscriptDelta(msgs, fromIndex, anchorCount = 2) {
+    const deltaStart = Math.min(Math.max(0, Math.floor(fromIndex)), msgs.length);
+    const anchorStart = Math.max(0, deltaStart - Math.max(0, Math.floor(anchorCount)));
+    return {
+        anchorStart,
+        deltaStart,
+        anchorMessages: msgs.slice(anchorStart, deltaStart),
+        deltaMessages: msgs.slice(deltaStart),
+    };
+}
+export function localDate(d = new Date()) {
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+export function localDateTime(d) {
+    return `${localDate(d)}T${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}`;
+}

package/dist/src/yaml.d.ts

@@ -0,0 +1,2 @@
+export declare function stringifyFlatYaml(entries: Array<[key: string, value: string | undefined]>): string;
+export declare function parseFlatYaml(input: string): Record<string, string>;

package/dist/src/yaml.js

@@ -0,0 +1,81 @@
+export function stringifyFlatYaml(entries) {
+    const out = [];
+    for (const [key, rawValue] of entries) {
+        const value = rawValue ?? "";
+        if (value.includes("\n")) {
+            out.push(`${key}: |-`);
+            for (const line of value.split("\n")) {
+                out.push(`  ${line}`);
+            }
+            continue;
+        }
+        out.push(`${key}: ${formatScalar(value)}`);
+    }
+    return out.join("\n");
+}
+export function parseFlatYaml(input) {
+    const result = {};
+    const lines = input.replace(/\r/g, "").split("\n");
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        if (!line.trim()) {
+            continue;
+        }
+        const match = /^([A-Za-z0-9_]+):(?:\s(.*))?$/.exec(line);
+        if (!match) {
+            continue;
+        }
+        const key = match[1];
+        const rawValue = match[2] ?? "";
+        if (rawValue === "|-" || rawValue === "|") {
+            const block = [];
+            let cursor = index + 1;
+            while (cursor < lines.length) {
+                const blockLine = lines[cursor] ?? "";
+                if (blockLine.startsWith("  ")) {
+                    block.push(blockLine.slice(2));
+                    cursor += 1;
+                    continue;
+                }
+                if (!blockLine.trim()) {
+                    block.push("");
+                    cursor += 1;
+                    continue;
+                }
+                break;
+            }
+            result[key] = block.join("\n");
+            index = cursor - 1;
+            continue;
+        }
+        result[key] = parseScalar(rawValue.trim());
+    }
+    return result;
+}
+function formatScalar(value) {
+    if (value.length === 0) {
+        return '""';
+    }
+    if (/^[A-Za-z0-9_./:@ -]+$/.test(value) && !looksLikeYamlKeyword(value)) {
+        return value;
+    }
+    return JSON.stringify(value);
+}
+function parseScalar(value) {
+    if (!value) {
+        return "";
+    }
+    if (value.startsWith('"') && value.endsWith('"')) {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return value.slice(1, -1);
+        }
+    }
+    return value;
+}
+function looksLikeYamlKeyword(value) {
+    const lowered = value.trim().toLowerCase();
+    return lowered === "null" || lowered === "true" || lowered === "false" || lowered === "~";
+}