t3code-cli 0.5.1 → 0.7.0

package/src/domain/helpers.test.ts

@@ -0,0 +1,103 @@
+import "vite-plus/test/config";
+
+import * as Effect from "effect/Effect";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, describe, it } from "@effect/vitest";
+import { fromPartial } from "@total-typescript/shoehorn";
+
+import type { OrchestrationShellSnapshot } from "#t3tools/contracts";
+
+import { resolveProjectScope } from "./helpers.ts";
+
+describe("resolveProjectScope", () => {
+  it.layer(NodeServices.layer)("resolveProjectScope", (t) => {
+    t.effect("resolves by id first (even if ref not absolute)", () =>
+      Effect.gen(function* () {
+        const snapshot: OrchestrationShellSnapshot = fromPartial({
+          projects: [{ id: "proj-1", workspaceRoot: "/workspace" }],
+          threads: [],
+        });
+
+        const scope = yield* resolveProjectScope(snapshot, { ref: "proj-1" });
+        assert.equal(scope?.project.id, "proj-1");
+        assert.equal(scope?.inferredWorktreePath, undefined);
+      }),
+    );
+
+    t.effect("returns undefined for non-absolute path refs", () =>
+      Effect.gen(function* () {
+        const snapshot: OrchestrationShellSnapshot = fromPartial({
+          projects: [{ id: "proj-1", workspaceRoot: "/workspace" }],
+          threads: [],
+        });
+
+        const scope = yield* resolveProjectScope(snapshot, { ref: "workspace/subdir" });
+        assert.equal(scope, undefined);
+      }),
+    );
+
+    t.effect("prefers longest matching workspaceRoot", () =>
+      Effect.gen(function* () {
+        const snapshot: OrchestrationShellSnapshot = fromPartial({
+          projects: [
+            { id: "proj-a", workspaceRoot: "/workspace" },
+            { id: "proj-b", workspaceRoot: "/workspace/sub" },
+          ],
+          threads: [],
+        });
+
+        const scope = yield* resolveProjectScope(snapshot, { ref: "/workspace/sub/deep" });
+        assert.equal(scope?.project.id, "proj-b");
+        assert.equal(scope?.inferredWorktreePath, "/workspace/sub/deep");
+      }),
+    );
+
+    t.effect("does not infer worktree when ref equals workspaceRoot", () =>
+      Effect.gen(function* () {
+        const snapshot: OrchestrationShellSnapshot = fromPartial({
+          projects: [
+            { id: "proj-a", workspaceRoot: "/workspace" },
+            { id: "proj-b", workspaceRoot: "/workspace/sub" },
+          ],
+          threads: [],
+        });
+
+        const scope = yield* resolveProjectScope(snapshot, { ref: "/workspace/sub" });
+        assert.equal(scope?.project.id, "proj-b");
+        assert.equal(scope?.inferredWorktreePath, undefined);
+      }),
+    );
+
+    t.effect("prefers worktree candidate over project candidate for same match path", () =>
+      Effect.gen(function* () {
+        const snapshot: OrchestrationShellSnapshot = fromPartial({
+          projects: [
+            { id: "proj-a", workspaceRoot: "/workspace" },
+            { id: "proj-b", workspaceRoot: "/workspace/proj" },
+          ],
+          threads: [{ projectId: "proj-a", worktreePath: "/workspace/proj" }],
+        });
+
+        const scope = yield* resolveProjectScope(snapshot, { ref: "/workspace/proj" });
+        assert.equal(scope?.project.id, "proj-a");
+        assert.equal(scope?.inferredWorktreePath, "/workspace/proj");
+      }),
+    );
+
+    t.effect("prefers longest matching worktree path", () =>
+      Effect.gen(function* () {
+        const snapshot: OrchestrationShellSnapshot = fromPartial({
+          projects: [{ id: "proj-a", workspaceRoot: "/workspace" }],
+          threads: [
+            { projectId: "proj-a", worktreePath: "/workspace/proj" },
+            { projectId: "proj-a", worktreePath: "/workspace/proj/deep" },
+          ],
+        });
+
+        const scope = yield* resolveProjectScope(snapshot, { ref: "/workspace/proj/deep/child" });
+        assert.equal(scope?.project.id, "proj-a");
+        assert.equal(scope?.inferredWorktreePath, "/workspace/proj/deep/child");
+      }),
+    );
+  });
+});

