mirror of
https://github.com/harivansh-afk/clanker-agent.git
synced 2026-04-15 07:04:45 +00:00
Make memory runtime-native for companion chat
Replace the old project-scoped file memory plumbing with runtime-native conversational memory and remove obsolete pi-memory-md shipping/wiring. Co-authored-by: Codex <noreply@openai.com>
This commit is contained in:
parent
9765576c0a
commit
5c389efcf9
10 changed files with 1859 additions and 1536 deletions
|
|
@ -60,7 +60,7 @@ This installer:
|
|||
Preinstalled package sources are:
|
||||
|
||||
```json
|
||||
["npm:@e9n/pi-channels", "npm:pi-memory-md", "npm:pi-teams"]
|
||||
["npm:@e9n/pi-channels", "npm:pi-teams"]
|
||||
```
|
||||
|
||||
If `npm` is available, it also installs these packages during install.
|
||||
|
|
|
|||
|
|
@ -61,6 +61,15 @@ import {
|
|||
type ToolHtmlRenderer,
|
||||
} from "./export-html/index.js";
|
||||
import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
|
||||
import {
|
||||
RuntimeMemoryManager,
|
||||
type RuntimeMemoryForgetInput,
|
||||
type RuntimeMemoryRebuildResult,
|
||||
type RuntimeMemoryRememberInput,
|
||||
type RuntimeMemorySearchResult,
|
||||
type RuntimeMemoryStatus,
|
||||
type RuntimeMemoryRecord,
|
||||
} from "./memory/runtime-memory.js";
|
||||
import {
|
||||
type ContextUsage,
|
||||
type ExtensionCommandContextActions,
|
||||
|
|
@ -337,6 +346,8 @@ export class AgentSession {
|
|||
|
||||
// Base system prompt (without extension appends) - used to apply fresh appends each turn
|
||||
private _baseSystemPrompt = "";
|
||||
private _memoryManager: RuntimeMemoryManager;
|
||||
private _memoryWriteQueue: Promise<void> = Promise.resolve();
|
||||
|
||||
constructor(config: AgentSessionConfig) {
|
||||
this.agent = config.agent;
|
||||
|
|
@ -350,6 +361,10 @@ export class AgentSession {
|
|||
this._extensionRunnerRef = config.extensionRunnerRef;
|
||||
this._initialActiveToolNames = config.initialActiveToolNames;
|
||||
this._baseToolsOverride = config.baseToolsOverride;
|
||||
this._memoryManager = new RuntimeMemoryManager({
|
||||
sessionManager: this.sessionManager,
|
||||
settingsManager: this.settingsManager,
|
||||
});
|
||||
|
||||
// Always subscribe to agent events for internal handling
|
||||
// (session persistence, extensions, auto-compaction, retry logic)
|
||||
|
|
@ -499,6 +514,16 @@ export class AgentSession {
|
|||
this._resolveRetry();
|
||||
}
|
||||
}
|
||||
|
||||
if (event.message.role === "user" || event.message.role === "assistant") {
|
||||
try {
|
||||
this._memoryManager.recordMessage(event.message);
|
||||
} catch (error) {
|
||||
const message =
|
||||
error instanceof Error ? error.message : String(error);
|
||||
console.error(`[memory] episode write failed: ${message}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Check auto-retry and auto-compaction after agent completes
|
||||
|
|
@ -513,6 +538,10 @@ export class AgentSession {
|
|||
}
|
||||
|
||||
await this._checkCompaction(msg);
|
||||
|
||||
if (msg.stopReason !== "error") {
|
||||
this._enqueueMemoryPromotion(event.messages);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -667,6 +696,9 @@ export class AgentSession {
|
|||
dispose(): void {
|
||||
this._disconnectFromAgent();
|
||||
this._eventListeners = [];
|
||||
void this._memoryWriteQueue.finally(() => {
|
||||
this._memoryManager.dispose();
|
||||
});
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
|
|
@ -804,6 +836,82 @@ export class AgentSession {
|
|||
return this._resourceLoader.getPrompts().prompts;
|
||||
}
|
||||
|
||||
async transformRuntimeContext(
|
||||
messages: AgentMessage[],
|
||||
signal?: AbortSignal,
|
||||
): Promise<AgentMessage[]> {
|
||||
await this._awaitMemoryWrites();
|
||||
return this._memoryManager.injectContext(messages, { signal });
|
||||
}
|
||||
|
||||
async getMemoryStatus(): Promise<RuntimeMemoryStatus> {
|
||||
await this._awaitMemoryWrites();
|
||||
return this._memoryManager.getStatus();
|
||||
}
|
||||
|
||||
async getCoreMemories(): Promise<RuntimeMemoryRecord[]> {
|
||||
await this._awaitMemoryWrites();
|
||||
return this._memoryManager.listCoreMemories();
|
||||
}
|
||||
|
||||
async searchMemory(
|
||||
query: string,
|
||||
limit?: number,
|
||||
): Promise<RuntimeMemorySearchResult> {
|
||||
await this._awaitMemoryWrites();
|
||||
return this._memoryManager.search(query, limit);
|
||||
}
|
||||
|
||||
async rememberMemory(
|
||||
input: RuntimeMemoryRememberInput,
|
||||
): Promise<RuntimeMemoryRecord | null> {
|
||||
await this._awaitMemoryWrites();
|
||||
return this._memoryManager.remember(input);
|
||||
}
|
||||
|
||||
async forgetMemory(
|
||||
input: RuntimeMemoryForgetInput,
|
||||
): Promise<{ ok: true; forgotten: boolean }> {
|
||||
await this._awaitMemoryWrites();
|
||||
return this._memoryManager.forget(input);
|
||||
}
|
||||
|
||||
async rebuildMemory(): Promise<RuntimeMemoryRebuildResult> {
|
||||
await this._awaitMemoryWrites();
|
||||
return this._memoryManager.rebuild();
|
||||
}
|
||||
|
||||
private async _awaitMemoryWrites(): Promise<void> {
|
||||
try {
|
||||
await this._memoryWriteQueue;
|
||||
} catch {
|
||||
// Memory writes are best-effort; failures should not block chat.
|
||||
}
|
||||
}
|
||||
|
||||
private _enqueueMemoryPromotion(messages: AgentMessage[]): void {
|
||||
this._memoryWriteQueue = this._memoryWriteQueue
|
||||
.catch(() => undefined)
|
||||
.then(async () => {
|
||||
if (!this.model) {
|
||||
return;
|
||||
}
|
||||
const apiKey = await this._modelRegistry.getApiKey(this.model);
|
||||
if (!apiKey) {
|
||||
return;
|
||||
}
|
||||
await this._memoryManager.promoteTurn({
|
||||
model: this.model,
|
||||
apiKey,
|
||||
messages,
|
||||
});
|
||||
})
|
||||
.catch((error: unknown) => {
|
||||
const message = error instanceof Error ? error.message : String(error);
|
||||
console.error(`[memory] promotion failed: ${message}`);
|
||||
});
|
||||
}
|
||||
|
||||
private _normalizePromptSnippet(
|
||||
text: string | undefined,
|
||||
): string | undefined {
|
||||
|
|
|
|||
|
|
@ -1,963 +0,0 @@
|
|||
import {
|
||||
type Dirent,
|
||||
existsSync,
|
||||
mkdirSync,
|
||||
readdirSync,
|
||||
readFileSync,
|
||||
renameSync,
|
||||
statSync,
|
||||
writeFileSync,
|
||||
} from "node:fs";
|
||||
import { createHash } from "node:crypto";
|
||||
import { homedir } from "node:os";
|
||||
import { basename, dirname, join, relative, resolve, sep } from "node:path";
|
||||
import { execCommand } from "../exec.js";
|
||||
import type { SettingsManager } from "../settings-manager.js";
|
||||
import { parseFrontmatter } from "../../utils/frontmatter.js";
|
||||
import { HttpError } from "./internal-types.js";
|
||||
|
||||
export interface MemoryFrontmatter {
|
||||
description: string;
|
||||
limit?: number;
|
||||
tags?: string[];
|
||||
created?: string;
|
||||
updated?: string;
|
||||
}
|
||||
|
||||
export interface MemoryMdSettings {
|
||||
enabled?: boolean;
|
||||
repoUrl?: string;
|
||||
localPath?: string;
|
||||
autoSync?: {
|
||||
onSessionStart?: boolean;
|
||||
};
|
||||
injection?: "system-prompt" | "message-append";
|
||||
systemPrompt?: {
|
||||
maxTokens?: number;
|
||||
includeProjects?: string[];
|
||||
};
|
||||
}
|
||||
|
||||
export interface MemoryStatus {
|
||||
enabled: boolean;
|
||||
cwd: string;
|
||||
project: string;
|
||||
directory: string;
|
||||
localPath: string;
|
||||
repoUrl: string | null;
|
||||
repoConfigured: boolean;
|
||||
repositoryReady: boolean;
|
||||
initialized: boolean;
|
||||
dirty: boolean | null;
|
||||
fileCount: number;
|
||||
}
|
||||
|
||||
export interface MemoryFileSummary {
|
||||
path: string;
|
||||
description: string | null;
|
||||
tags: string[];
|
||||
created?: string;
|
||||
updated?: string;
|
||||
valid: boolean;
|
||||
}
|
||||
|
||||
export interface MemoryFileRecord {
|
||||
path: string;
|
||||
frontmatter: MemoryFrontmatter;
|
||||
content: string;
|
||||
}
|
||||
|
||||
export interface MemorySearchResult {
|
||||
path: string;
|
||||
match: string;
|
||||
description: string;
|
||||
tags: string[];
|
||||
}
|
||||
|
||||
export interface MemorySyncResult {
|
||||
success: boolean;
|
||||
message: string;
|
||||
configured: boolean;
|
||||
initialized: boolean;
|
||||
dirty: boolean | null;
|
||||
updated?: boolean;
|
||||
committed?: boolean;
|
||||
}
|
||||
|
||||
export type MemorySearchScope = "content" | "tags" | "description";
|
||||
export type MemorySyncAction = "pull" | "push" | "status";
|
||||
|
||||
const DEFAULT_LOCAL_PATH = join(homedir(), ".pi", "memory-md");
|
||||
const DEFAULT_MEMORY_SETTINGS: MemoryMdSettings = {
|
||||
enabled: true,
|
||||
repoUrl: "",
|
||||
localPath: DEFAULT_LOCAL_PATH,
|
||||
autoSync: { onSessionStart: true },
|
||||
injection: "message-append",
|
||||
systemPrompt: {
|
||||
maxTokens: 10000,
|
||||
includeProjects: ["current"],
|
||||
},
|
||||
};
|
||||
|
||||
function getCurrentDate(): string {
|
||||
return new Date().toISOString().split("T")[0] ?? "";
|
||||
}
|
||||
|
||||
function getLegacyProjectDirName(cwd: string): string {
|
||||
return basename(cwd);
|
||||
}
|
||||
|
||||
function getProjectDirName(cwd: string): string {
|
||||
const projectName = getLegacyProjectDirName(cwd);
|
||||
const hash = createHash("sha256")
|
||||
.update(resolve(cwd))
|
||||
.digest("hex")
|
||||
.slice(0, 12);
|
||||
return `${projectName}-${hash}`;
|
||||
}
|
||||
|
||||
function getMemoryDirCandidates(
|
||||
settings: MemoryMdSettings,
|
||||
cwd: string,
|
||||
): {
|
||||
preferred: string;
|
||||
legacy: string;
|
||||
} {
|
||||
const basePath = settings.localPath ?? DEFAULT_LOCAL_PATH;
|
||||
return {
|
||||
preferred: join(basePath, getProjectDirName(cwd)),
|
||||
legacy: join(basePath, getLegacyProjectDirName(cwd)),
|
||||
};
|
||||
}
|
||||
|
||||
function migrateLegacyMemoryDir(preferred: string, legacy: string): string {
|
||||
try {
|
||||
renameSync(legacy, preferred);
|
||||
return preferred;
|
||||
} catch {
|
||||
return legacy;
|
||||
}
|
||||
}
|
||||
|
||||
function normalizePathSeparators(value: string): string {
|
||||
return value.replaceAll("\\", "/");
|
||||
}
|
||||
|
||||
function expandPath(value: string): string {
|
||||
if (!value.startsWith("~")) {
|
||||
return value;
|
||||
}
|
||||
return join(homedir(), value.slice(1));
|
||||
}
|
||||
|
||||
function asRecord(value: unknown): Record<string, unknown> | null {
|
||||
if (typeof value !== "object" || value === null || Array.isArray(value)) {
|
||||
return null;
|
||||
}
|
||||
return value as Record<string, unknown>;
|
||||
}
|
||||
|
||||
function readScopedMemorySettings(
|
||||
settings: Record<string, unknown>,
|
||||
): MemoryMdSettings {
|
||||
const scoped = asRecord(settings["pi-memory-md"]);
|
||||
return scoped ? (scoped as MemoryMdSettings) : {};
|
||||
}
|
||||
|
||||
function getMemorySettings(settingsManager: SettingsManager): MemoryMdSettings {
|
||||
const globalSettings = readScopedMemorySettings(
|
||||
settingsManager.getGlobalSettings() as Record<string, unknown>,
|
||||
);
|
||||
const projectSettings = readScopedMemorySettings(
|
||||
settingsManager.getProjectSettings() as Record<string, unknown>,
|
||||
);
|
||||
const merged: MemoryMdSettings = {
|
||||
...DEFAULT_MEMORY_SETTINGS,
|
||||
...globalSettings,
|
||||
...projectSettings,
|
||||
autoSync: {
|
||||
...DEFAULT_MEMORY_SETTINGS.autoSync,
|
||||
...globalSettings.autoSync,
|
||||
...projectSettings.autoSync,
|
||||
},
|
||||
systemPrompt: {
|
||||
...DEFAULT_MEMORY_SETTINGS.systemPrompt,
|
||||
...globalSettings.systemPrompt,
|
||||
...projectSettings.systemPrompt,
|
||||
},
|
||||
};
|
||||
if (merged.localPath) {
|
||||
merged.localPath = expandPath(merged.localPath);
|
||||
}
|
||||
return merged;
|
||||
}
|
||||
|
||||
function getMemoryDir(settings: MemoryMdSettings, cwd: string): string {
|
||||
const { preferred, legacy } = getMemoryDirCandidates(settings, cwd);
|
||||
if (existsSync(preferred)) {
|
||||
return preferred;
|
||||
}
|
||||
if (existsSync(legacy)) {
|
||||
return migrateLegacyMemoryDir(preferred, legacy);
|
||||
}
|
||||
return preferred;
|
||||
}
|
||||
|
||||
function getProjectRepoPath(settings: MemoryMdSettings, cwd: string): string {
|
||||
const localPath = settings.localPath ?? DEFAULT_LOCAL_PATH;
|
||||
return normalizePathSeparators(relative(localPath, getMemoryDir(settings, cwd)));
|
||||
}
|
||||
|
||||
function validateFrontmatter(frontmatter: Record<string, unknown>): {
|
||||
valid: boolean;
|
||||
error?: string;
|
||||
} {
|
||||
if (
|
||||
typeof frontmatter.description !== "string" ||
|
||||
frontmatter.description.trim().length === 0
|
||||
) {
|
||||
return {
|
||||
valid: false,
|
||||
error: "Frontmatter must contain a non-empty description",
|
||||
};
|
||||
}
|
||||
if (
|
||||
frontmatter.limit !== undefined &&
|
||||
(typeof frontmatter.limit !== "number" || frontmatter.limit <= 0)
|
||||
) {
|
||||
return {
|
||||
valid: false,
|
||||
error: "Frontmatter limit must be a positive number",
|
||||
};
|
||||
}
|
||||
if (frontmatter.tags !== undefined) {
|
||||
if (!Array.isArray(frontmatter.tags)) {
|
||||
return {
|
||||
valid: false,
|
||||
error: "Frontmatter tags must be an array of strings",
|
||||
};
|
||||
}
|
||||
if (
|
||||
frontmatter.tags.some((tag) => typeof tag !== "string" || tag.length === 0)
|
||||
) {
|
||||
return {
|
||||
valid: false,
|
||||
error: "Frontmatter tags must contain only non-empty strings",
|
||||
};
|
||||
}
|
||||
}
|
||||
return { valid: true };
|
||||
}
|
||||
|
||||
function normalizeFrontmatter(frontmatter: Record<string, unknown>): MemoryFrontmatter {
|
||||
return {
|
||||
description: frontmatter.description as string,
|
||||
...(typeof frontmatter.limit === "number"
|
||||
? { limit: frontmatter.limit }
|
||||
: {}),
|
||||
...(Array.isArray(frontmatter.tags)
|
||||
? {
|
||||
tags: frontmatter.tags.filter(
|
||||
(tag): tag is string => typeof tag === "string",
|
||||
),
|
||||
}
|
||||
: {}),
|
||||
...(typeof frontmatter.created === "string"
|
||||
? { created: frontmatter.created }
|
||||
: {}),
|
||||
...(typeof frontmatter.updated === "string"
|
||||
? { updated: frontmatter.updated }
|
||||
: {}),
|
||||
};
|
||||
}
|
||||
|
||||
function readMemoryFile(filePath: string): MemoryFileRecord | null {
|
||||
try {
|
||||
const content = readFileSync(filePath, "utf8");
|
||||
const parsed = parseFrontmatter<Record<string, unknown>>(content);
|
||||
const validation = validateFrontmatter(parsed.frontmatter);
|
||||
if (!validation.valid) {
|
||||
return null;
|
||||
}
|
||||
return {
|
||||
path: filePath,
|
||||
frontmatter: normalizeFrontmatter(parsed.frontmatter),
|
||||
content: parsed.body,
|
||||
};
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function escapeYamlString(value: string): string {
|
||||
return JSON.stringify(value);
|
||||
}
|
||||
|
||||
function serializeFrontmatter(frontmatter: MemoryFrontmatter): string {
|
||||
const lines = ["---", `description: ${escapeYamlString(frontmatter.description)}`];
|
||||
if (typeof frontmatter.limit === "number") {
|
||||
lines.push(`limit: ${frontmatter.limit}`);
|
||||
}
|
||||
if (frontmatter.tags && frontmatter.tags.length > 0) {
|
||||
lines.push("tags:");
|
||||
for (const tag of frontmatter.tags) {
|
||||
lines.push(` - ${escapeYamlString(tag)}`);
|
||||
}
|
||||
}
|
||||
if (frontmatter.created) {
|
||||
lines.push(`created: ${escapeYamlString(frontmatter.created)}`);
|
||||
}
|
||||
if (frontmatter.updated) {
|
||||
lines.push(`updated: ${escapeYamlString(frontmatter.updated)}`);
|
||||
}
|
||||
lines.push("---");
|
||||
return lines.join("\n");
|
||||
}
|
||||
|
||||
function writeMemoryFile(
|
||||
filePath: string,
|
||||
content: string,
|
||||
frontmatter: MemoryFrontmatter,
|
||||
): void {
|
||||
mkdirSync(dirname(filePath), { recursive: true });
|
||||
const normalizedContent = content.replace(/\r\n/g, "\n");
|
||||
const body = normalizedContent.endsWith("\n")
|
||||
? normalizedContent
|
||||
: `${normalizedContent}\n`;
|
||||
const output = `${serializeFrontmatter(frontmatter)}\n\n${body}`;
|
||||
writeFileSync(filePath, output, "utf8");
|
||||
}
|
||||
|
||||
function listMemoryFiles(memoryDir: string): string[] {
|
||||
if (!existsSync(memoryDir)) {
|
||||
return [];
|
||||
}
|
||||
const files: string[] = [];
|
||||
const stack = [memoryDir];
|
||||
|
||||
while (stack.length > 0) {
|
||||
const currentDir = stack.pop();
|
||||
if (!currentDir) {
|
||||
continue;
|
||||
}
|
||||
let entries: Dirent[];
|
||||
try {
|
||||
entries = readdirSync(currentDir, { withFileTypes: true });
|
||||
} catch {
|
||||
continue;
|
||||
}
|
||||
for (const entry of entries) {
|
||||
const fullPath = join(currentDir, entry.name);
|
||||
if (entry.isDirectory()) {
|
||||
stack.push(fullPath);
|
||||
continue;
|
||||
}
|
||||
if (entry.isFile() && entry.name.endsWith(".md")) {
|
||||
files.push(fullPath);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return files.sort((left, right) => left.localeCompare(right));
|
||||
}
|
||||
|
||||
function ensureDirectoryStructure(memoryDir: string): void {
|
||||
const directories = [
|
||||
join(memoryDir, "core", "user"),
|
||||
join(memoryDir, "core", "project"),
|
||||
join(memoryDir, "reference"),
|
||||
];
|
||||
for (const directory of directories) {
|
||||
mkdirSync(directory, { recursive: true });
|
||||
}
|
||||
}
|
||||
|
||||
function ensureDefaultFiles(memoryDir: string): void {
|
||||
const identityPath = join(memoryDir, "core", "user", "identity.md");
|
||||
if (!existsSync(identityPath)) {
|
||||
writeMemoryFile(
|
||||
identityPath,
|
||||
"# User Identity\n\nCustomize this file with your information.",
|
||||
{
|
||||
description: "User identity and background",
|
||||
tags: ["user", "identity"],
|
||||
created: getCurrentDate(),
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
const preferencesPath = join(memoryDir, "core", "user", "prefer.md");
|
||||
if (!existsSync(preferencesPath)) {
|
||||
writeMemoryFile(
|
||||
preferencesPath,
|
||||
"# User Preferences\n\n## Communication Style\n- Be concise\n- Show code examples\n\n## Code Style\n- 2 space indentation\n- Prefer const over var\n- Functional programming preferred",
|
||||
{
|
||||
description: "User habits and code style preferences",
|
||||
tags: ["user", "preferences"],
|
||||
created: getCurrentDate(),
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function resolveWithinMemoryDir(memoryDir: string, relativePath: string): string {
|
||||
const trimmed = relativePath.trim();
|
||||
if (trimmed.length === 0) {
|
||||
throw new HttpError(400, "Memory path is required");
|
||||
}
|
||||
const resolvedPath = resolve(memoryDir, trimmed);
|
||||
const resolvedRoot = resolve(memoryDir);
|
||||
if (
|
||||
resolvedPath !== resolvedRoot &&
|
||||
!resolvedPath.startsWith(`${resolvedRoot}${sep}`)
|
||||
) {
|
||||
throw new HttpError(400, `Memory path escapes root: ${relativePath}`);
|
||||
}
|
||||
return resolvedPath;
|
||||
}
|
||||
|
||||
function summarizeMemoryFile(
|
||||
memoryDir: string,
|
||||
filePath: string,
|
||||
): MemoryFileSummary {
|
||||
const relativePath = normalizePathSeparators(relative(memoryDir, filePath));
|
||||
const memoryFile = readMemoryFile(filePath);
|
||||
if (!memoryFile) {
|
||||
return {
|
||||
path: relativePath,
|
||||
description: null,
|
||||
tags: [],
|
||||
valid: false,
|
||||
};
|
||||
}
|
||||
return {
|
||||
path: relativePath,
|
||||
description: memoryFile.frontmatter.description,
|
||||
tags: memoryFile.frontmatter.tags ?? [],
|
||||
created: memoryFile.frontmatter.created,
|
||||
updated: memoryFile.frontmatter.updated,
|
||||
valid: true,
|
||||
};
|
||||
}
|
||||
|
||||
function readMemoryFileOrThrow(
|
||||
memoryDir: string,
|
||||
relativePath: string,
|
||||
): MemoryFileRecord {
|
||||
const fullPath = resolveWithinMemoryDir(memoryDir, relativePath);
|
||||
if (!existsSync(fullPath)) {
|
||||
throw new HttpError(404, `Memory file not found: ${relativePath}`);
|
||||
}
|
||||
const memoryFile = readMemoryFile(fullPath);
|
||||
if (!memoryFile) {
|
||||
throw new HttpError(422, `Invalid memory file: ${relativePath}`);
|
||||
}
|
||||
return {
|
||||
...memoryFile,
|
||||
path: normalizePathSeparators(relative(memoryDir, fullPath)),
|
||||
};
|
||||
}
|
||||
|
||||
async function runGit(
|
||||
cwd: string,
|
||||
...args: string[]
|
||||
): Promise<{ success: boolean; stdout: string; stderr: string }> {
|
||||
const result = await execCommand("git", args, cwd, { timeout: 30_000 });
|
||||
return {
|
||||
success: result.code === 0 && !result.killed,
|
||||
stdout: result.stdout,
|
||||
stderr: result.stderr,
|
||||
};
|
||||
}
|
||||
|
||||
function getRepoName(settings: MemoryMdSettings): string {
|
||||
if (!settings.repoUrl) {
|
||||
return "memory-md";
|
||||
}
|
||||
const match = settings.repoUrl.match(/\/([^/]+?)(\.git)?$/);
|
||||
return match?.[1] ?? "memory-md";
|
||||
}
|
||||
|
||||
async function getGitHead(cwd: string): Promise<string | null> {
|
||||
const result = await runGit(cwd, "rev-parse", "HEAD");
|
||||
if (!result.success) {
|
||||
return null;
|
||||
}
|
||||
const head = result.stdout.trim();
|
||||
return head.length > 0 ? head : null;
|
||||
}
|
||||
|
||||
async function getRepositoryDirtyState(
|
||||
localPath: string,
|
||||
projectPath?: string,
|
||||
): Promise<boolean | null> {
|
||||
if (!existsSync(join(localPath, ".git"))) {
|
||||
return null;
|
||||
}
|
||||
const args = projectPath
|
||||
? ["status", "--porcelain", "--", projectPath]
|
||||
: ["status", "--porcelain"];
|
||||
const result = await runGit(localPath, ...args);
|
||||
if (!result.success) {
|
||||
return null;
|
||||
}
|
||||
return result.stdout.trim().length > 0;
|
||||
}
|
||||
|
||||
async function syncRepository(
|
||||
settings: MemoryMdSettings,
|
||||
): Promise<{ success: boolean; message: string; updated?: boolean }> {
|
||||
const localPath = settings.localPath ?? DEFAULT_LOCAL_PATH;
|
||||
const repoUrl = settings.repoUrl?.trim() ?? "";
|
||||
|
||||
if (!repoUrl) {
|
||||
return {
|
||||
success: false,
|
||||
message: "Memory repo URL is not configured",
|
||||
};
|
||||
}
|
||||
|
||||
if (existsSync(localPath)) {
|
||||
if (!existsSync(join(localPath, ".git"))) {
|
||||
let existingEntries: string[];
|
||||
try {
|
||||
existingEntries = readdirSync(localPath);
|
||||
} catch {
|
||||
return {
|
||||
success: false,
|
||||
message: `Path exists but is not a directory: ${localPath}`,
|
||||
};
|
||||
}
|
||||
if (existingEntries.length === 0) {
|
||||
const cloneIntoEmptyDir = await runGit(localPath, "clone", repoUrl, ".");
|
||||
if (!cloneIntoEmptyDir.success) {
|
||||
return {
|
||||
success: false,
|
||||
message:
|
||||
cloneIntoEmptyDir.stderr.trim() ||
|
||||
"Clone failed. Check repo URL and auth.",
|
||||
};
|
||||
}
|
||||
return {
|
||||
success: true,
|
||||
message: `Cloned ${getRepoName(settings)} successfully`,
|
||||
updated: true,
|
||||
};
|
||||
}
|
||||
return {
|
||||
success: false,
|
||||
message: `Directory exists but is not a git repo: ${localPath}`,
|
||||
};
|
||||
}
|
||||
const previousHead = await getGitHead(localPath);
|
||||
const pullResult = await runGit(localPath, "pull", "--rebase", "--autostash");
|
||||
if (!pullResult.success) {
|
||||
return {
|
||||
success: false,
|
||||
message:
|
||||
pullResult.stderr.trim() || "Pull failed. Check repository state.",
|
||||
};
|
||||
}
|
||||
const currentHead = await getGitHead(localPath);
|
||||
const updated =
|
||||
previousHead !== null &&
|
||||
currentHead !== null &&
|
||||
previousHead !== currentHead;
|
||||
const message =
|
||||
previousHead === null || currentHead === null
|
||||
? `Synchronized ${getRepoName(settings)}`
|
||||
: updated
|
||||
? `Pulled latest changes from ${getRepoName(settings)}`
|
||||
: `${getRepoName(settings)} is already up to date`;
|
||||
return {
|
||||
success: true,
|
||||
message,
|
||||
updated,
|
||||
};
|
||||
}
|
||||
|
||||
mkdirSync(dirname(localPath), { recursive: true });
|
||||
const cloneResult = await runGit(
|
||||
dirname(localPath),
|
||||
"clone",
|
||||
repoUrl,
|
||||
basename(localPath),
|
||||
);
|
||||
if (!cloneResult.success) {
|
||||
return {
|
||||
success: false,
|
||||
message: cloneResult.stderr.trim() || "Clone failed. Check repo URL and auth.",
|
||||
};
|
||||
}
|
||||
return {
|
||||
success: true,
|
||||
message: `Cloned ${getRepoName(settings)} successfully`,
|
||||
updated: true,
|
||||
};
|
||||
}
|
||||
|
||||
export async function getMemoryStatus(
|
||||
settingsManager: SettingsManager,
|
||||
cwd: string,
|
||||
): Promise<MemoryStatus> {
|
||||
const settings = getMemorySettings(settingsManager);
|
||||
const localPath = settings.localPath ?? DEFAULT_LOCAL_PATH;
|
||||
const memoryDir = getMemoryDir(settings, cwd);
|
||||
const initialized = existsSync(join(memoryDir, "core", "user"));
|
||||
const fileCount = listMemoryFiles(memoryDir).length;
|
||||
const dirty = await getRepositoryDirtyState(
|
||||
localPath,
|
||||
getProjectRepoPath(settings, cwd),
|
||||
);
|
||||
return {
|
||||
enabled: settings.enabled ?? true,
|
||||
cwd,
|
||||
project: basename(cwd),
|
||||
directory: memoryDir,
|
||||
localPath,
|
||||
repoUrl: settings.repoUrl?.trim() || null,
|
||||
repoConfigured: Boolean(settings.repoUrl?.trim()),
|
||||
repositoryReady: existsSync(join(localPath, ".git")),
|
||||
initialized,
|
||||
dirty,
|
||||
fileCount,
|
||||
};
|
||||
}
|
||||
|
||||
export async function initializeMemory(
|
||||
settingsManager: SettingsManager,
|
||||
cwd: string,
|
||||
options: { force?: boolean } = {},
|
||||
): Promise<{
|
||||
ok: true;
|
||||
created: boolean;
|
||||
message: string;
|
||||
memory: MemoryStatus;
|
||||
}> {
|
||||
const settings = getMemorySettings(settingsManager);
|
||||
const localPath = settings.localPath ?? DEFAULT_LOCAL_PATH;
|
||||
const memoryDir = getMemoryDir(settings, cwd);
|
||||
const initialized = existsSync(join(memoryDir, "core", "user"));
|
||||
|
||||
if (settings.repoUrl?.trim()) {
|
||||
const repositoryReady = existsSync(join(localPath, ".git"));
|
||||
if (!initialized || options.force || !repositoryReady) {
|
||||
const syncResult = await syncRepository(settings);
|
||||
if (!syncResult.success) {
|
||||
throw new HttpError(409, syncResult.message);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
mkdirSync(localPath, { recursive: true });
|
||||
}
|
||||
|
||||
ensureDirectoryStructure(memoryDir);
|
||||
ensureDefaultFiles(memoryDir);
|
||||
|
||||
return {
|
||||
ok: true,
|
||||
created: !initialized,
|
||||
message:
|
||||
settings.repoUrl?.trim()
|
||||
? initialized
|
||||
? "Memory repository refreshed and project memory verified"
|
||||
: "Memory repository initialized for this project"
|
||||
: initialized
|
||||
? "Local memory verified"
|
||||
: "Local memory initialized",
|
||||
memory: await getMemoryStatus(settingsManager, cwd),
|
||||
};
|
||||
}
|
||||
|
||||
export async function listProjectMemoryFiles(
|
||||
settingsManager: SettingsManager,
|
||||
cwd: string,
|
||||
directory?: string,
|
||||
): Promise<{
|
||||
directory: string;
|
||||
files: MemoryFileSummary[];
|
||||
}> {
|
||||
const settings = getMemorySettings(settingsManager);
|
||||
const memoryDir = getMemoryDir(settings, cwd);
|
||||
const searchDir = directory
|
||||
? resolveWithinMemoryDir(memoryDir, directory)
|
||||
: memoryDir;
|
||||
const files = listMemoryFiles(searchDir).map((filePath) =>
|
||||
summarizeMemoryFile(memoryDir, filePath),
|
||||
);
|
||||
return {
|
||||
directory: directory?.trim() || "",
|
||||
files,
|
||||
};
|
||||
}
|
||||
|
||||
export async function readProjectMemoryFile(
|
||||
settingsManager: SettingsManager,
|
||||
cwd: string,
|
||||
relativePath: string,
|
||||
): Promise<{ file: MemoryFileRecord }> {
|
||||
const settings = getMemorySettings(settingsManager);
|
||||
const memoryDir = getMemoryDir(settings, cwd);
|
||||
return {
|
||||
file: readMemoryFileOrThrow(memoryDir, relativePath),
|
||||
};
|
||||
}
|
||||
|
||||
export async function writeProjectMemoryFile(
|
||||
settingsManager: SettingsManager,
|
||||
cwd: string,
|
||||
params: {
|
||||
path: string;
|
||||
content: string;
|
||||
description: string;
|
||||
tags?: string[];
|
||||
},
|
||||
): Promise<{ ok: true; file: MemoryFileRecord }> {
|
||||
const relativePath = params.path.trim();
|
||||
if (!relativePath.endsWith(".md")) {
|
||||
throw new HttpError(400, "Memory files must use the .md extension");
|
||||
}
|
||||
if (params.description.trim().length === 0) {
|
||||
throw new HttpError(400, "Memory description is required");
|
||||
}
|
||||
|
||||
const settings = getMemorySettings(settingsManager);
|
||||
const memoryDir = getMemoryDir(settings, cwd);
|
||||
const fullPath = resolveWithinMemoryDir(memoryDir, relativePath);
|
||||
if (existsSync(fullPath) && statSync(fullPath).isDirectory()) {
|
||||
throw new HttpError(400, `Memory path points to a directory: ${relativePath}`);
|
||||
}
|
||||
const existing = existsSync(fullPath) ? readMemoryFile(fullPath) : null;
|
||||
|
||||
const hasTagsInput = params.tags !== undefined;
|
||||
const tags = (params.tags ?? []).map((tag) => tag.trim()).filter(Boolean);
|
||||
const frontmatter: MemoryFrontmatter = {
|
||||
description: params.description.trim(),
|
||||
created: existing?.frontmatter.created ?? getCurrentDate(),
|
||||
updated: getCurrentDate(),
|
||||
...(existing?.frontmatter.limit !== undefined
|
||||
? { limit: existing.frontmatter.limit }
|
||||
: {}),
|
||||
...(hasTagsInput
|
||||
? { tags }
|
||||
: existing?.frontmatter.tags
|
||||
? { tags: existing.frontmatter.tags }
|
||||
: {}),
|
||||
};
|
||||
|
||||
writeMemoryFile(fullPath, params.content, frontmatter);
|
||||
|
||||
return {
|
||||
ok: true,
|
||||
file: {
|
||||
path: normalizePathSeparators(relative(memoryDir, fullPath)),
|
||||
frontmatter,
|
||||
content: params.content.replace(/\r\n/g, "\n"),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
export async function searchProjectMemory(
|
||||
settingsManager: SettingsManager,
|
||||
cwd: string,
|
||||
query: string,
|
||||
searchIn: MemorySearchScope,
|
||||
): Promise<{ results: MemorySearchResult[] }> {
|
||||
const normalizedQuery = query.trim().toLowerCase();
|
||||
if (normalizedQuery.length === 0) {
|
||||
throw new HttpError(400, "Memory search query is required");
|
||||
}
|
||||
|
||||
const settings = getMemorySettings(settingsManager);
|
||||
const memoryDir = getMemoryDir(settings, cwd);
|
||||
const results: MemorySearchResult[] = [];
|
||||
|
||||
for (const filePath of listMemoryFiles(memoryDir)) {
|
||||
const memoryFile = readMemoryFile(filePath);
|
||||
if (!memoryFile) {
|
||||
continue;
|
||||
}
|
||||
const relativePath = normalizePathSeparators(relative(memoryDir, filePath));
|
||||
if (searchIn === "content") {
|
||||
if (!memoryFile.content.toLowerCase().includes(normalizedQuery)) {
|
||||
continue;
|
||||
}
|
||||
const match =
|
||||
memoryFile.content
|
||||
.split("\n")
|
||||
.find((line) => line.toLowerCase().includes(normalizedQuery)) ??
|
||||
memoryFile.content.slice(0, 120);
|
||||
results.push({
|
||||
path: relativePath,
|
||||
match,
|
||||
description: memoryFile.frontmatter.description,
|
||||
tags: memoryFile.frontmatter.tags ?? [],
|
||||
});
|
||||
continue;
|
||||
}
|
||||
|
||||
if (searchIn === "tags") {
|
||||
const tags = memoryFile.frontmatter.tags ?? [];
|
||||
if (!tags.some((tag) => tag.toLowerCase().includes(normalizedQuery))) {
|
||||
continue;
|
||||
}
|
||||
results.push({
|
||||
path: relativePath,
|
||||
match: `Tags: ${tags.join(", ")}`,
|
||||
description: memoryFile.frontmatter.description,
|
||||
tags,
|
||||
});
|
||||
continue;
|
||||
}
|
||||
|
||||
if (
|
||||
memoryFile.frontmatter.description.toLowerCase().includes(normalizedQuery)
|
||||
) {
|
||||
results.push({
|
||||
path: relativePath,
|
||||
match: memoryFile.frontmatter.description,
|
||||
description: memoryFile.frontmatter.description,
|
||||
tags: memoryFile.frontmatter.tags ?? [],
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return { results };
|
||||
}
|
||||
|
||||
export async function syncProjectMemory(
|
||||
settingsManager: SettingsManager,
|
||||
cwd: string,
|
||||
action: MemorySyncAction,
|
||||
): Promise<MemorySyncResult> {
|
||||
const settings = getMemorySettings(settingsManager);
|
||||
const localPath = settings.localPath ?? DEFAULT_LOCAL_PATH;
|
||||
const projectPath = getProjectRepoPath(settings, cwd);
|
||||
const configured = Boolean(settings.repoUrl?.trim());
|
||||
const repositoryReady = existsSync(join(localPath, ".git"));
|
||||
const initialized = existsSync(join(getMemoryDir(settings, cwd), "core", "user"));
|
||||
|
||||
if (action === "status") {
|
||||
const dirty = await getRepositoryDirtyState(localPath, projectPath);
|
||||
return {
|
||||
success: repositoryReady && dirty !== null,
|
||||
message: repositoryReady
|
||||
? dirty === null
|
||||
? "Memory repository status is unavailable"
|
||||
: dirty
|
||||
? "Memory repository has uncommitted changes"
|
||||
: "Memory repository is clean"
|
||||
: configured
|
||||
? "Memory repository is not initialized"
|
||||
: "Memory repository is not configured",
|
||||
configured,
|
||||
initialized,
|
||||
dirty,
|
||||
};
|
||||
}
|
||||
|
||||
if (!configured) {
|
||||
return {
|
||||
success: false,
|
||||
message: "Memory repo URL is not configured",
|
||||
configured,
|
||||
initialized,
|
||||
dirty: null,
|
||||
};
|
||||
}
|
||||
|
||||
if (action === "pull") {
|
||||
const result = await syncRepository(settings);
|
||||
return {
|
||||
success: result.success,
|
||||
message: result.message,
|
||||
configured,
|
||||
initialized,
|
||||
dirty: await getRepositoryDirtyState(localPath, projectPath),
|
||||
updated: result.updated,
|
||||
};
|
||||
}
|
||||
|
||||
const syncResult = await syncRepository(settings);
|
||||
if (!syncResult.success) {
|
||||
return {
|
||||
success: false,
|
||||
message: syncResult.message,
|
||||
configured,
|
||||
initialized,
|
||||
dirty: null,
|
||||
updated: syncResult.updated,
|
||||
};
|
||||
}
|
||||
|
||||
const statusResult = await runGit(
|
||||
localPath,
|
||||
"status",
|
||||
"--porcelain",
|
||||
"--",
|
||||
projectPath,
|
||||
);
|
||||
if (!statusResult.success) {
|
||||
return {
|
||||
success: false,
|
||||
message: statusResult.stderr.trim() || "Failed to inspect memory repository",
|
||||
configured,
|
||||
initialized,
|
||||
dirty: null,
|
||||
};
|
||||
}
|
||||
|
||||
const hasChanges = statusResult.stdout.trim().length > 0;
|
||||
if (hasChanges) {
|
||||
const addResult = await runGit(localPath, "add", "-A", "--", projectPath);
|
||||
if (!addResult.success) {
|
||||
return {
|
||||
success: false,
|
||||
message: addResult.stderr.trim() || "Failed to stage memory changes",
|
||||
configured,
|
||||
initialized,
|
||||
dirty: true,
|
||||
};
|
||||
}
|
||||
|
||||
const timestamp = new Date()
|
||||
.toISOString()
|
||||
.replace(/[:.]/g, "-")
|
||||
.slice(0, 19);
|
||||
const commitResult = await runGit(
|
||||
localPath,
|
||||
"commit",
|
||||
"-m",
|
||||
`Update memory for ${basename(cwd)} - ${timestamp}`,
|
||||
"--only",
|
||||
"--",
|
||||
projectPath,
|
||||
);
|
||||
if (!commitResult.success) {
|
||||
return {
|
||||
success: false,
|
||||
message:
|
||||
commitResult.stderr.trim() || "Failed to commit memory changes",
|
||||
configured,
|
||||
initialized,
|
||||
dirty: true,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
const pushResult = await runGit(localPath, "push");
|
||||
return {
|
||||
success: pushResult.success,
|
||||
message: pushResult.success
|
||||
? hasChanges
|
||||
? "Committed and pushed memory changes"
|
||||
: "No memory changes to push"
|
||||
: pushResult.stderr.trim() || "Failed to push memory changes",
|
||||
configured,
|
||||
initialized,
|
||||
dirty: await getRepositoryDirtyState(localPath, projectPath),
|
||||
committed: hasChanges,
|
||||
updated: syncResult.updated,
|
||||
};
|
||||
}
|
||||
|
|
@ -29,15 +29,6 @@ import type {
|
|||
HistoryPart,
|
||||
ModelInfo,
|
||||
} from "./types.js";
|
||||
import {
|
||||
getMemoryStatus,
|
||||
initializeMemory,
|
||||
listProjectMemoryFiles,
|
||||
readProjectMemoryFile,
|
||||
searchProjectMemory,
|
||||
syncProjectMemory,
|
||||
writeProjectMemoryFile,
|
||||
} from "./memory.js";
|
||||
import type { Settings } from "../settings-manager.js";
|
||||
import {
|
||||
createVercelStreamListener,
|
||||
|
|
@ -306,6 +297,16 @@ export class GatewayRuntime {
|
|||
return managedSession;
|
||||
}
|
||||
|
||||
private async resolveMemorySession(
|
||||
sessionKey: string | null | undefined,
|
||||
): Promise<AgentSession> {
|
||||
if (!sessionKey || sessionKey === this.primarySessionKey) {
|
||||
return this.primarySession;
|
||||
}
|
||||
const managedSession = await this.ensureSession(sessionKey);
|
||||
return managedSession.session;
|
||||
}
|
||||
|
||||
private async processNext(
|
||||
managedSession: ManagedGatewaySession,
|
||||
): Promise<void> {
|
||||
|
|
@ -634,106 +635,89 @@ export class GatewayRuntime {
|
|||
}
|
||||
|
||||
if (method === "GET" && path === "/memory/status") {
|
||||
const memory = await getMemoryStatus(
|
||||
this.primarySession.settingsManager,
|
||||
this.primarySession.sessionManager.getCwd(),
|
||||
);
|
||||
const sessionKey = url.searchParams.get("sessionKey");
|
||||
const memorySession = await this.resolveMemorySession(sessionKey);
|
||||
const memory = await memorySession.getMemoryStatus();
|
||||
this.writeJson(response, 200, { memory });
|
||||
return;
|
||||
}
|
||||
|
||||
if (method === "POST" && path === "/memory/init") {
|
||||
const body = await this.readJsonBody(request);
|
||||
const result = await initializeMemory(
|
||||
this.primarySession.settingsManager,
|
||||
this.primarySession.sessionManager.getCwd(),
|
||||
{ force: body.force === true },
|
||||
);
|
||||
this.writeJson(response, 200, result);
|
||||
return;
|
||||
}
|
||||
|
||||
if (method === "GET" && path === "/memory/files") {
|
||||
const directory = url.searchParams.get("directory") ?? undefined;
|
||||
const result = await listProjectMemoryFiles(
|
||||
this.primarySession.settingsManager,
|
||||
this.primarySession.sessionManager.getCwd(),
|
||||
directory,
|
||||
);
|
||||
this.writeJson(response, 200, result);
|
||||
return;
|
||||
}
|
||||
|
||||
if (method === "GET" && path === "/memory/file") {
|
||||
const filePath = url.searchParams.get("path");
|
||||
if (!filePath) {
|
||||
this.writeJson(response, 400, { error: "Missing memory file path" });
|
||||
return;
|
||||
}
|
||||
const result = await readProjectMemoryFile(
|
||||
this.primarySession.settingsManager,
|
||||
this.primarySession.sessionManager.getCwd(),
|
||||
filePath,
|
||||
);
|
||||
this.writeJson(response, 200, result);
|
||||
return;
|
||||
}
|
||||
|
||||
if (method === "POST" && path === "/memory/file") {
|
||||
const body = await this.readJsonBody(request);
|
||||
const filePath = typeof body.path === "string" ? body.path : "";
|
||||
const content = typeof body.content === "string" ? body.content : "";
|
||||
const description =
|
||||
typeof body.description === "string" ? body.description : "";
|
||||
const tags = Array.isArray(body.tags)
|
||||
? body.tags.filter((tag): tag is string => typeof tag === "string")
|
||||
: undefined;
|
||||
const result = await writeProjectMemoryFile(
|
||||
this.primarySession.settingsManager,
|
||||
this.primarySession.sessionManager.getCwd(),
|
||||
{
|
||||
path: filePath,
|
||||
content,
|
||||
description,
|
||||
tags,
|
||||
},
|
||||
);
|
||||
this.writeJson(response, 200, result);
|
||||
if (method === "GET" && path === "/memory/core") {
|
||||
const sessionKey = url.searchParams.get("sessionKey");
|
||||
const memorySession = await this.resolveMemorySession(sessionKey);
|
||||
const memories = await memorySession.getCoreMemories();
|
||||
this.writeJson(response, 200, { memories });
|
||||
return;
|
||||
}
|
||||
|
||||
if (method === "POST" && path === "/memory/search") {
|
||||
const body = await this.readJsonBody(request);
|
||||
const query = typeof body.query === "string" ? body.query : "";
|
||||
const searchIn =
|
||||
body.searchIn === "content" ||
|
||||
body.searchIn === "tags" ||
|
||||
body.searchIn === "description"
|
||||
? body.searchIn
|
||||
: "content";
|
||||
const result = await searchProjectMemory(
|
||||
this.primarySession.settingsManager,
|
||||
this.primarySession.sessionManager.getCwd(),
|
||||
query,
|
||||
searchIn,
|
||||
);
|
||||
const limit =
|
||||
typeof body.limit === "number" && Number.isFinite(body.limit)
|
||||
? Math.max(1, Math.floor(body.limit))
|
||||
: undefined;
|
||||
const sessionKey =
|
||||
typeof body.sessionKey === "string" ? body.sessionKey : undefined;
|
||||
const memorySession = await this.resolveMemorySession(sessionKey);
|
||||
const result = await memorySession.searchMemory(query, limit);
|
||||
this.writeJson(response, 200, result);
|
||||
return;
|
||||
}
|
||||
|
||||
if (method === "POST" && path === "/memory/sync") {
|
||||
if (method === "POST" && path === "/memory/remember") {
|
||||
const body = await this.readJsonBody(request);
|
||||
const action =
|
||||
body.action === "pull" ||
|
||||
body.action === "push" ||
|
||||
body.action === "status"
|
||||
? body.action
|
||||
: "status";
|
||||
const result = await syncProjectMemory(
|
||||
this.primarySession.settingsManager,
|
||||
this.primarySession.sessionManager.getCwd(),
|
||||
action,
|
||||
);
|
||||
const content = typeof body.content === "string" ? body.content : "";
|
||||
if (!content.trim()) {
|
||||
this.writeJson(response, 400, { error: "Missing memory content" });
|
||||
return;
|
||||
}
|
||||
const sessionKey =
|
||||
typeof body.sessionKey === "string" ? body.sessionKey : undefined;
|
||||
const memorySession = await this.resolveMemorySession(sessionKey);
|
||||
const memory = await memorySession.rememberMemory({
|
||||
bucket:
|
||||
body.bucket === "core" || body.bucket === "archival"
|
||||
? body.bucket
|
||||
: undefined,
|
||||
kind:
|
||||
body.kind === "profile" ||
|
||||
body.kind === "preference" ||
|
||||
body.kind === "relationship" ||
|
||||
body.kind === "fact" ||
|
||||
body.kind === "secret"
|
||||
? body.kind
|
||||
: undefined,
|
||||
key: typeof body.key === "string" ? body.key : undefined,
|
||||
content,
|
||||
source: "manual",
|
||||
});
|
||||
this.writeJson(response, 200, { ok: true, memory });
|
||||
return;
|
||||
}
|
||||
|
||||
if (method === "POST" && path === "/memory/forget") {
|
||||
const body = await this.readJsonBody(request);
|
||||
const sessionKey =
|
||||
typeof body.sessionKey === "string" ? body.sessionKey : undefined;
|
||||
const memorySession = await this.resolveMemorySession(sessionKey);
|
||||
const result = await memorySession.forgetMemory({
|
||||
id:
|
||||
typeof body.id === "number" && Number.isFinite(body.id)
|
||||
? Math.floor(body.id)
|
||||
: undefined,
|
||||
key: typeof body.key === "string" ? body.key : undefined,
|
||||
});
|
||||
this.writeJson(response, 200, result);
|
||||
return;
|
||||
}
|
||||
|
||||
if (method === "POST" && path === "/memory/rebuild") {
|
||||
const body = await this.readJsonBody(request);
|
||||
const sessionKey =
|
||||
typeof body.sessionKey === "string" ? body.sessionKey : undefined;
|
||||
const memorySession = await this.resolveMemorySession(sessionKey);
|
||||
const result = await memorySession.rebuildMemory();
|
||||
this.writeJson(response, 200, result);
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
1532
packages/coding-agent/src/core/memory/runtime-memory.ts
Normal file
1532
packages/coding-agent/src/core/memory/runtime-memory.ts
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -315,6 +315,7 @@ export async function createAgentSession(
|
|||
};
|
||||
|
||||
const extensionRunnerRef: { current?: ExtensionRunner } = {};
|
||||
const sessionRef: { current?: AgentSession } = {};
|
||||
|
||||
agent = new Agent({
|
||||
initialState: {
|
||||
|
|
@ -326,9 +327,15 @@ export async function createAgentSession(
|
|||
convertToLlm: convertToLlmWithBlockImages,
|
||||
sessionId: sessionManager.getSessionId(),
|
||||
transformContext: async (messages) => {
|
||||
const currentSession = sessionRef.current;
|
||||
let transformedMessages = messages;
|
||||
if (currentSession) {
|
||||
transformedMessages =
|
||||
await currentSession.transformRuntimeContext(transformedMessages);
|
||||
}
|
||||
const runner = extensionRunnerRef.current;
|
||||
if (!runner) return messages;
|
||||
return runner.emitContext(messages);
|
||||
if (!runner) return transformedMessages;
|
||||
return runner.emitContext(transformedMessages);
|
||||
},
|
||||
steeringMode: settingsManager.getSteeringMode(),
|
||||
followUpMode: settingsManager.getFollowUpMode(),
|
||||
|
|
@ -388,6 +395,7 @@ export async function createAgentSession(
|
|||
initialActiveToolNames,
|
||||
extensionRunnerRef,
|
||||
});
|
||||
sessionRef.current = session;
|
||||
const extensionsResult = resourceLoader.getExtensions();
|
||||
|
||||
return {
|
||||
|
|
|
|||
|
|
@ -63,6 +63,17 @@ export interface GatewaySettings {
|
|||
webhook?: GatewayWebhookSettings;
|
||||
}
|
||||
|
||||
export interface CompanionMemorySettings {
|
||||
enabled?: boolean;
|
||||
storageDir?: string;
|
||||
maxCoreTokens?: number;
|
||||
maxRecallResults?: number;
|
||||
writer?: {
|
||||
enabled?: boolean;
|
||||
maxTokens?: number;
|
||||
};
|
||||
}
|
||||
|
||||
export type TransportSetting = Transport;
|
||||
|
||||
/**
|
||||
|
|
@ -125,6 +136,7 @@ export interface Settings {
|
|||
showHardwareCursor?: boolean; // Show terminal cursor while still positioning it for IME
|
||||
markdown?: MarkdownSettings;
|
||||
gateway?: GatewaySettings;
|
||||
companionMemory?: CompanionMemorySettings;
|
||||
}
|
||||
|
||||
/** Deep merge settings: project/overrides take precedence, nested objects merge recursively */
|
||||
|
|
|
|||
|
|
@ -1,5 +1,4 @@
|
|||
import fs from "node:fs";
|
||||
import { createHash } from "node:crypto";
|
||||
import os from "node:os";
|
||||
import path from "node:path";
|
||||
import type {
|
||||
|
|
@ -62,7 +61,7 @@ export type ParsedFrontmatter = GrayMatterFile<string>["data"];
|
|||
const DEFAULT_LOCAL_PATH = path.join(os.homedir(), ".pi", "memory-md");
|
||||
|
||||
export function getCurrentDate(): string {
|
||||
return new Date().toISOString().split("T")[0] ?? "";
|
||||
return new Date().toISOString().split("T")[0];
|
||||
}
|
||||
|
||||
function expandPath(p: string): string {
|
||||
|
|
@ -72,73 +71,12 @@ function expandPath(p: string): string {
|
|||
return p;
|
||||
}
|
||||
|
||||
function getLegacyProjectDirName(cwd: string): string {
|
||||
return path.basename(cwd);
|
||||
}
|
||||
|
||||
function getProjectDirName(cwd: string): string {
|
||||
const projectName = getLegacyProjectDirName(cwd);
|
||||
const hash = createHash("sha256")
|
||||
.update(path.resolve(cwd))
|
||||
.digest("hex")
|
||||
.slice(0, 12);
|
||||
return `${projectName}-${hash}`;
|
||||
}
|
||||
|
||||
function migrateLegacyMemoryDir(
|
||||
preferredDir: string,
|
||||
legacyDir: string,
|
||||
): string {
|
||||
try {
|
||||
fs.renameSync(legacyDir, preferredDir);
|
||||
return preferredDir;
|
||||
} catch (error) {
|
||||
console.warn("Failed to migrate legacy memory dir:", error);
|
||||
return legacyDir;
|
||||
}
|
||||
}
|
||||
|
||||
export function getMemoryDir(
|
||||
settings: MemoryMdSettings,
|
||||
ctx: ExtensionContext,
|
||||
): string {
|
||||
const basePath = settings.localPath || DEFAULT_LOCAL_PATH;
|
||||
const preferredDir = path.join(basePath, getProjectDirName(ctx.cwd));
|
||||
if (fs.existsSync(preferredDir)) {
|
||||
return preferredDir;
|
||||
}
|
||||
|
||||
const legacyDir = path.join(basePath, getLegacyProjectDirName(ctx.cwd));
|
||||
if (fs.existsSync(legacyDir)) {
|
||||
return migrateLegacyMemoryDir(preferredDir, legacyDir);
|
||||
}
|
||||
|
||||
return preferredDir;
|
||||
}
|
||||
|
||||
export function getProjectRepoPath(
|
||||
settings: MemoryMdSettings,
|
||||
ctx: ExtensionContext,
|
||||
): string {
|
||||
const basePath = settings.localPath || DEFAULT_LOCAL_PATH;
|
||||
return path.relative(basePath, getMemoryDir(settings, ctx)).split(path.sep).join("/");
|
||||
}
|
||||
|
||||
export function resolveMemoryPath(
|
||||
settings: MemoryMdSettings,
|
||||
ctx: ExtensionContext,
|
||||
relativePath: string,
|
||||
): string {
|
||||
const memoryDir = getMemoryDir(settings, ctx);
|
||||
const resolvedPath = path.resolve(memoryDir, relativePath.trim());
|
||||
const resolvedRoot = path.resolve(memoryDir);
|
||||
if (
|
||||
resolvedPath !== resolvedRoot &&
|
||||
!resolvedPath.startsWith(`${resolvedRoot}${path.sep}`)
|
||||
) {
|
||||
throw new Error(`Memory path escapes root: ${relativePath}`);
|
||||
}
|
||||
return resolvedPath;
|
||||
return path.join(basePath, path.basename(ctx.cwd));
|
||||
}
|
||||
|
||||
function getRepoName(settings: MemoryMdSettings): string {
|
||||
|
|
@ -147,38 +85,7 @@ function getRepoName(settings: MemoryMdSettings): string {
|
|||
return match ? match[1] : "memory-md";
|
||||
}
|
||||
|
||||
async function getGitHead(
|
||||
pi: ExtensionAPI,
|
||||
cwd: string,
|
||||
): Promise<string | null> {
|
||||
const result = await gitExec(pi, cwd, "rev-parse", "HEAD");
|
||||
if (!result.success) {
|
||||
return null;
|
||||
}
|
||||
const head = result.stdout.trim();
|
||||
return head.length > 0 ? head : null;
|
||||
}
|
||||
|
||||
function loadScopedSettings(settingsPath: string): MemoryMdSettings {
|
||||
if (!fs.existsSync(settingsPath)) {
|
||||
return {};
|
||||
}
|
||||
|
||||
try {
|
||||
const content = fs.readFileSync(settingsPath, "utf-8");
|
||||
const parsed = JSON.parse(content);
|
||||
const scoped = parsed["pi-memory-md"];
|
||||
if (!scoped || typeof scoped !== "object" || Array.isArray(scoped)) {
|
||||
return {};
|
||||
}
|
||||
return scoped as MemoryMdSettings;
|
||||
} catch (error) {
|
||||
console.warn("Failed to load memory settings:", error);
|
||||
return {};
|
||||
}
|
||||
}
|
||||
|
||||
function loadSettings(cwd?: string): MemoryMdSettings {
|
||||
function loadSettings(): MemoryMdSettings {
|
||||
const DEFAULT_SETTINGS: MemoryMdSettings = {
|
||||
enabled: true,
|
||||
repoUrl: "",
|
||||
|
|
@ -197,27 +104,16 @@ function loadSettings(cwd?: string): MemoryMdSettings {
|
|||
"agent",
|
||||
"settings.json",
|
||||
);
|
||||
const projectSettings = cwd
|
||||
? path.join(cwd, ".pi", "settings.json")
|
||||
: undefined;
|
||||
const globalLoaded = loadScopedSettings(globalSettings);
|
||||
const projectLoaded = projectSettings
|
||||
? loadScopedSettings(projectSettings)
|
||||
: {};
|
||||
if (!fs.existsSync(globalSettings)) {
|
||||
return DEFAULT_SETTINGS;
|
||||
}
|
||||
|
||||
try {
|
||||
const content = fs.readFileSync(globalSettings, "utf-8");
|
||||
const parsed = JSON.parse(content);
|
||||
const loadedSettings = {
|
||||
...DEFAULT_SETTINGS,
|
||||
...globalLoaded,
|
||||
...projectLoaded,
|
||||
autoSync: {
|
||||
...DEFAULT_SETTINGS.autoSync,
|
||||
...globalLoaded.autoSync,
|
||||
...projectLoaded.autoSync,
|
||||
},
|
||||
systemPrompt: {
|
||||
...DEFAULT_SETTINGS.systemPrompt,
|
||||
...globalLoaded.systemPrompt,
|
||||
...projectLoaded.systemPrompt,
|
||||
},
|
||||
...(parsed["pi-memory-md"] as MemoryMdSettings),
|
||||
};
|
||||
|
||||
if (loadedSettings.localPath) {
|
||||
|
|
@ -225,6 +121,10 @@ function loadSettings(cwd?: string): MemoryMdSettings {
|
|||
}
|
||||
|
||||
return loadedSettings;
|
||||
} catch (error) {
|
||||
console.warn("Failed to load memory settings:", error);
|
||||
return DEFAULT_SETTINGS;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -265,40 +165,12 @@ export async function syncRepository(
|
|||
if (fs.existsSync(localPath)) {
|
||||
const gitDir = path.join(localPath, ".git");
|
||||
if (!fs.existsSync(gitDir)) {
|
||||
let existingEntries: string[];
|
||||
try {
|
||||
existingEntries = fs.readdirSync(localPath);
|
||||
} catch {
|
||||
return {
|
||||
success: false,
|
||||
message: `Path exists but is not a directory: ${localPath}`,
|
||||
};
|
||||
}
|
||||
|
||||
if (existingEntries.length === 0) {
|
||||
const cloneIntoEmptyDir = await gitExec(pi, localPath, "clone", repoUrl, ".");
|
||||
if (cloneIntoEmptyDir.success) {
|
||||
isRepoInitialized.value = true;
|
||||
const repoName = getRepoName(settings);
|
||||
return {
|
||||
success: true,
|
||||
message: `Cloned [${repoName}] successfully`,
|
||||
updated: true,
|
||||
};
|
||||
}
|
||||
return {
|
||||
success: false,
|
||||
message: "Clone failed - check repo URL and auth",
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
success: false,
|
||||
message: `Directory exists but is not a git repo: ${localPath}`,
|
||||
};
|
||||
}
|
||||
|
||||
const previousHead = await getGitHead(pi, localPath);
|
||||
const pullResult = await gitExec(
|
||||
pi,
|
||||
localPath,
|
||||
|
|
@ -314,21 +186,15 @@ export async function syncRepository(
|
|||
}
|
||||
|
||||
isRepoInitialized.value = true;
|
||||
const currentHead = await getGitHead(pi, localPath);
|
||||
const updated =
|
||||
previousHead !== null &&
|
||||
currentHead !== null &&
|
||||
previousHead !== currentHead;
|
||||
pullResult.stdout.includes("Updating") ||
|
||||
pullResult.stdout.includes("Fast-forward");
|
||||
const repoName = getRepoName(settings);
|
||||
const message =
|
||||
previousHead === null || currentHead === null
|
||||
? `Synchronized [${repoName}]`
|
||||
: updated
|
||||
? `Pulled latest changes from [${repoName}]`
|
||||
: `[${repoName}] is already latest`;
|
||||
return {
|
||||
success: true,
|
||||
message,
|
||||
message: updated
|
||||
? `Pulled latest changes from [${repoName}]`
|
||||
: `[${repoName}] is already latest`,
|
||||
updated,
|
||||
};
|
||||
}
|
||||
|
|
@ -456,7 +322,7 @@ export function writeMemoryFile(
|
|||
* Build memory context for agent prompt.
|
||||
*/
|
||||
|
||||
export function ensureDirectoryStructure(memoryDir: string): void {
|
||||
function ensureDirectoryStructure(memoryDir: string): void {
|
||||
const dirs = [
|
||||
path.join(memoryDir, "core", "user"),
|
||||
path.join(memoryDir, "core", "project"),
|
||||
|
|
@ -468,7 +334,7 @@ export function ensureDirectoryStructure(memoryDir: string): void {
|
|||
}
|
||||
}
|
||||
|
||||
export function createDefaultFiles(memoryDir: string): void {
|
||||
function createDefaultFiles(memoryDir: string): void {
|
||||
const identityFile = path.join(memoryDir, "core", "user", "identity.md");
|
||||
if (!fs.existsSync(identityFile)) {
|
||||
writeMemoryFile(
|
||||
|
|
@ -496,68 +362,6 @@ export function createDefaultFiles(memoryDir: string): void {
|
|||
}
|
||||
}
|
||||
|
||||
export function formatMemoryDirectoryTree(
|
||||
memoryDir: string,
|
||||
maxDepth = 3,
|
||||
maxLines = 40,
|
||||
): string {
|
||||
if (!fs.existsSync(memoryDir)) {
|
||||
return "Unable to generate directory tree.";
|
||||
}
|
||||
|
||||
const lines = [`${path.basename(memoryDir) || memoryDir}/`];
|
||||
let truncated = false;
|
||||
|
||||
function visit(dir: string, depth: number, prefix: string): void {
|
||||
if (depth >= maxDepth || lines.length >= maxLines) {
|
||||
truncated = true;
|
||||
return;
|
||||
}
|
||||
|
||||
let entries: fs.Dirent[];
|
||||
try {
|
||||
entries = fs
|
||||
.readdirSync(dir, { withFileTypes: true })
|
||||
.filter((entry) => entry.name !== "node_modules")
|
||||
.sort((left, right) => {
|
||||
if (left.isDirectory() !== right.isDirectory()) {
|
||||
return left.isDirectory() ? -1 : 1;
|
||||
}
|
||||
return left.name.localeCompare(right.name);
|
||||
});
|
||||
} catch {
|
||||
truncated = true;
|
||||
return;
|
||||
}
|
||||
|
||||
for (const [index, entry] of entries.entries()) {
|
||||
if (lines.length >= maxLines) {
|
||||
truncated = true;
|
||||
return;
|
||||
}
|
||||
|
||||
const isLast = index === entries.length - 1;
|
||||
const marker = isLast ? "\\-- " : "|-- ";
|
||||
const childPrefix = `${prefix}${isLast ? " " : "| "}`;
|
||||
lines.push(
|
||||
`${prefix}${marker}${entry.name}${entry.isDirectory() ? "/" : ""}`,
|
||||
);
|
||||
|
||||
if (entry.isDirectory()) {
|
||||
visit(path.join(dir, entry.name), depth + 1, childPrefix);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
visit(memoryDir, 0, "");
|
||||
|
||||
if (truncated) {
|
||||
lines.push("... (tree truncated)");
|
||||
}
|
||||
|
||||
return lines.join("\n");
|
||||
}
|
||||
|
||||
function buildMemoryContext(
|
||||
settings: MemoryMdSettings,
|
||||
ctx: ExtensionContext,
|
||||
|
|
@ -630,7 +434,7 @@ export default function memoryMdExtension(pi: ExtensionAPI) {
|
|||
let memoryInjected = false;
|
||||
|
||||
pi.on("session_start", async (_event, ctx) => {
|
||||
settings = loadSettings(ctx.cwd);
|
||||
settings = loadSettings();
|
||||
|
||||
if (!settings.enabled) {
|
||||
return;
|
||||
|
|
@ -647,11 +451,7 @@ export default function memoryMdExtension(pi: ExtensionAPI) {
|
|||
return;
|
||||
}
|
||||
|
||||
if (
|
||||
settings.autoSync?.onSessionStart &&
|
||||
settings.localPath &&
|
||||
settings.repoUrl
|
||||
) {
|
||||
if (settings.autoSync?.onSessionStart && settings.localPath) {
|
||||
syncPromise = syncRepository(pi, settings, repoInitialized).then(
|
||||
(syncResult) => {
|
||||
if (settings.repoUrl) {
|
||||
|
|
@ -709,20 +509,14 @@ export default function memoryMdExtension(pi: ExtensionAPI) {
|
|||
return undefined;
|
||||
});
|
||||
|
||||
registerAllTools(pi, () => settings, repoInitialized);
|
||||
registerAllTools(pi, settings, repoInitialized);
|
||||
|
||||
pi.registerCommand("memory-status", {
|
||||
description: "Show memory repository status",
|
||||
handler: async (_args, ctx) => {
|
||||
settings = loadSettings(ctx.cwd);
|
||||
const projectName = path.basename(ctx.cwd);
|
||||
const memoryDir = getMemoryDir(settings, ctx);
|
||||
const projectRepoPath = getProjectRepoPath(settings, ctx);
|
||||
const coreUserDir = path.join(memoryDir, "core", "user");
|
||||
const repoConfigured = Boolean(settings.repoUrl);
|
||||
const repoReady = Boolean(
|
||||
settings.localPath && fs.existsSync(path.join(settings.localPath, ".git")),
|
||||
);
|
||||
|
||||
if (!fs.existsSync(coreUserDir)) {
|
||||
ctx.ui.notify(
|
||||
|
|
@ -732,37 +526,12 @@ export default function memoryMdExtension(pi: ExtensionAPI) {
|
|||
return;
|
||||
}
|
||||
|
||||
if (!repoConfigured) {
|
||||
ctx.ui.notify(
|
||||
`Memory: ${projectName} | Local only | Path: ${memoryDir}`,
|
||||
"info",
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!repoReady || !settings.localPath) {
|
||||
ctx.ui.notify(
|
||||
`Memory: ${projectName} | Repo not initialized | Path: ${memoryDir}`,
|
||||
"warning",
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
||||
const result = await gitExec(
|
||||
pi,
|
||||
settings.localPath,
|
||||
settings.localPath!,
|
||||
"status",
|
||||
"--porcelain",
|
||||
"--",
|
||||
projectRepoPath,
|
||||
);
|
||||
if (!result.success) {
|
||||
ctx.ui.notify(
|
||||
`Memory: ${projectName} | Repo status unavailable | Path: ${memoryDir}`,
|
||||
"warning",
|
||||
);
|
||||
return;
|
||||
}
|
||||
const isDirty = result.stdout.trim().length > 0;
|
||||
|
||||
ctx.ui.notify(
|
||||
|
|
@ -775,36 +544,26 @@ export default function memoryMdExtension(pi: ExtensionAPI) {
|
|||
pi.registerCommand("memory-init", {
|
||||
description: "Initialize memory repository",
|
||||
handler: async (_args, ctx) => {
|
||||
settings = loadSettings(ctx.cwd);
|
||||
const memoryDir = getMemoryDir(settings, ctx);
|
||||
const alreadyInitialized = fs.existsSync(
|
||||
path.join(memoryDir, "core", "user"),
|
||||
);
|
||||
|
||||
if (settings.repoUrl) {
|
||||
const result = await syncRepository(pi, settings, repoInitialized);
|
||||
|
||||
if (!result.success) {
|
||||
ctx.ui.notify(`Initialization failed: ${result.message}`, "error");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
ensureDirectoryStructure(memoryDir);
|
||||
createDefaultFiles(memoryDir);
|
||||
repoInitialized.value = true;
|
||||
|
||||
if (alreadyInitialized) {
|
||||
ctx.ui.notify(
|
||||
settings.repoUrl
|
||||
? "Memory already exists and repository is ready"
|
||||
: "Local memory already exists",
|
||||
"info",
|
||||
);
|
||||
ctx.ui.notify(`Memory already exists: ${result.message}`, "info");
|
||||
} else {
|
||||
ctx.ui.notify(
|
||||
settings.repoUrl
|
||||
? "Memory initialized and repository is ready\n\nCreated:\n - core/user\n - core/project\n - reference"
|
||||
: "Local memory initialized\n\nCreated:\n - core/user\n - core/project\n - reference",
|
||||
`Memory initialized: ${result.message}\n\nCreated:\n - core/user\n - core/project\n - reference`,
|
||||
"info",
|
||||
);
|
||||
}
|
||||
|
|
@ -814,7 +573,6 @@ export default function memoryMdExtension(pi: ExtensionAPI) {
|
|||
pi.registerCommand("memory-refresh", {
|
||||
description: "Refresh memory context from files",
|
||||
handler: async (_args, ctx) => {
|
||||
settings = loadSettings(ctx.cwd);
|
||||
const memoryContext = buildMemoryContext(settings, ctx);
|
||||
|
||||
if (!memoryContext) {
|
||||
|
|
@ -852,7 +610,6 @@ export default function memoryMdExtension(pi: ExtensionAPI) {
|
|||
pi.registerCommand("memory-check", {
|
||||
description: "Check memory folder structure",
|
||||
handler: async (_args, ctx) => {
|
||||
settings = loadSettings(ctx.cwd);
|
||||
const memoryDir = getMemoryDir(settings, ctx);
|
||||
|
||||
if (!fs.existsSync(memoryDir)) {
|
||||
|
|
@ -860,7 +617,25 @@ export default function memoryMdExtension(pi: ExtensionAPI) {
|
|||
return;
|
||||
}
|
||||
|
||||
ctx.ui.notify(formatMemoryDirectoryTree(memoryDir).trim(), "info");
|
||||
const { execSync } = await import("node:child_process");
|
||||
let treeOutput = "";
|
||||
|
||||
try {
|
||||
treeOutput = execSync(`tree -L 3 -I "node_modules" "${memoryDir}"`, {
|
||||
encoding: "utf-8",
|
||||
});
|
||||
} catch {
|
||||
try {
|
||||
treeOutput = execSync(
|
||||
`find "${memoryDir}" -type d -not -path "*/node_modules/*"`,
|
||||
{ encoding: "utf-8" },
|
||||
);
|
||||
} catch {
|
||||
treeOutput = "Unable to generate directory tree.";
|
||||
}
|
||||
}
|
||||
|
||||
ctx.ui.notify(treeOutput.trim(), "info");
|
||||
},
|
||||
});
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,22 +6,15 @@ import { Text } from "@mariozechner/pi-tui";
|
|||
import { Type } from "@sinclair/typebox";
|
||||
import type { MemoryFrontmatter, MemoryMdSettings } from "./memory-md.js";
|
||||
import {
|
||||
createDefaultFiles,
|
||||
ensureDirectoryStructure,
|
||||
formatMemoryDirectoryTree,
|
||||
getCurrentDate,
|
||||
getMemoryDir,
|
||||
getProjectRepoPath,
|
||||
gitExec,
|
||||
listMemoryFiles,
|
||||
readMemoryFile,
|
||||
resolveMemoryPath,
|
||||
syncRepository,
|
||||
writeMemoryFile,
|
||||
} from "./memory-md.js";
|
||||
|
||||
type MemorySettingsGetter = () => MemoryMdSettings;
|
||||
|
||||
function renderWithExpandHint(
|
||||
text: string,
|
||||
theme: Theme,
|
||||
|
|
@ -41,7 +34,7 @@ function renderWithExpandHint(
|
|||
|
||||
export function registerMemorySync(
|
||||
pi: ExtensionAPI,
|
||||
getSettings: MemorySettingsGetter,
|
||||
settings: MemoryMdSettings,
|
||||
isRepoInitialized: { value: boolean },
|
||||
): void {
|
||||
pi.registerTool({
|
||||
|
|
@ -59,73 +52,26 @@ export function registerMemorySync(
|
|||
|
||||
async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
|
||||
const { action } = params as { action: "pull" | "push" | "status" };
|
||||
const settings = getSettings();
|
||||
const localPath = settings.localPath;
|
||||
const localPath = settings.localPath!;
|
||||
const memoryDir = getMemoryDir(settings, ctx);
|
||||
const projectRepoPath = getProjectRepoPath(settings, ctx);
|
||||
const coreUserDir = path.join(memoryDir, "core", "user");
|
||||
const configured = Boolean(settings.repoUrl);
|
||||
const initialized = fs.existsSync(coreUserDir);
|
||||
const repoReady = Boolean(
|
||||
localPath && fs.existsSync(path.join(localPath, ".git")),
|
||||
);
|
||||
|
||||
if (action === "status") {
|
||||
const initialized =
|
||||
isRepoInitialized.value && fs.existsSync(coreUserDir);
|
||||
if (!initialized) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: "Memory not initialized. Use memory_init to set up.",
|
||||
text: "Memory repository not initialized. Use memory_init to set up.",
|
||||
},
|
||||
],
|
||||
details: { initialized: false, configured, dirty: null },
|
||||
details: { initialized: false },
|
||||
};
|
||||
}
|
||||
|
||||
if (!configured) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: "Memory repository is not configured. Local memory is available only on this machine.",
|
||||
},
|
||||
],
|
||||
details: { initialized: true, configured: false, dirty: null },
|
||||
};
|
||||
}
|
||||
|
||||
if (!repoReady || !localPath) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: "Memory repository is configured but not initialized locally.",
|
||||
},
|
||||
],
|
||||
details: { initialized: true, configured: true, dirty: null },
|
||||
};
|
||||
}
|
||||
|
||||
const result = await gitExec(
|
||||
pi,
|
||||
localPath,
|
||||
"status",
|
||||
"--porcelain",
|
||||
"--",
|
||||
projectRepoPath,
|
||||
);
|
||||
if (!result.success) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: "Unable to inspect memory repository status.",
|
||||
},
|
||||
],
|
||||
details: { initialized: true, configured: true, dirty: null },
|
||||
};
|
||||
}
|
||||
const result = await gitExec(pi, localPath, "status", "--porcelain");
|
||||
const dirty = result.stdout.trim().length > 0;
|
||||
|
||||
return {
|
||||
|
|
@ -142,95 +88,36 @@ export function registerMemorySync(
|
|||
}
|
||||
|
||||
if (action === "pull") {
|
||||
if (!configured) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: "Memory repository is not configured. Nothing to pull.",
|
||||
},
|
||||
],
|
||||
details: { success: false, configured: false },
|
||||
};
|
||||
}
|
||||
const result = await syncRepository(pi, settings, isRepoInitialized);
|
||||
return {
|
||||
content: [{ type: "text", text: result.message }],
|
||||
details: { success: result.success, configured: true },
|
||||
details: { success: result.success },
|
||||
};
|
||||
}
|
||||
|
||||
if (action === "push") {
|
||||
if (!configured || !localPath) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: "Memory repository is not configured. Nothing to push.",
|
||||
},
|
||||
],
|
||||
details: { success: false, configured: false },
|
||||
};
|
||||
}
|
||||
|
||||
if (!repoReady) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: "Memory repository is configured but not initialized locally.",
|
||||
},
|
||||
],
|
||||
details: { success: false, configured: true },
|
||||
};
|
||||
}
|
||||
|
||||
const syncResult = await syncRepository(pi, settings, isRepoInitialized);
|
||||
if (!syncResult.success) {
|
||||
return {
|
||||
content: [{ type: "text", text: syncResult.message }],
|
||||
details: { success: false, configured: true },
|
||||
};
|
||||
}
|
||||
|
||||
const statusResult = await gitExec(
|
||||
pi,
|
||||
localPath,
|
||||
"status",
|
||||
"--porcelain",
|
||||
"--",
|
||||
projectRepoPath,
|
||||
);
|
||||
if (!statusResult.success) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: "Unable to inspect memory repository before push.",
|
||||
},
|
||||
],
|
||||
details: { success: false, configured: true },
|
||||
};
|
||||
}
|
||||
const hasChanges = statusResult.stdout.trim().length > 0;
|
||||
|
||||
if (hasChanges) {
|
||||
await gitExec(pi, localPath, "add", "-A", "--", projectRepoPath);
|
||||
await gitExec(pi, localPath, "add", ".");
|
||||
|
||||
const timestamp = new Date()
|
||||
.toISOString()
|
||||
.replace(/[:.]/g, "-")
|
||||
.slice(0, 19);
|
||||
const commitMessage = `Update memory for ${path.basename(ctx.cwd)} - ${timestamp}`;
|
||||
const commitMessage = `Update memory - ${timestamp}`;
|
||||
const commitResult = await gitExec(
|
||||
pi,
|
||||
localPath,
|
||||
"commit",
|
||||
"-m",
|
||||
commitMessage,
|
||||
"--only",
|
||||
"--",
|
||||
projectRepoPath,
|
||||
);
|
||||
|
||||
if (!commitResult.success) {
|
||||
|
|
@ -302,7 +189,7 @@ export function registerMemorySync(
|
|||
|
||||
export function registerMemoryRead(
|
||||
pi: ExtensionAPI,
|
||||
getSettings: MemorySettingsGetter,
|
||||
settings: MemoryMdSettings,
|
||||
): void {
|
||||
pi.registerTool({
|
||||
name: "memory_read",
|
||||
|
|
@ -317,8 +204,8 @@ export function registerMemoryRead(
|
|||
|
||||
async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
|
||||
const { path: relPath } = params as { path: string };
|
||||
const settings = getSettings();
|
||||
const fullPath = resolveMemoryPath(settings, ctx, relPath);
|
||||
const memoryDir = getMemoryDir(settings, ctx);
|
||||
const fullPath = path.join(memoryDir, relPath);
|
||||
|
||||
const memory = readMemoryFile(fullPath);
|
||||
if (!memory) {
|
||||
|
|
@ -384,7 +271,7 @@ export function registerMemoryRead(
|
|||
|
||||
export function registerMemoryWrite(
|
||||
pi: ExtensionAPI,
|
||||
getSettings: MemorySettingsGetter,
|
||||
settings: MemoryMdSettings,
|
||||
): void {
|
||||
pi.registerTool({
|
||||
name: "memory_write",
|
||||
|
|
@ -413,24 +300,17 @@ export function registerMemoryWrite(
|
|||
tags?: string[];
|
||||
};
|
||||
|
||||
const settings = getSettings();
|
||||
const fullPath = resolveMemoryPath(settings, ctx, relPath);
|
||||
const memoryDir = getMemoryDir(settings, ctx);
|
||||
const fullPath = path.join(memoryDir, relPath);
|
||||
|
||||
const existing = readMemoryFile(fullPath);
|
||||
const existingFrontmatter = existing?.frontmatter;
|
||||
const existingFrontmatter = existing?.frontmatter || { description };
|
||||
|
||||
const frontmatter: MemoryFrontmatter = {
|
||||
...existingFrontmatter,
|
||||
description,
|
||||
created: existingFrontmatter?.created ?? getCurrentDate(),
|
||||
updated: getCurrentDate(),
|
||||
...(existingFrontmatter?.limit !== undefined
|
||||
? { limit: existingFrontmatter.limit }
|
||||
: {}),
|
||||
...(tags !== undefined
|
||||
? { tags }
|
||||
: existingFrontmatter?.tags
|
||||
? { tags: existingFrontmatter.tags }
|
||||
: {}),
|
||||
...(tags && { tags }),
|
||||
};
|
||||
|
||||
writeMemoryFile(fullPath, content, frontmatter);
|
||||
|
|
@ -487,7 +367,7 @@ export function registerMemoryWrite(
|
|||
|
||||
export function registerMemoryList(
|
||||
pi: ExtensionAPI,
|
||||
getSettings: MemorySettingsGetter,
|
||||
settings: MemoryMdSettings,
|
||||
): void {
|
||||
pi.registerTool({
|
||||
name: "memory_list",
|
||||
|
|
@ -501,11 +381,8 @@ export function registerMemoryList(
|
|||
|
||||
async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
|
||||
const { directory } = params as { directory?: string };
|
||||
const settings = getSettings();
|
||||
const memoryDir = getMemoryDir(settings, ctx);
|
||||
const searchDir = directory
|
||||
? resolveMemoryPath(settings, ctx, directory)
|
||||
: memoryDir;
|
||||
const searchDir = directory ? path.join(memoryDir, directory) : memoryDir;
|
||||
const files = listMemoryFiles(searchDir);
|
||||
const relPaths = files.map((f) => path.relative(memoryDir, f));
|
||||
|
||||
|
|
@ -555,7 +432,7 @@ export function registerMemoryList(
|
|||
|
||||
export function registerMemorySearch(
|
||||
pi: ExtensionAPI,
|
||||
getSettings: MemorySettingsGetter,
|
||||
settings: MemoryMdSettings,
|
||||
): void {
|
||||
pi.registerTool({
|
||||
name: "memory_search",
|
||||
|
|
@ -580,7 +457,6 @@ export function registerMemorySearch(
|
|||
query: string;
|
||||
searchIn: "content" | "tags" | "description";
|
||||
};
|
||||
const settings = getSettings();
|
||||
const memoryDir = getMemoryDir(settings, ctx);
|
||||
const files = listMemoryFiles(memoryDir);
|
||||
const results: Array<{ path: string; match: string }> = [];
|
||||
|
|
@ -668,7 +544,7 @@ export function registerMemorySearch(
|
|||
|
||||
export function registerMemoryInit(
|
||||
pi: ExtensionAPI,
|
||||
getSettings: MemorySettingsGetter,
|
||||
settings: MemoryMdSettings,
|
||||
isRepoInitialized: { value: boolean },
|
||||
): void {
|
||||
pi.registerTool({
|
||||
|
|
@ -682,19 +558,10 @@ export function registerMemoryInit(
|
|||
),
|
||||
}) as any,
|
||||
|
||||
async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
|
||||
async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
|
||||
const { force = false } = params as { force?: boolean };
|
||||
const settings = getSettings();
|
||||
const memoryDir = getMemoryDir(settings, ctx);
|
||||
const alreadyInitialized = fs.existsSync(
|
||||
path.join(memoryDir, "core", "user"),
|
||||
);
|
||||
const repoReady = Boolean(
|
||||
settings.localPath &&
|
||||
fs.existsSync(path.join(settings.localPath, ".git")),
|
||||
);
|
||||
|
||||
if (alreadyInitialized && (!settings.repoUrl || repoReady) && !force) {
|
||||
if (isRepoInitialized.value && !force) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
|
|
@ -706,35 +573,18 @@ export function registerMemoryInit(
|
|||
};
|
||||
}
|
||||
|
||||
if (settings.repoUrl) {
|
||||
const result = await syncRepository(pi, settings, isRepoInitialized);
|
||||
if (!result.success) {
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: `Initialization failed: ${result.message}`,
|
||||
},
|
||||
],
|
||||
details: { success: false },
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
ensureDirectoryStructure(memoryDir);
|
||||
createDefaultFiles(memoryDir);
|
||||
isRepoInitialized.value = true;
|
||||
|
||||
return {
|
||||
content: [
|
||||
{
|
||||
type: "text",
|
||||
text: settings.repoUrl
|
||||
? `Memory repository initialized.\n\nCreated directory structure:\n${["core/user", "core/project", "reference"].map((d) => ` - ${d}`).join("\n")}`
|
||||
: `Local memory initialized.\n\nCreated directory structure:\n${["core/user", "core/project", "reference"].map((d) => ` - ${d}`).join("\n")}`,
|
||||
text: result.success
|
||||
? `Memory repository initialized:\n${result.message}\n\nCreated directory structure:\n${["core/user", "core/project", "reference"].map((d) => ` - ${d}`).join("\n")}`
|
||||
: `Initialization failed: ${result.message}`,
|
||||
},
|
||||
],
|
||||
details: { success: true },
|
||||
details: { success: result.success },
|
||||
};
|
||||
},
|
||||
|
||||
|
|
@ -778,7 +628,7 @@ export function registerMemoryInit(
|
|||
|
||||
export function registerMemoryCheck(
|
||||
pi: ExtensionAPI,
|
||||
getSettings: MemorySettingsGetter,
|
||||
settings: MemoryMdSettings,
|
||||
): void {
|
||||
pi.registerTool({
|
||||
name: "memory_check",
|
||||
|
|
@ -787,7 +637,6 @@ export function registerMemoryCheck(
|
|||
parameters: Type.Object({}) as any,
|
||||
|
||||
async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
|
||||
const settings = getSettings();
|
||||
const memoryDir = getMemoryDir(settings, ctx);
|
||||
|
||||
if (!fs.existsSync(memoryDir)) {
|
||||
|
|
@ -802,7 +651,26 @@ export function registerMemoryCheck(
|
|||
};
|
||||
}
|
||||
|
||||
const treeOutput = formatMemoryDirectoryTree(memoryDir);
|
||||
const { execSync } = await import("node:child_process");
|
||||
let treeOutput = "";
|
||||
|
||||
try {
|
||||
treeOutput = execSync(`tree -L 3 -I "node_modules" "${memoryDir}"`, {
|
||||
encoding: "utf-8",
|
||||
});
|
||||
} catch {
|
||||
try {
|
||||
treeOutput = execSync(
|
||||
`find "${memoryDir}" -type d -not -path "*/node_modules/*" | head -20`,
|
||||
{
|
||||
encoding: "utf-8",
|
||||
},
|
||||
);
|
||||
} catch {
|
||||
treeOutput =
|
||||
"Unable to generate directory tree. Please check permissions.";
|
||||
}
|
||||
}
|
||||
|
||||
const files = listMemoryFiles(memoryDir);
|
||||
const relPaths = files.map((f) => path.relative(memoryDir, f));
|
||||
|
|
@ -851,14 +719,14 @@ export function registerMemoryCheck(
|
|||
|
||||
export function registerAllTools(
|
||||
pi: ExtensionAPI,
|
||||
getSettings: MemorySettingsGetter,
|
||||
settings: MemoryMdSettings,
|
||||
isRepoInitialized: { value: boolean },
|
||||
): void {
|
||||
registerMemorySync(pi, getSettings, isRepoInitialized);
|
||||
registerMemoryRead(pi, getSettings);
|
||||
registerMemoryWrite(pi, getSettings);
|
||||
registerMemoryList(pi, getSettings);
|
||||
registerMemorySearch(pi, getSettings);
|
||||
registerMemoryInit(pi, getSettings, isRepoInitialized);
|
||||
registerMemoryCheck(pi, getSettings);
|
||||
registerMemorySync(pi, settings, isRepoInitialized);
|
||||
registerMemoryRead(pi, settings);
|
||||
registerMemoryWrite(pi, settings);
|
||||
registerMemoryList(pi, settings);
|
||||
registerMemorySearch(pi, settings);
|
||||
registerMemoryInit(pi, settings, isRepoInitialized);
|
||||
registerMemoryCheck(pi, settings);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,7 +23,6 @@ SERVICE_STDERR_LOG=""
|
|||
|
||||
DEFAULT_PACKAGES=(
|
||||
"npm:@e9n/pi-channels"
|
||||
"npm:pi-memory-md"
|
||||
"npm:pi-teams"
|
||||
)
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue