@lebronj/pi-suite 0.1.4 → 0.1.5

package/vendor/pi-memory/src/evolution/git.ts

@@ -0,0 +1,132 @@
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { EvolutionConfig } from "./config.ts";
+import { pathExists } from "./file-utils.ts";
+
+export interface GitStatus {
+	repoDir: string;
+	initialized: boolean;
+	branch: string | null;
+	remote: string | null;
+	dirty: boolean;
+	status: string;
+	lastCommit: string | null;
+	autoPush: boolean;
+	autoCommit: boolean;
+	enabled: boolean;
+}
+
+export interface GitCommitResult {
+	committed: boolean;
+	commit?: string;
+	message?: string;
+	status: string;
+}
+
+function runGit(repoDir: string, args: string[], options: { allowFailure?: boolean } = {}): string {
+	try {
+		return execFileSync("git", args, { cwd: repoDir, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+	} catch (error) {
+		if (options.allowFailure) return "";
+		throw error;
+	}
+}
+
+function isGitRepo(repoDir: string): boolean {
+	return pathExists(path.join(repoDir, ".git"));
+}
+
+function isEmptyDir(repoDir: string): boolean {
+	if (!pathExists(repoDir)) return true;
+	return fs.readdirSync(repoDir).length === 0;
+}
+
+function ensureGitIdentity(repoDir: string): void {
+	const name = runGit(repoDir, ["config", "user.name"], { allowFailure: true });
+	const email = runGit(repoDir, ["config", "user.email"], { allowFailure: true });
+	if (!name) runGit(repoDir, ["config", "user.name", "pi-memory"]);
+	if (!email) runGit(repoDir, ["config", "user.email", "pi-memory@local"]);
+}
+
+export function ensureEvolutionRepo(config: EvolutionConfig): void {
+	if (!config.enabled) return;
+	if (pathExists(config.repoDir) && !isGitRepo(config.repoDir) && !isEmptyDir(config.repoDir)) {
+		throw new Error(`Evolution directory exists but is not a git repo: ${config.repoDir}`);
+	}
+	if (!pathExists(config.repoDir)) {
+		fs.mkdirSync(path.dirname(config.repoDir), { recursive: true });
+		try {
+			execFileSync("git", ["clone", "--branch", config.branch, config.remote, config.repoDir], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+		} catch {
+			fs.mkdirSync(config.repoDir, { recursive: true });
+			runGit(config.repoDir, ["init", "-b", config.branch], { allowFailure: true });
+			if (!isGitRepo(config.repoDir)) runGit(config.repoDir, ["init"]);
+			runGit(config.repoDir, ["checkout", "-B", config.branch]);
+			runGit(config.repoDir, ["remote", "add", "origin", config.remote], { allowFailure: true });
+		}
+	} else if (!isGitRepo(config.repoDir)) {
+		fs.mkdirSync(config.repoDir, { recursive: true });
+		runGit(config.repoDir, ["init", "-b", config.branch], { allowFailure: true });
+		if (!isGitRepo(config.repoDir)) runGit(config.repoDir, ["init"]);
+		runGit(config.repoDir, ["checkout", "-B", config.branch]);
+	}
+
+	const remote = runGit(config.repoDir, ["remote", "get-url", "origin"], { allowFailure: true });
+	if (!remote) runGit(config.repoDir, ["remote", "add", "origin", config.remote]);
+	else if (remote !== config.remote) runGit(config.repoDir, ["remote", "set-url", "origin", config.remote]);
+
+	const branch = runGit(config.repoDir, ["branch", "--show-current"], { allowFailure: true });
+	if (!branch) runGit(config.repoDir, ["checkout", "-B", config.branch]);
+	ensureGitIdentity(config.repoDir);
+}
+
+export function getEvolutionGitStatus(config: EvolutionConfig): GitStatus {
+	if (!config.enabled || !isGitRepo(config.repoDir)) {
+		return {
+			repoDir: config.repoDir,
+			initialized: isGitRepo(config.repoDir),
+			branch: null,
+			remote: null,
+			dirty: false,
+			status: "",
+			lastCommit: null,
+			autoPush: config.autoPush,
+			autoCommit: config.autoCommit,
+			enabled: config.enabled,
+		};
+	}
+	const status = runGit(config.repoDir, ["status", "--short"], { allowFailure: true });
+	return {
+		repoDir: config.repoDir,
+		initialized: true,
+		branch: runGit(config.repoDir, ["branch", "--show-current"], { allowFailure: true }) || null,
+		remote: runGit(config.repoDir, ["remote", "get-url", "origin"], { allowFailure: true }) || null,
+		dirty: Boolean(status),
+		status,
+		lastCommit: runGit(config.repoDir, ["log", "-1", "--oneline"], { allowFailure: true }) || null,
+		autoPush: config.autoPush,
+		autoCommit: config.autoCommit,
+		enabled: config.enabled,
+	};
+}
+
+export function commitEvolutionChanges(config: EvolutionConfig, message: string): GitCommitResult {
+	ensureEvolutionRepo(config);
+	if (!config.autoCommit) {
+		const status = runGit(config.repoDir, ["status", "--short"], { allowFailure: true });
+		return { committed: false, message: "auto commit disabled", status };
+	}
+	runGit(config.repoDir, ["add", "memory", "skill-drafts", "snapshots", "manifests"]);
+	const status = runGit(config.repoDir, ["status", "--short"], { allowFailure: true });
+	if (!status) return { committed: false, status };
+	runGit(config.repoDir, ["commit", "-m", message]);
+	const commit = runGit(config.repoDir, ["rev-parse", "--short", "HEAD"], { allowFailure: true }) || undefined;
+	return { committed: true, commit, status };
+}
+
+export function pushEvolution(config: EvolutionConfig): string {
+	ensureEvolutionRepo(config);
+	const branch = runGit(config.repoDir, ["branch", "--show-current"], { allowFailure: true }) || config.branch;
+	return runGit(config.repoDir, ["push", "-u", "origin", branch]);
+}

package/vendor/pi-memory/src/evolution/index.ts

@@ -0,0 +1,6 @@
+export { DEFAULT_EVOLUTION_BRANCH, DEFAULT_EVOLUTION_REMOTE, resolveEvolutionConfig, type EvolutionConfig } from "./config.ts";
+export { commitEvolutionChanges, ensureEvolutionRepo, getEvolutionGitStatus, pushEvolution, type GitCommitResult, type GitStatus } from "./git.ts";
+export { buildManifest, createSnapshotId, listManifests, readManifest, writeManifest, type EvolutionManifest } from "./manifest.ts";
+export { restoreEvolutionSnapshot, type RestoreResult, type RestoreTarget } from "./restore.ts";
+export { createEvolutionSnapshot, syncEvolutionAfterChange, type SnapshotOptions, type SnapshotResult } from "./snapshot.ts";
+export { syncCurrentToEvolution } from "./sync.ts";

package/vendor/pi-memory/src/evolution/manifest.ts

@@ -0,0 +1,68 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { EvolutionConfig } from "./config.ts";
+import { countFiles } from "./file-utils.ts";
+
+export interface EvolutionManifest {
+	id: string;
+	createdAt: string;
+	reason: string;
+	trigger: string;
+	memoryDir: string;
+	skillDraftsDir: string;
+	repoDir: string;
+	sessionId?: string;
+	files: {
+		memory: number;
+		skillDrafts: number;
+	};
+}
+
+export function createSnapshotId(now = new Date()): string {
+	const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "");
+	const suffix = Math.random().toString(16).slice(2, 8).padEnd(6, "0");
+	return `${stamp}-${suffix}`;
+}
+
+export function buildManifest(config: EvolutionConfig, id: string, reason: string, trigger: string, sessionId?: string, now = new Date()): EvolutionManifest {
+	return {
+		id,
+		createdAt: now.toISOString(),
+		reason,
+		trigger,
+		memoryDir: config.memoryDir,
+		skillDraftsDir: config.skillDraftsDir,
+		repoDir: config.repoDir,
+		sessionId,
+		files: {
+			memory: countFiles(config.memoryDir),
+			skillDrafts: countFiles(config.skillDraftsDir),
+		},
+	};
+}
+
+export function writeManifest(config: EvolutionConfig, manifest: EvolutionManifest): void {
+	const snapshotDir = path.join(config.repoDir, "snapshots", manifest.id);
+	const manifestsDir = path.join(config.repoDir, "manifests");
+	fs.mkdirSync(snapshotDir, { recursive: true });
+	fs.mkdirSync(manifestsDir, { recursive: true });
+	const content = `${JSON.stringify(manifest, null, 2)}\n`;
+	fs.writeFileSync(path.join(snapshotDir, "manifest.json"), content, "utf-8");
+	fs.writeFileSync(path.join(manifestsDir, `${manifest.id}.json`), content, "utf-8");
+}
+
+export function readManifest(config: EvolutionConfig, id: string): EvolutionManifest {
+	const filePath = path.join(config.repoDir, "manifests", `${id}.json`);
+	return JSON.parse(fs.readFileSync(filePath, "utf-8")) as EvolutionManifest;
+}
+
+export function listManifests(config: EvolutionConfig, limit = 20): EvolutionManifest[] {
+	const dir = path.join(config.repoDir, "manifests");
+	if (!fs.existsSync(dir)) return [];
+	return fs.readdirSync(dir)
+		.filter((file) => file.endsWith(".json"))
+		.sort()
+		.reverse()
+		.slice(0, limit)
+		.map((file) => JSON.parse(fs.readFileSync(path.join(dir, file), "utf-8")) as EvolutionManifest);
+}

package/vendor/pi-memory/src/evolution/restore.ts

@@ -0,0 +1,44 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { EvolutionConfig } from "./config.ts";
+import { pathExists, replaceDirFrom } from "./file-utils.ts";
+import { pushEvolution } from "./git.ts";
+import { readManifest, type EvolutionManifest } from "./manifest.ts";
+import { createEvolutionSnapshot, syncEvolutionAfterChange, type SnapshotResult } from "./snapshot.ts";
+
+export type RestoreTarget = "memory" | "skill-drafts" | "all";
+
+export interface RestoreResult {
+	restored: EvolutionManifest;
+	preRestore: SnapshotResult;
+	commit: ReturnType<typeof syncEvolutionAfterChange>;
+	pushed: boolean;
+}
+
+export function restoreEvolutionSnapshot(config: EvolutionConfig, id: string, target: RestoreTarget = "all", sessionId?: string): RestoreResult {
+	if (!config.enabled) throw new Error("Evolution versioning is disabled.");
+	const snapshotDir = path.join(config.repoDir, "snapshots", id);
+	if (!pathExists(snapshotDir)) throw new Error(`Snapshot not found: ${id}`);
+	const manifest = readManifest(config, id);
+	const preRestore = createEvolutionSnapshot(config, {
+		reason: `pre-restore backup before ${id}`,
+		trigger: "restore",
+		sessionId,
+		commitMessage: `memory: snapshot before restore ${id}`,
+	});
+	if (target === "memory" || target === "all") {
+		replaceDirFrom(path.join(snapshotDir, "memory"), config.memoryDir);
+	}
+	if (target === "skill-drafts" || target === "all") {
+		replaceDirFrom(path.join(snapshotDir, "skill-drafts"), config.skillDraftsDir);
+	}
+	fs.mkdirSync(config.memoryDir, { recursive: true });
+	fs.mkdirSync(config.skillDraftsDir, { recursive: true });
+	const commit = syncEvolutionAfterChange(config, `memory: restore snapshot ${id}`);
+	let pushed = false;
+	if (config.autoPush) {
+		pushEvolution(config);
+		pushed = true;
+	}
+	return { restored: manifest, preRestore, commit, pushed };
+}

package/vendor/pi-memory/src/evolution/snapshot.ts

@@ -0,0 +1,41 @@
+import * as path from "node:path";
+import type { EvolutionConfig } from "./config.ts";
+import { copyDirContents, emptyDir } from "./file-utils.ts";
+import { commitEvolutionChanges, ensureEvolutionRepo, type GitCommitResult } from "./git.ts";
+import { buildManifest, createSnapshotId, writeManifest, type EvolutionManifest } from "./manifest.ts";
+import { syncCurrentToEvolution } from "./sync.ts";
+
+export interface SnapshotOptions {
+	reason: string;
+	trigger?: string;
+	sessionId?: string;
+	commitMessage?: string;
+}
+
+export interface SnapshotResult {
+	manifest: EvolutionManifest | null;
+	commit: GitCommitResult | null;
+	skipped?: string;
+}
+
+export function createEvolutionSnapshot(config: EvolutionConfig, options: SnapshotOptions): SnapshotResult {
+	if (!config.enabled) return { manifest: null, commit: null, skipped: "disabled" };
+	ensureEvolutionRepo(config);
+	const id = createSnapshotId();
+	const snapshotDir = path.join(config.repoDir, "snapshots", id);
+	emptyDir(path.join(snapshotDir, "memory"));
+	emptyDir(path.join(snapshotDir, "skill-drafts"));
+	copyDirContents(config.memoryDir, path.join(snapshotDir, "memory"));
+	copyDirContents(config.skillDraftsDir, path.join(snapshotDir, "skill-drafts"));
+	const manifest = buildManifest(config, id, options.reason, options.trigger || "manual", options.sessionId);
+	writeManifest(config, manifest);
+	syncCurrentToEvolution(config);
+	const commit = commitEvolutionChanges(config, options.commitMessage || `memory: snapshot ${id}`);
+	return { manifest, commit };
+}
+
+export function syncEvolutionAfterChange(config: EvolutionConfig, message: string): GitCommitResult | null {
+	if (!config.enabled) return null;
+	syncCurrentToEvolution(config);
+	return commitEvolutionChanges(config, message);
+}

package/vendor/pi-memory/src/evolution/sync.ts

@@ -0,0 +1,20 @@
+import * as path from "node:path";
+import type { EvolutionConfig } from "./config.ts";
+import { copyDirContents, emptyDir } from "./file-utils.ts";
+import { ensureEvolutionRepo } from "./git.ts";
+
+function excludeRepoMetadata(relativePath: string): boolean {
+	const normalized = relativePath.replace(/\\/g, "/");
+	return normalized === ".git" || normalized.startsWith(".git/");
+}
+
+export function syncCurrentToEvolution(config: EvolutionConfig): void {
+	if (!config.enabled) return;
+	ensureEvolutionRepo(config);
+	const memoryMirror = path.join(config.repoDir, "memory");
+	const skillDraftsMirror = path.join(config.repoDir, "skill-drafts");
+	emptyDir(memoryMirror);
+	emptyDir(skillDraftsMirror);
+	copyDirContents(config.memoryDir, memoryMirror, { exclude: excludeRepoMetadata });
+	copyDirContents(config.skillDraftsDir, skillDraftsMirror, { exclude: excludeRepoMetadata });
+}

package/vendor/pi-memory/src/index.ts

@@ -33,3 +33,26 @@ export { validateMemoryPatch, type MemoryPatch } from "./curator-core/patch.ts";
 export { DEFAULT_MEMORY_DIR, FileMemoryStore } from "./curator-store/file-store.ts";
 export { ENTRY_DELIMITER, MEMORY_TARGETS, normalizeMemoryTarget, type CuratorState, type MemoryStore, type MemoryTarget } from "./curator-store/types.ts";
 export { disableCuratorService, enableCuratorService, getCuratorServiceStatus, resolveMemoryDir, type CuratorServiceBackend, type CuratorServiceResult, type CuratorServiceState } from "./service-controller.ts";
+export {
+	DEFAULT_EVOLUTION_BRANCH,
+	DEFAULT_EVOLUTION_REMOTE,
+	commitEvolutionChanges,
+	createEvolutionSnapshot,
+	createSnapshotId,
+	ensureEvolutionRepo,
+	getEvolutionGitStatus,
+	listManifests,
+	pushEvolution,
+	resolveEvolutionConfig,
+	restoreEvolutionSnapshot,
+	syncCurrentToEvolution,
+	syncEvolutionAfterChange,
+	type EvolutionConfig,
+	type EvolutionManifest,
+	type GitCommitResult,
+	type GitStatus,
+	type RestoreResult,
+	type RestoreTarget,
+	type SnapshotOptions,
+	type SnapshotResult,
+} from "./evolution/index.ts";

package/vendor/pi-memory/test/evolution.test.ts

@@ -0,0 +1,80 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import {
+	createEvolutionSnapshot,
+	getEvolutionGitStatus,
+	listManifests,
+	resolveEvolutionConfig,
+	restoreEvolutionSnapshot,
+	syncEvolutionAfterChange,
+} from "../src/index.ts";
+
+function testConfig() {
+	const root = mkdtempSync(join(tmpdir(), "pi-memory-evolution-"));
+	const memoryDir = join(root, "memory");
+	const skillDraftsDir = join(root, "skill-drafts");
+	const repoDir = join(root, "evolution");
+	return {
+		root,
+		memoryDir,
+		skillDraftsDir,
+		repoDir,
+		config: resolveEvolutionConfig(memoryDir, {
+			PI_EVOLUTION_DIR: repoDir,
+			PI_EVOLUTION_REMOTE: "https://example.invalid/pi-evolution.git",
+			PI_EVOLUTION_AUTO_PUSH: "0",
+			HOME: root,
+		}),
+	};
+}
+
+test("creates snapshot, manifest, current mirrors, and git commit", () => {
+	const { memoryDir, skillDraftsDir, repoDir, config } = testConfig();
+	mkdirSync(memoryDir, { recursive: true });
+	mkdirSync(skillDraftsDir, { recursive: true });
+	writeFileSync(join(memoryDir, "MEMORY.md"), "stable memory\n", { encoding: "utf-8", flag: "w" });
+	writeFileSync(join(skillDraftsDir, "draft.txt"), "draft\n", { encoding: "utf-8", flag: "w" });
+
+	const result = createEvolutionSnapshot(config, { reason: "test snapshot", trigger: "test", commitMessage: "memory: test snapshot" });
+
+	assert.ok(result.manifest?.id);
+	assert.equal(result.commit?.committed, true);
+	assert.equal(existsSync(join(repoDir, "memory", "MEMORY.md")), true);
+	assert.equal(existsSync(join(repoDir, "skill-drafts", "draft.txt")), true);
+	assert.equal(existsSync(join(repoDir, "snapshots", result.manifest.id, "manifest.json")), true);
+	assert.equal(existsSync(join(repoDir, "manifests", `${result.manifest.id}.json`)), true);
+	assert.equal(listManifests(config, 1)[0].reason, "test snapshot");
+	assert.match(getEvolutionGitStatus(config).lastCommit || "", /memory: test snapshot/);
+});
+
+test("sync does not create empty commits when nothing changed", () => {
+	const { memoryDir, config } = testConfig();
+	mkdirSync(memoryDir, { recursive: true });
+	writeFileSync(join(memoryDir, "MEMORY.md"), "stable memory\n", { encoding: "utf-8", flag: "w" });
+	createEvolutionSnapshot(config, { reason: "test snapshot", trigger: "test", commitMessage: "memory: first" });
+
+	const result = syncEvolutionAfterChange(config, "memory: no-op");
+
+	assert.equal(result?.committed, false);
+});
+
+test("restore creates pre-restore backup and restores selected target", () => {
+	const { memoryDir, skillDraftsDir, config } = testConfig();
+	mkdirSync(memoryDir, { recursive: true });
+	mkdirSync(skillDraftsDir, { recursive: true });
+	writeFileSync(join(memoryDir, "MEMORY.md"), "before\n", { encoding: "utf-8", flag: "w" });
+	writeFileSync(join(skillDraftsDir, "draft.txt"), "draft before\n", { encoding: "utf-8", flag: "w" });
+	const snapshot = createEvolutionSnapshot(config, { reason: "restore point", trigger: "test", commitMessage: "memory: restore point" });
+	writeFileSync(join(memoryDir, "MEMORY.md"), "after\n", "utf-8");
+	writeFileSync(join(skillDraftsDir, "draft.txt"), "draft after\n", "utf-8");
+
+	const result = restoreEvolutionSnapshot(config, snapshot.manifest?.id || "", "memory");
+
+	assert.equal(readFileSync(join(memoryDir, "MEMORY.md"), "utf-8"), "before\n");
+	assert.equal(readFileSync(join(skillDraftsDir, "draft.txt"), "utf-8"), "draft after\n");
+	assert.ok(result.preRestore.manifest?.id);
+	assert.match(getEvolutionGitStatus(config).lastCommit || "", /memory: restore snapshot/);
+});