package/src/domain/helpers.ts

@@ -1,27 +1,31 @@
-import type * as Path from "effect/Path";
+import * as Effect from "effect/Effect";
+import * as Path from "effect/Path";
 import type { OrchestrationProjectShell, OrchestrationShellSnapshot } from "#t3tools/contracts";
 
-import { ProjectLookupError } from "./error.ts";
+export type ResolvedProjectScope = {
+  readonly project: OrchestrationProjectShell;
+  readonly inferredWorktreePath?: string;
+};
 
-export function resolveProject(
+export const resolveProjectScope = Effect.fn("resolveProjectScope")(function* (
   snapshot: OrchestrationShellSnapshot,
-  ref: string,
-  path: Path.Path,
-  cwd: string,
+  input: {
+    readonly ref: string;
+  },
 ) {
-  const byId = findProjectById(snapshot, ref);
+  const path = yield* Path.Path;
+
+  const byId = findProjectById(snapshot, input.ref);
   if (byId !== null) {
-    return byId;
+    return { project: byId };
   }
-  const absolute = path.resolve(cwd, ref);
-  const byPath = snapshot.projects.find(
-    (project) => path.resolve(cwd, project.workspaceRoot) === absolute,
-  );
-  if (byPath !== undefined) {
-    return byPath;
+
+  if (!path.isAbsolute(input.ref)) {
+    return undefined;
   }
-  throw new ProjectLookupError({ message: `project not found: ${ref}`, ref });
-}
+
+  return yield* findProjectByPathPriority(snapshot, path.normalize(input.ref));
+});
 
 export function findProjectById(
   snapshot: OrchestrationShellSnapshot,
@@ -29,3 +33,95 @@ export function findProjectById(
 ): OrchestrationProjectShell | null {
   return snapshot.projects.find((project) => project.id === projectId) ?? null;
 }
+
+const isDescendantPath = Effect.fn("isDescendantPath")(function* (parent: string, child: string) {
+  const path = yield* Path.Path;
+  if (child === parent) {
+    return true;
+  }
+  const relative = path.relative(parent, child);
+  return relative.length > 0 && !relative.startsWith("..") && !path.isAbsolute(relative);
+});
+
+const findProjectByPathPriority = Effect.fn("findProjectByPathPriority")(function* (
+  snapshot: OrchestrationShellSnapshot,
+  absolutePath: string,
+) {
+  const path = yield* Path.Path;
+  const projectsById = new Map(snapshot.projects.map((project) => [project.id, project]));
+  const workspaceRoots = new Map(
+    snapshot.projects.map(
+      (project) => [project.id, path.normalize(project.workspaceRoot)] as const,
+    ),
+  );
+  const candidates: Array<{
+    readonly project: OrchestrationProjectShell;
+    readonly matchPath: string;
+    readonly workspaceRoot: string;
+    readonly source: "worktree" | "project";
+  }> = [];
+
+  for (const thread of snapshot.threads) {
+    if (thread.worktreePath === null) {
+      continue;
+    }
+    const project = projectsById.get(thread.projectId);
+    if (project === undefined) {
+      continue;
+    }
+    const workspaceRoot = workspaceRoots.get(thread.projectId);
+    if (workspaceRoot === undefined) {
+      continue;
+    }
+    const matchPath = path.normalize(thread.worktreePath);
+    if (!(yield* isDescendantPath(matchPath, absolutePath))) {
+      continue;
+    }
+    candidates.push({
+      project,
+      matchPath,
+      workspaceRoot,
+      source: "worktree",
+    });
+  }
+
+  for (const project of snapshot.projects) {
+    const workspaceRoot = workspaceRoots.get(project.id);
+    if (workspaceRoot === undefined) {
+      continue;
+    }
+    if (!(yield* isDescendantPath(workspaceRoot, absolutePath))) {
+      continue;
+    }
+    candidates.push({
+      project,
+      matchPath: workspaceRoot,
+      workspaceRoot,
+      source: "project",
+    });
+  }
+
+  if (candidates.length === 0) {
+    return undefined;
+  }
+
+  candidates.sort((left, right) => {
+    if (left.matchPath.length !== right.matchPath.length) {
+      return right.matchPath.length - left.matchPath.length;
+    }
+    if (left.source === right.source) {
+      return 0;
+    }
+    return left.source === "worktree" ? -1 : 1;
+  });
+
+  const best = candidates[0]!;
+  if (absolutePath === best.matchPath) {
+    if (best.source === "worktree" && best.matchPath !== best.workspaceRoot) {
+      return { project: best.project, inferredWorktreePath: best.matchPath };
+    }
+    return { project: best.project };
+  }
+
+  return { project: best.project, inferredWorktreePath: absolutePath };
+});

package/src/index.ts

@@ -1,92 +1,9 @@
-export { T3Application } from "./application/service.ts";
+export { T3Application } from "./application/index.ts";
 export type {
   SendThreadInput,
   StartThreadInput,
   StartThreadPolicy,
   WaitEvent,
-} from "./application/service.ts";
-export type { ApplicationError } from "./application/error.ts";
-export { T3Auth } from "./auth/service.ts";
-export { T3AuthLive, makeT3Auth } from "./auth/layer.ts";
-export { T3LocalAuth, T3LocalAuthLive, makeT3LocalAuth } from "./auth/local.ts";
-export {
-  T3LocalAuthOrigin,
-  T3LocalAuthOriginLive,
-  makeT3LocalAuthOrigin,
-} from "./auth/local-origin.ts";
-export {
-  T3LocalAuthToken,
-  T3LocalAuthTokenLive,
-  makeT3LocalAuthToken,
-} from "./auth/local-token.ts";
-export {
-  T3AuthPairing,
-  T3AuthPairingLive,
-  makeT3AuthPairing,
-  parsePairingUrl,
-} from "./auth/pairing.ts";
-export {
-  AuthConfigError,
-  AuthLocalDatabaseError,
-  AuthLocalError,
-  AuthLocalSecretError,
-  AuthLocalSigningError,
-  AuthPairingUrlError,
-  AuthTransportError,
-} from "./auth/error.ts";
-export type { AuthError } from "./auth/error.ts";
-export type { AuthSessionState, AuthWebSocketTicketResult } from "./auth/schema.ts";
-export type {
-  AuthConfigInput,
-  AuthSessionRole,
-  LocalAuthInput,
-  LocalAuthOriginInput,
-  LocalAuthResult,
-  LocalAuthTokenInput,
-  LocalAuthTokenResult,
-  PairingUrl,
-  PairResult,
-} from "./auth/type.ts";
-export { T3Config } from "./config/service.ts";
-export type { ResolvedConfig, StoredConfig } from "./config/service.ts";
-export { T3ConfigLive, makeT3Config } from "./config/layer.ts";
-export { ConfigError, UrlError } from "./config/error.ts";
-export type { ConfigServiceError } from "./config/error.ts";
-export {
-  makeT3CodeConnectionProvider,
-  makeT3CodeRpcLayer,
-  T3CodeConnectionProvider,
-  T3CodeConnectionProviderLive,
-  T3CodeNodeRpcLayer,
-  T3CodeRpcLayer,
-  T3CodeConnectionError,
-} from "./connection.ts";
-export type { T3CodeAuth, T3CodeConnection, T3CodeOrigin } from "./connection.ts";
-export { Environment } from "./environment/service.ts";
-export type { EnvironmentShape } from "./environment/service.ts";
-export { NodeEnvironmentLive } from "./environment/layer.ts";
-export {
-  AppLayer,
-  AuthAppLayer,
-  T3AuthLayer,
-  T3AuthPairingLayer,
-  T3AuthTransportLayer,
-  T3LocalAuthLayer,
-  T3LocalAuthOriginLayer,
-  T3LocalAuthTokenLayer,
-} from "./runtime.ts";
-export { SqlClientFactory } from "./sql/service.ts";
-export type { SqlClientFactoryShape, SqliteClientConfig } from "./sql/service.ts";
-export {
-  NodeSqlClientFactoryLive,
-  NodeSqliteClientLive,
-  makeNodeSqliteClient,
-} from "./sql/node-sqlite-client.ts";
-export type {
-  OrchestrationMessage,
-  OrchestrationProjectShell,
-  OrchestrationShellSnapshot,
-  OrchestrationThread,
-  OrchestrationThreadShell,
-  ServerProvider,
-} from "#t3tools/contracts";
+} from "./application/index.ts";
+export type { ApplicationError } from "./application/index.ts";
+export { AppLayer, AuthAppLayer } from "./runtime/index.ts";

package/src/layout/base-dir.ts

@@ -0,0 +1,35 @@
+import { homedir } from "node:os";
+import * as Effect from "effect/Effect";
+import * as Path from "effect/Path";
+
+export type T3Layout = {
+  readonly cwd: string;
+  readonly homeDir: string;
+  readonly t3codeHome?: string | undefined;
+};
+
+export function readT3LayoutFromNodeProcess(): T3Layout {
+  return {
+    cwd: process.cwd(),
+    homeDir: homedir(),
+    t3codeHome: process.env["T3CODE_HOME"],
+  };
+}
+
+export const resolveT3BaseDir = Effect.fn("resolveT3BaseDir")(function* (input: {
+  readonly layout: T3Layout;
+  readonly baseDir?: string | undefined;
+}) {
+  const path = yield* Path.Path;
+  const raw = input.baseDir ?? input.layout.t3codeHome;
+  if (raw === undefined || raw.length === 0) {
+    return path.join(input.layout.homeDir, ".t3");
+  }
+  if (raw === "~") {
+    return input.layout.homeDir;
+  }
+  if (raw.startsWith("~/") || raw.startsWith("~\\")) {
+    return path.join(input.layout.homeDir, raw.slice(2));
+  }
+  return path.resolve(input.layout.cwd, raw);
+});

package/src/layout/index.ts

@@ -0,0 +1 @@
+export { readT3LayoutFromNodeProcess, resolveT3BaseDir, type T3Layout } from "./base-dir.ts";

package/src/orchestration/index.ts

@@ -0,0 +1,7 @@
+export {
+  T3Orchestration,
+  type OpenThread,
+  type Orchestration,
+  type OrchestrationError,
+} from "./service.ts";
+export { T3OrchestrationLayer } from "../runtime/layer.ts";

package/src/rpc/index.ts

@@ -0,0 +1 @@
+export { RpcError, type OrchestrationError } from "./error.ts";

package/src/runtime/index.ts

@@ -0,0 +1,12 @@
+export {
+  AppLayer,
+  AuthAppLayer,
+  T3AuthLayer,
+  T3AuthPairingLayer,
+  T3AuthTransportLayer,
+  T3LocalAuthLayer,
+  T3LocalAuthOriginLayer,
+  T3LocalAuthTokenLayer,
+  T3OrchestrationLayer,
+} from "./layer.ts";
+export { NodeEnvironmentLive } from "../environment/layer.ts";

package/src/{runtime.ts → runtime/layer.ts}

@@ -3,20 +3,20 @@ import * as Layer from "effect/Layer";
 import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
 import * as NodeSocket from "@effect/platform-node/NodeSocket";
 
-import { T3AuthLive } from "./auth/layer.ts";
-import { T3LocalAuthLive } from "./auth/local.ts";
-import { T3LocalAuthOriginLive } from "./auth/local-origin.ts";
-import { T3LocalAuthTokenLive } from "./auth/local-token.ts";
-import { T3AuthPairingLive } from "./auth/pairing.ts";
-import { T3AuthTransportLive } from "./auth/transport.ts";
-import { T3CodeConnectionError } from "./connection/error.ts";
-import { T3CodeConnectionProvider, makeT3CodeConnectionProvider } from "./connection/service.ts";
-import { T3ConfigLive } from "./config/layer.ts";
-import { T3Config } from "./config/service.ts";
-import { T3ApplicationLive } from "./application/layer.ts";
-import { T3OrchestrationLive } from "./orchestration/layer.ts";
-import { T3RpcLive } from "./rpc/layer.ts";
-import { NodeSqlClientFactoryLive } from "./sql/node-sqlite-client.ts";
+import { T3ApplicationLive } from "../application/layer.ts";
+import { T3AuthLive } from "../auth/layer.ts";
+import { T3LocalAuthLive } from "../auth/local.ts";
+import { T3LocalAuthOriginLive } from "../auth/local-origin.ts";
+import { T3LocalAuthTokenLive } from "../auth/local-token.ts";
+import { T3AuthPairingLive } from "../auth/pairing.ts";
+import { T3AuthTransportLive } from "../auth/transport.ts";
+import { T3ConfigLive } from "../config/layer.ts";
+import { T3Config } from "../config/service.ts";
+import { T3CodeConnectionError } from "../connection/error.ts";
+import { T3CodeConnectionProvider, makeT3CodeConnectionProvider } from "../connection/service.ts";
+import { T3OrchestrationLive } from "../orchestration/layer.ts";
+import { T3RpcLive } from "../rpc/layer.ts";
+import { NodeSqlClientFactoryLive } from "../sql/node-sqlite-client.ts";
 
 export const T3AuthTransportLayer = T3AuthTransportLive.pipe(
   Layer.provide(NodeHttpClient.layerUndici),
@@ -65,7 +65,7 @@ const T3RpcLayer = T3RpcLive.pipe(
     ),
   ),
 );
