t3 0.0.3 → 0.0.4

package/dist/index.mjs

@@ -194,22 +194,44 @@ const resolveStaticDir = Effect.fn(function* () {
 	if (yield* exists(join(monorepoClient, "index.html")).pipe(Effect.orElseSucceed(() => false))) return monorepoClient;
 });
 
+//#endregion
+//#region ../../packages/shared/src/shell.ts
+const PATH_CAPTURE_START = "__T3CODE_PATH_START__";
+const PATH_CAPTURE_END = "__T3CODE_PATH_END__";
+const PATH_CAPTURE_COMMAND = [
+	`printf '%s\n' '${PATH_CAPTURE_START}'`,
+	"printenv PATH",
+	`printf '%s\n' '${PATH_CAPTURE_END}'`
+].join("; ");
+function extractPathFromShellOutput(output) {
+	const startIndex = output.indexOf(PATH_CAPTURE_START);
+	if (startIndex === -1) return null;
+	const valueStartIndex = startIndex + 21;
+	const endIndex = output.indexOf(PATH_CAPTURE_END, valueStartIndex);
+	if (endIndex === -1) return null;
+	const pathValue = output.slice(valueStartIndex, endIndex).trim();
+	return pathValue.length > 0 ? pathValue : null;
+}
+function readPathFromLoginShell(shell, execFile = execFileSync) {
+	return extractPathFromShellOutput(execFile(shell, ["-ilc", PATH_CAPTURE_COMMAND], {
+		encoding: "utf8",
+		timeout: 5e3
+	})) ?? void 0;
+}
+
 //#endregion
 //#region src/os-jank.ts
 function fixPath() {
 	if (process.platform !== "darwin") return;
 	try {
-		const result = execFileSync(process.env.SHELL ?? "/bin/zsh", ["-ilc", "echo -n $PATH"], {
-			encoding: "utf8",
-			timeout: 5e3
-		});
+		const result = readPathFromLoginShell(process.env.SHELL ?? "/bin/zsh");
 		if (result) process.env.PATH = result;
 	} catch {}
 }
 const expandHomePath = Effect.fn(function* (input) {
-	const { join, sep } = yield* Path.Path;
+	const { join } = yield* Path.Path;
 	if (input === "~") return OS.homedir();
-	if (input.startsWith(`~${sep}`)) return join(OS.homedir(), input.slice(sep.length));
+	if (input.startsWith("~/") || input.startsWith("~\\")) return join(OS.homedir(), input.slice(2));
 	return input;
 });
 const resolveStateDir = Effect.fn(function* (raw) {
@@ -5160,6 +5182,12 @@ var ProviderService = class extends ServiceMap.Service()("t3/provider/Services/P
 */
 var CheckpointReactor = class extends ServiceMap.Service()("t3/orchestration/Services/CheckpointReactor") {};
 
+//#endregion
+//#region src/git/isRepo.ts
+function isGitRepository(cwd) {
+	return existsSync(join(cwd, ".git"));
+}
+
 //#endregion
 //#region src/orchestration/Layers/CheckpointReactor.ts
 function toTurnId$2(value) {
@@ -5231,6 +5259,7 @@ const make$2 = Effect.gen(function* () {
 		}
 		return Option.none();
 	});
+	const isGitWorkspace = (cwd) => isGitRepository(cwd);
 	const captureCheckpointFromTurnCompletion = Effect.fnUntraced(function* (event) {
 		const turnId = toTurnId$2(event.turnId);
 		if (!turnId) return;
@@ -5254,6 +5283,14 @@ const make$2 = Effect.gen(function* () {
 			});
 			return;
 		}
+		if (!isGitWorkspace(checkpointCwd)) {
+			yield* Effect.logDebug("checkpoint capture skipped for non-git workspace", {
+				threadId: thread.id,
+				turnId,
+				cwd: checkpointCwd
+			});
+			return;
+		}
 		const nextTurnCount = thread.checkpoints.reduce((maxTurnCount, checkpoint) => Math.max(maxTurnCount, checkpoint.checkpointTurnCount), 0) + 1;
 		const fromTurnCount = Math.max(0, nextTurnCount - 1);
 		const fromCheckpointRef = checkpointRefForThreadTurn(thread.id, fromTurnCount);
@@ -5345,6 +5382,7 @@ const make$2 = Effect.gen(function* () {
 			});
 			return;
 		}
+		if (!isGitWorkspace(checkpointCwd)) return;
 		const currentTurnCount = thread.checkpoints.reduce((maxTurnCount, checkpoint) => Math.max(maxTurnCount, checkpoint.checkpointTurnCount), 0);
 		const baselineCheckpointRef = checkpointRefForThreadTurn(thread.id, currentTurnCount);
 		if (yield* checkpointStore.hasCheckpointRef({
@@ -5375,6 +5413,7 @@ const make$2 = Effect.gen(function* () {
 			yield* Effect.logWarning("checkpoint pre-turn capture skipped: no workspace cwd", { threadId });
 			return;
 		}
+		if (!isGitWorkspace(checkpointCwd)) return;
 		const baselineCheckpointRef = checkpointRefForThreadTurn(threadId, thread.checkpoints.reduce((maxTurnCount, checkpoint) => Math.max(maxTurnCount, checkpoint.checkpointTurnCount), 0));
 		if (yield* checkpointStore.hasCheckpointRef({
 			cwd: checkpointCwd,
@@ -5407,6 +5446,15 @@ const make$2 = Effect.gen(function* () {
 			}).pipe(Effect.catch(() => Effect.void));
 			return;
 		}
+		if (!isGitWorkspace(sessionRuntime.value.cwd)) {
+			yield* appendRevertFailureActivity({
+				threadId: event.payload.threadId,
+				turnCount: event.payload.turnCount,
+				detail: "Checkpoints are unavailable because this project is not a git repository.",
+				createdAt: now
+			}).pipe(Effect.catch(() => Effect.void));
+			return;
+		}
 		const currentTurnCount = thread.checkpoints.reduce((maxTurnCount, checkpoint) => Math.max(maxTurnCount, checkpoint.checkpointTurnCount), 0);
 		if (event.payload.turnCount > currentTurnCount) {
 			yield* appendRevertFailureActivity({
@@ -8780,6 +8828,17 @@ const make = Effect.gen(function* () {
 			createdAt: ""
 		})
 	});
+	const isGitRepoForThread = Effect.fnUntraced(function* (threadId) {
+		const readModel = yield* orchestrationEngine.getReadModel();
+		const thread = readModel.threads.find((entry) => entry.id === threadId);
+		if (!thread) return false;
+		const workspaceCwd = resolveThreadWorkspaceCwd({
+			thread,
+			projects: readModel.projects
+		});
+		if (!workspaceCwd) return false;
+		return isGitRepository(workspaceCwd);
+	});
 	const rememberAssistantMessageId = (threadId, turnId, messageId) => Cache.getOption(turnMessageIdsByTurnKey, providerTurnKey(threadId, turnId)).pipe(Effect.flatMap((existingIds) => Cache.set(turnMessageIdsByTurnKey, providerTurnKey(threadId, turnId), Option.match(existingIds, {
 		onNone: () => new Set([messageId]),
 		onSome: (ids) => {
@@ -9058,7 +9117,7 @@ const make = Effect.gen(function* () {
 		});
 		if (event.type === "turn.diff.updated") {
 			const turnId = toTurnId$1(event.turnId);
-			if (turnId) {
+			if (turnId && (yield* isGitRepoForThread(thread.id))) {
 				const assistantMessageId = MessageId.makeUnsafe(`assistant:${event.itemId ?? event.turnId ?? event.eventId}`);
 				yield* orchestrationEngine.dispatch({
 					type: "thread.turn.diff.complete",
@@ -11567,11 +11626,10 @@ const makeProviderService = (options) => Effect.gen(function* () {
 		return activeSessions.map((session) => {
 			const binding = bindingsByThreadId.get(session.threadId);
 			if (!binding) return session;
-			return {
-				...session,
-				...session.resumeCursor === void 0 && binding.resumeCursor !== void 0 ? { resumeCursor: binding.resumeCursor } : {},
-				...binding.runtimeMode !== void 0 ? { runtimeMode: binding.runtimeMode } : {}
-			};
+			const overrides = {};
+			if (session.resumeCursor === void 0 && binding.resumeCursor !== void 0) overrides.resumeCursor = binding.resumeCursor;
+			if (binding.runtimeMode !== void 0) overrides.runtimeMode = binding.runtimeMode;
+			return Object.assign({}, session, overrides);
 		});
 	});
 	const getCapabilities = (provider) => registry.getByProvider(provider).pipe(Effect.map((adapter) => adapter.capabilities));
@@ -12843,7 +12901,7 @@ var TerminalManagerRuntime = class extends EventEmitter {
 	}
 	async runWithThreadLock(threadId, task) {
 		const previous = this.threadLocks.get(threadId) ?? Promise.resolve();
-		let release = () => {};
+		let release;
 		const current = new Promise((resolve) => {
 			release = resolve;
 		});
@@ -15834,6 +15892,11 @@ function resolveWorkspaceWritePath(params) {
 function stripRequestTag(body) {
 	return Struct.omit(body, ["_tag"]);
 }
+function messageFromCause(cause) {
+	const squashed = Cause.squash(cause);
+	const message = squashed instanceof Error ? squashed.message.trim() : String(squashed).trim();
+	return message.length > 0 ? message : Cause.pretty(cause);
+}
 var ServerLifecycleError = class extends Schema.TaggedErrorClass()("ServerLifecycleError", {
 	operation: Schema.String,
 	cause: Schema.optional(Schema.Defect)
@@ -15884,6 +15947,21 @@ const createServer = Effect.fn(function* () {
 		});
 	});
 	const normalizeDispatchCommand = Effect.fnUntraced(function* (input) {
+		const normalizeProjectWorkspaceRoot = Effect.fnUntraced(function* (workspaceRoot) {
+			const normalizedWorkspaceRoot = path.resolve(yield* expandHomePath(workspaceRoot.trim()));
+			const workspaceStat = yield* fileSystem.stat(normalizedWorkspaceRoot).pipe(Effect.catch(() => Effect.succeed(null)));
+			if (!workspaceStat) return yield* new RouteRequestError({ message: `Project directory does not exist: ${normalizedWorkspaceRoot}` });
+			if (workspaceStat.type !== "Directory") return yield* new RouteRequestError({ message: `Project path is not a directory: ${normalizedWorkspaceRoot}` });
+			return normalizedWorkspaceRoot;
+		});
+		if (input.command.type === "project.create") return {
+			...input.command,
+			workspaceRoot: yield* normalizeProjectWorkspaceRoot(input.command.workspaceRoot)
+		};
+		if (input.command.type === "project.meta.update" && input.command.workspaceRoot !== void 0) return {
+			...input.command,
+			workspaceRoot: yield* normalizeProjectWorkspaceRoot(input.command.workspaceRoot)
+		};
 		if (input.command.type !== "thread.turn.start") return input.command;
 		const turnStartCommand = input.command;
 		const normalizedAttachments = yield* Effect.forEach(turnStartCommand.message.attachments, (attachment) => Effect.gen(function* () {
@@ -16102,7 +16180,8 @@ const createServer = Effect.fn(function* () {
 		operation: "autoBootstrapProject",
 		cause
 	})));
-	const runPromise = yield* Effect.map(Effect.services(), Effect.runPromiseWith);
+	const runtimeServices = yield* Effect.services();
+	const runPromise = Effect.runPromiseWith(runtimeServices);
 	const unsubscribeTerminalEvents = yield* terminalManager.subscribe((event) => void Effect.runPromise(onTerminalEvent(event)));
 	yield* Effect.addFinalizer(() => Effect.sync(() => unsubscribeTerminalEvents()));
 	yield* NodeHttpServer.make(() => httpServer, listenOptions).pipe(Effect.mapError((cause) => new ServerLifecycleError({
@@ -16250,7 +16329,7 @@ const createServer = Effect.fn(function* () {
 		if (request._tag === "Failure") {
 			const errorResponse = yield* encodeResponse({
 				id: "unknown",
-				error: { message: `Invalid request format: ${Cause.pretty(request.cause)}` }
+				error: { message: `Invalid request format: ${messageFromCause(request.cause)}` }
 			});
 			ws.send(errorResponse);
 			return;
@@ -16259,7 +16338,7 @@ const createServer = Effect.fn(function* () {
 		if (result._tag === "Failure") {
 			const errorResponse = yield* encodeResponse({
 				id: request.value.id,
-				error: { message: Cause.pretty(result.cause) }
+				error: { message: messageFromCause(result.cause) }
 			});
 			ws.send(errorResponse);
 			return;
@@ -16386,7 +16465,7 @@ const getTelemetryIdentifier = Effect.gen(function* () {
 
 //#endregion
 //#region package.json
-var version = "0.0.2";
+var version = "0.0.3";
 
 //#endregion
 //#region src/telemetry/Layers/AnalyticsService.ts