@clinebot/core 0.0.0

package/src/session/workspace-manager.ts

@@ -0,0 +1,98 @@
+import type { WorkspaceInfo } from "../types/workspace";
+import {
+	generateWorkspaceInfo,
+	normalizeWorkspacePath,
+	upsertWorkspaceInfo,
+	type WorkspaceManifest,
+	WorkspaceManifestSchema,
+} from "./workspace-manifest";
+
+export interface WorkspaceManagerEvent {
+	type: "workspace_added" | "workspace_switched";
+	workspace: WorkspaceInfo;
+}
+
+export interface WorkspaceManager {
+	addWorkspacePath(workspacePath: string): Promise<WorkspaceInfo>;
+	switchWorkspace(workspacePath: string): Promise<WorkspaceInfo>;
+	subscribe(listener: (event: WorkspaceManagerEvent) => void): () => void;
+	getCurrentWorkspace(): WorkspaceInfo | undefined;
+	getWorkspace(workspacePath: string): WorkspaceInfo | undefined;
+	listWorkspaces(): WorkspaceInfo[];
+	getManifest(): WorkspaceManifest;
+}
+
+export class InMemoryWorkspaceManager implements WorkspaceManager {
+	private manifest: WorkspaceManifest;
+	private readonly listeners = new Set<
+		(event: WorkspaceManagerEvent) => void
+	>();
+
+	constructor(manifest?: WorkspaceManifest) {
+		this.manifest = WorkspaceManifestSchema.parse(
+			manifest ?? { workspaces: {} },
+		);
+	}
+
+	async addWorkspacePath(workspacePath: string): Promise<WorkspaceInfo> {
+		const info = await generateWorkspaceInfo(workspacePath);
+		this.manifest = upsertWorkspaceInfo(this.manifest, info);
+		this.emit({ type: "workspace_added", workspace: info });
+		return info;
+	}
+
+	async switchWorkspace(workspacePath: string): Promise<WorkspaceInfo> {
+		const normalizedPath = normalizeWorkspacePath(workspacePath);
+		const existing = this.manifest.workspaces[normalizedPath];
+		if (existing) {
+			this.manifest = WorkspaceManifestSchema.parse({
+				...this.manifest,
+				currentWorkspacePath: normalizedPath,
+			});
+			this.emit({ type: "workspace_switched", workspace: existing });
+			return existing;
+		}
+
+		const added = await this.addWorkspacePath(normalizedPath);
+		this.manifest = WorkspaceManifestSchema.parse({
+			...this.manifest,
+			currentWorkspacePath: added.rootPath,
+		});
+		this.emit({ type: "workspace_switched", workspace: added });
+		return added;
+	}
+
+	subscribe(listener: (event: WorkspaceManagerEvent) => void): () => void {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+
+	getCurrentWorkspace(): WorkspaceInfo | undefined {
+		const currentPath = this.manifest.currentWorkspacePath;
+		if (!currentPath) {
+			return undefined;
+		}
+		return this.manifest.workspaces[currentPath];
+	}
+
+	getWorkspace(workspacePath: string): WorkspaceInfo | undefined {
+		const normalizedPath = normalizeWorkspacePath(workspacePath);
+		return this.manifest.workspaces[normalizedPath];
+	}
+
+	listWorkspaces(): WorkspaceInfo[] {
+		return Object.values(this.manifest.workspaces);
+	}
+
+	getManifest(): WorkspaceManifest {
+		return this.manifest;
+	}
+
+	private emit(event: WorkspaceManagerEvent): void {
+		for (const listener of this.listeners) {
+			listener(event);
+		}
+	}
+}

package/src/session/workspace-manifest.ts

@@ -0,0 +1,100 @@
+import { basename, resolve } from "node:path";
+import simpleGit from "simple-git";
+import { z } from "zod";
+import type { WorkspaceInfo } from "../types/workspace";
+
+export const WorkspaceInfoSchema = z.object({
+	rootPath: z.string().min(1),
+	hint: z.string().min(1).optional(),
+	associatedRemoteUrls: z.array(z.string().min(1)).optional(),
+	latestGitCommitHash: z.string().min(1).optional(),
+	latestGitBranchName: z.string().min(1).optional(),
+});
+
+export const WorkspaceManifestSchema = z.object({
+	currentWorkspacePath: z.string().min(1).optional(),
+	workspaces: z.record(z.string().min(1), WorkspaceInfoSchema),
+});
+
+export type WorkspaceManifest = z.infer<typeof WorkspaceManifestSchema>;
+
+export function emptyWorkspaceManifest(): WorkspaceManifest {
+	return { workspaces: {} };
+}
+
+export function normalizeWorkspacePath(workspacePath: string): string {
+	return resolve(workspacePath);
+}
+
+export async function generateWorkspaceInfo(
+	workspacePath: string,
+): Promise<WorkspaceInfo> {
+	const rootPath = normalizeWorkspacePath(workspacePath);
+	const info: WorkspaceInfo = {
+		rootPath,
+		hint: basename(rootPath),
+	};
+
+	try {
+		const git = simpleGit({ baseDir: rootPath });
+		const isRepo = await git.checkIsRepo();
+		if (!isRepo) {
+			return info;
+		}
+
+		const remotes = await git.getRemotes(true);
+		if (remotes.length > 0) {
+			const associatedRemoteUrls = remotes.map((remote) => {
+				const remoteUrl = remote.refs.fetch || remote.refs.push;
+				return `${remote.name}: ${remoteUrl}`;
+			});
+			info.associatedRemoteUrls = associatedRemoteUrls;
+		}
+
+		const latestGitCommitHash = (await git.revparse(["HEAD"])).trim();
+		if (latestGitCommitHash.length > 0) {
+			info.latestGitCommitHash = latestGitCommitHash;
+		}
+
+		const latestGitBranchName = (await git.branch()).current.trim();
+		if (latestGitBranchName.length > 0) {
+			info.latestGitBranchName = latestGitBranchName;
+		}
+	} catch {
+		// Non-git workspaces keep only path + hint.
+	}
+
+	return info;
+}
+
+export function upsertWorkspaceInfo(
+	manifest: WorkspaceManifest,
+	info: WorkspaceInfo,
+): WorkspaceManifest {
+	const nextManifest: WorkspaceManifest = {
+		...manifest,
+		workspaces: {
+			...manifest.workspaces,
+			[info.rootPath]: info,
+		},
+	};
+	if (!nextManifest.currentWorkspacePath) {
+		nextManifest.currentWorkspacePath = info.rootPath;
+	}
+	return WorkspaceManifestSchema.parse(nextManifest);
+}
+
+export async function buildWorkspaceMetadata(cwd: string): Promise<string> {
+	const workspaceInfo = await generateWorkspaceInfo(cwd);
+	const workspaceConfig = {
+		workspaces: {
+			[workspaceInfo.rootPath]: {
+				hint: workspaceInfo.hint,
+				associatedRemoteUrls: workspaceInfo.associatedRemoteUrls,
+				latestGitCommitHash: workspaceInfo.latestGitCommitHash,
+				latestGitBranchName: workspaceInfo.latestGitBranchName,
+			},
+		},
+	};
+	return `# Workspace Configuration\n${JSON.stringify(workspaceConfig, null, 2)}`;
+}

package/src/storage/artifact-store.ts

@@ -0,0 +1 @@
+export type { ArtifactStore } from "../types/storage";

package/src/storage/index.ts

@@ -0,0 +1,11 @@
+export type { ArtifactStore } from "./artifact-store";
+export {
+	type MigrateLegacyProviderSettingsOptions,
+	type MigrateLegacyProviderSettingsResult,
+	migrateLegacyProviderSettings,
+} from "./provider-settings-legacy-migration";
+export { ProviderSettingsManager } from "./provider-settings-manager";
+export type { SessionStore } from "./session-store";
+export { SqliteSessionStore } from "./sqlite-session-store";
+export type { TeamStore } from "./team-store";
+export { SqliteTeamStore, type SqliteTeamStoreOptions } from "./team-store";

package/src/storage/provider-settings-legacy-migration.test.ts

@@ -0,0 +1,175 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { migrateLegacyProviderSettings } from "./provider-settings-legacy-migration";
+import { ProviderSettingsManager } from "./provider-settings-manager";
+
+describe("migrateLegacyProviderSettings", () => {
+	const tempDirs: string[] = [];
+
+	afterEach(() => {
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("migrates legacy provider state into providers.json when target is empty", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-legacy-provider-"),
+		);
+		tempDirs.push(tempDir);
+		const providersPath = path.join(tempDir, "settings", "providers.json");
+		const manager = new ProviderSettingsManager({ filePath: providersPath });
+
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					mode: "act",
+					actModeApiProvider: "anthropic",
+					actModeApiModelId: "claude-sonnet-4-6",
+					anthropicBaseUrl: "https://example.invalid/anthropic",
+					actModeReasoningEffort: "high",
+					actModeThinkingBudgetTokens: 2048,
+					requestTimeoutMs: 90000,
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(
+			path.join(tempDir, "secrets.json"),
+			JSON.stringify({ apiKey: "legacy-anthropic-key" }, null, 2),
+		);
+
+		const result = migrateLegacyProviderSettings({
+			providerSettingsManager: manager,
+			dataDir: tempDir,
+		});
+
+		expect(result).toMatchObject({
+			migrated: true,
+			providerCount: 1,
+			lastUsedProvider: "anthropic",
+		});
+		expect(manager.getProviderSettings("anthropic")).toEqual({
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+			apiKey: "legacy-anthropic-key",
+			baseUrl: "https://example.invalid/anthropic",
+			timeout: 90000,
+			reasoning: {
+				effort: "high",
+				budgetTokens: 2048,
+			},
+		});
+		expect(manager.read().providers.anthropic?.tokenSource).toBe("migration");
+	});
+
+	it("migrates missing providers without overwriting existing providers", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-legacy-provider-"),
+		);
+		tempDirs.push(tempDir);
+		const providersPath = path.join(tempDir, "settings", "providers.json");
+		const manager = new ProviderSettingsManager({ filePath: providersPath });
+
+		manager.saveProviderSettings({
+			provider: "openai",
+			model: "gpt-5",
+			apiKey: "already-migrated",
+		});
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					mode: "act",
+					actModeApiProvider: "anthropic",
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(
+			path.join(tempDir, "secrets.json"),
+			JSON.stringify({ apiKey: "legacy-key" }, null, 2),
+		);
+
+		const result = migrateLegacyProviderSettings({
+			providerSettingsManager: manager,
+			dataDir: tempDir,
+		});
+
+		expect(result.migrated).toBe(true);
+		expect(manager.getProviderSettings("openai")?.apiKey).toBe(
+			"already-migrated",
+		);
+		expect(manager.getProviderSettings("anthropic")).toEqual({
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+			apiKey: "legacy-key",
+		});
+		expect(manager.read().providers.openai?.tokenSource).toBe("manual");
+		expect(manager.read().providers.anthropic?.tokenSource).toBe("migration");
+	});
+
+	it("migrates legacy OpenAI Codex OAuth credentials", () => {
+		const tempDir = mkdtempSync(
+			path.join(os.tmpdir(), "core-legacy-provider-"),
+		);
+		tempDirs.push(tempDir);
+		const providersPath = path.join(tempDir, "settings", "providers.json");
+		const manager = new ProviderSettingsManager({ filePath: providersPath });
+
+		writeFileSync(
+			path.join(tempDir, "globalState.json"),
+			JSON.stringify(
+				{
+					mode: "act",
+					actModeApiProvider: "openai-codex",
+				},
+				null,
+				2,
+			),
+		);
+		writeFileSync(
+			path.join(tempDir, "secrets.json"),
+			JSON.stringify(
+				{
+					"openai-codex-oauth-credentials": JSON.stringify({
+						type: "openai-codex",
+						access_token: "legacy-access",
+						refresh_token: "legacy-refresh",
+						expires: Date.now() + 60_000,
+						accountId: "acct_123",
+					}),
+				},
+				null,
+				2,
+			),
+		);
+
+		const result = migrateLegacyProviderSettings({
+			providerSettingsManager: manager,
+			dataDir: tempDir,
+		});
+
+		expect(result).toMatchObject({
+			migrated: true,
+			lastUsedProvider: "openai-codex",
+		});
+		expect(manager.getProviderSettings("openai-codex")).toEqual({
+			provider: "openai-codex",
+			apiKey: "legacy-access",
+			auth: {
+				accessToken: "legacy-access",
+				refreshToken: "legacy-refresh",
+				accountId: "acct_123",
+			},
+		});
+		expect(manager.read().providers["openai-codex"]?.tokenSource).toBe(
+			"migration",
+		);
+	});
+});