t3code-cli 0.6.0 → 0.8.0

package/src/domain/helpers.ts

@@ -11,27 +11,20 @@ export const resolveProjectScope = Effect.fn("resolveProjectScope")(function* (
   snapshot: OrchestrationShellSnapshot,
   input: {
     readonly ref: string;
-    readonly cwd: string;
   },
 ) {
-  const absoluteRef = yield* resolveAbsolutePath(input.ref, input.cwd);
+  const path = yield* Path.Path;
 
   const byId = findProjectById(snapshot, input.ref);
   if (byId !== null) {
     return { project: byId };
   }
 
-  const byExactPath = yield* findProjectByWorkspaceRoot(snapshot, absoluteRef, input.cwd);
-  if (byExactPath !== undefined) {
-    return { project: byExactPath };
-  }
-
-  const byAncestor = yield* findProjectByAncestorPath(snapshot, absoluteRef, input.cwd);
-  if (byAncestor !== undefined) {
-    return byAncestor;
+  if (!path.isAbsolute(input.ref)) {
+    return undefined;
   }
 
-  return yield* findProjectByKnownWorktreePath(snapshot, absoluteRef, input.cwd);
+  return yield* findProjectByPathPriority(snapshot, path.normalize(input.ref));
 });
 
 export function findProjectById(
@@ -41,11 +34,6 @@ export function findProjectById(
   return snapshot.projects.find((project) => project.id === projectId) ?? null;
 }
 
-const resolveAbsolutePath = Effect.fn("resolveAbsolutePath")(function* (ref: string, cwd: string) {
-  const path = yield* Path.Path;
-  return path.isAbsolute(ref) ? path.normalize(ref) : path.normalize(path.resolve(cwd, ref));
-});
-
 const isDescendantPath = Effect.fn("isDescendantPath")(function* (parent: string, child: string) {
   const path = yield* Path.Path;
   if (child === parent) {
@@ -55,61 +43,23 @@ const isDescendantPath = Effect.fn("isDescendantPath")(function* (parent: string
   return relative.length > 0 && !relative.startsWith("..") && !path.isAbsolute(relative);
 });
 
-const findProjectByWorkspaceRoot = Effect.fn("findProjectByWorkspaceRoot")(function* (
-  snapshot: OrchestrationShellSnapshot,
-  absolutePath: string,
-  cwd: string,
-) {
-  for (const project of snapshot.projects) {
-    const workspaceRoot = yield* resolveAbsolutePath(project.workspaceRoot, cwd);
-    if (workspaceRoot === absolutePath) {
-      return project;
-    }
-  }
-  return undefined;
-});
-
-const findProjectByAncestorPath = Effect.fn("findProjectByAncestorPath")(function* (
+const findProjectByPathPriority = Effect.fn("findProjectByPathPriority")(function* (
   snapshot: OrchestrationShellSnapshot,
   absolutePath: string,
-  cwd: string,
-) {
-  let bestProject: OrchestrationProjectShell | undefined;
-  let bestWorkspaceRoot = "";
-
-  for (const project of snapshot.projects) {
-    const workspaceRoot = yield* resolveAbsolutePath(project.workspaceRoot, cwd);
-    if (!(yield* isDescendantPath(workspaceRoot, absolutePath))) {
-      continue;
-    }
-    if (workspaceRoot.length > bestWorkspaceRoot.length) {
-      bestProject = project;
-      bestWorkspaceRoot = workspaceRoot;
-    }
-  }
-
-  if (bestProject === undefined) {
-    return undefined;
-  }
-
-  if (absolutePath === bestWorkspaceRoot) {
-    return { project: bestProject };
-  }
-
-  return {
-    project: bestProject,
-    inferredWorktreePath: absolutePath,
-  };
-});
-
-const findProjectByKnownWorktreePath = Effect.fn("findProjectByKnownWorktreePath")(function* (
-  snapshot: OrchestrationShellSnapshot,
-  absolutePath: string,
-  cwd: string,
 ) {
+  const path = yield* Path.Path;
   const projectsById = new Map(snapshot.projects.map((project) => [project.id, project]));
-  let bestProject: OrchestrationProjectShell | undefined;
-  let bestKnownPath = "";
+  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) {
@@ -119,33 +69,59 @@ const findProjectByKnownWorktreePath = Effect.fn("findProjectByKnownWorktreePath
     if (project === undefined) {
       continue;
     }
-    const knownPath = yield* resolveAbsolutePath(thread.worktreePath, cwd);
-    if (!(yield* isDescendantPath(knownPath, absolutePath))) {
+    const workspaceRoot = workspaceRoots.get(thread.projectId);
+    if (workspaceRoot === undefined) {
       continue;
     }
-    if (knownPath.length > bestKnownPath.length) {
-      bestProject = project;
-      bestKnownPath = knownPath;
+    const matchPath = path.normalize(thread.worktreePath);
+    if (!(yield* isDescendantPath(matchPath, absolutePath))) {
+      continue;
     }
+    candidates.push({
+      project,
+      matchPath,
+      workspaceRoot,
+      source: "worktree",
+    });
   }
 
-  if (bestProject === undefined) {
-    return undefined;
+  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",
+    });
   }
 
-  const workspaceRoot = yield* resolveAbsolutePath(bestProject.workspaceRoot, cwd);
-  if (absolutePath === workspaceRoot) {
-    return { project: bestProject };
+  if (candidates.length === 0) {
+    return undefined;
   }
 
-  if (absolutePath === bestKnownPath) {
-    return bestKnownPath === workspaceRoot
-      ? { project: bestProject }
-      : { project: bestProject, inferredWorktreePath: bestKnownPath };
+  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: bestProject,
-    inferredWorktreePath: absolutePath,
-  };
+  return { project: best.project, inferredWorktreePath: absolutePath };
 });

package/src/runtime/layer.ts

@@ -17,6 +17,7 @@ import { T3CodeConnectionProvider, makeT3CodeConnectionProvider } from "../conne
 import { T3OrchestrationLive } from "../orchestration/layer.ts";
 import { T3RpcLive } from "../rpc/layer.ts";
 import { NodeSqlClientFactoryLive } from "../sql/node-sqlite-client.ts";
+import { NodeCliPathLayer } from "../cli-path/layer.ts";
 
 export const T3AuthTransportLayer = T3AuthTransportLive.pipe(
   Layer.provide(NodeHttpClient.layerUndici),
@@ -76,4 +77,5 @@ export const AppLayer = Layer.mergeAll(
   T3RpcLayer,
   T3OrchestrationLayer,
   T3ApplicationLayer,
+  NodeCliPathLayer,
 );