-const T3OrchestrationLayer = T3OrchestrationLive.pipe(Layer.provide(T3RpcLayer));
+export const T3OrchestrationLayer = T3OrchestrationLive.pipe(Layer.provide(T3RpcLayer));
 const T3ApplicationLayer = T3ApplicationLive.pipe(Layer.provide(T3OrchestrationLayer));
 
 export const AuthAppLayer = Layer.mergeAll(T3ConfigLive, T3AuthLayer);

package/src/scope/index.ts

@@ -0,0 +1,6 @@
+export {
+  resolveCommandProjectRef,
+  resolveProjectRef,
+  resolveThreadId,
+  resolveWorktreePath,
+} from "./resolve.ts";

package/src/scope/resolve.ts

@@ -0,0 +1,62 @@
+export function resolveProjectRef(input: {
+  readonly value: string | undefined;
+  readonly env: Readonly<Record<string, string | undefined>>;
+}): string | undefined {
+  if (input.value !== undefined && input.value.length > 0) {
+    return input.value;
+  }
+  const fromRoot = input.env.T3CODE_PROJECT_ROOT;
+  if (fromRoot !== undefined && fromRoot.length > 0) {
+    return fromRoot;
+  }
+  const fromId = input.env.T3CODE_PROJECT_ID;
+  if (fromId !== undefined && fromId.length > 0) {
+    return fromId;
+  }
+  return undefined;
+}
+
+export function resolveCommandProjectRef(input: {
+  readonly value: string | undefined;
+  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly cwd: string;
+  readonly isLocal?: boolean;
+}): string | undefined {
+  const explicit = resolveProjectRef({ value: input.value, env: input.env });
+  if (explicit !== undefined) {
+    return explicit;
+  }
+  if (input.isLocal ?? false) {
+    return input.cwd;
+  }
+  return undefined;
+}
+
+export function resolveWorktreePath(input: {
+  readonly value: string | undefined;
+  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly inferred?: string;
+}): string | undefined {
+  if (input.value !== undefined && input.value.length > 0) {
+    return input.value;
+  }
+  const fromEnv = input.env.T3CODE_WORKTREE_PATH;
+  if (fromEnv !== undefined && fromEnv.length > 0) {
+    return fromEnv;
+  }
+  return input.inferred;
+}
+
+export function resolveThreadId(input: {
+  readonly value: string | undefined;
+  readonly env: Readonly<Record<string, string | undefined>>;
+}): string | undefined {
+  if (input.value !== undefined && input.value.length > 0) {
+    return input.value;
+  }
+  const fromEnv = input.env.T3CODE_THREAD_ID;
+  if (fromEnv !== undefined && fromEnv.length > 0) {
+    return fromEnv;
+  }
+  return undefined;
+}

package/src/t3tools/index.ts

@@ -0,0 +1 @@
+export * from "#t3tools/contracts";