teamcopilot 0.1.3 → 0.1.4

package/dist/workspace_files/.opencode/plugins/apply-patch-session-diff.ts

@@ -1,3 +1,4 @@
+import fs from "node:fs"
 import path from "node:path"
 import type { Plugin } from "@opencode-ai/plugin"
 
@@ -17,6 +18,8 @@ interface SessionLookupResponse {
   }
 }
 
+type ToolArgs = Record<string, unknown> | undefined
+
 function findPatchPayload(value: unknown): string | null {
   if (typeof value === "string") {
     const normalized = value.replace(/\r\n/g, "\n")
@@ -62,6 +65,118 @@ function extractTrackedPathsFromPatch(patchText: string): string[] {
   return Array.from(new Set(paths.filter((candidate) => candidate.length > 0)))
 }
 
+function findNestedStringByKeys(value: unknown, keys: Set<string>): string | null {
+  if (!value || typeof value !== "object") {
+    return null
+  }
+
+  for (const [key, nestedValue] of Object.entries(value as Record<string, unknown>)) {
+    if (keys.has(key) && typeof nestedValue === "string" && nestedValue.trim().length > 0) {
+      return nestedValue
+    }
+
+    const nestedMatch = findNestedStringByKeys(nestedValue, keys)
+    if (nestedMatch) {
+      return nestedMatch
+    }
+  }
+
+  return null
+}
+
+function tokenizeCommand(command: string): string[] {
+  const tokens = command.match(/"[^"]*"|'[^']*'|&&|\|\||[;|]|[^\s]+/g) ?? []
+  return tokens.map((token) => {
+    if (
+      (token.startsWith("\"") && token.endsWith("\"")) ||
+      (token.startsWith("'") && token.endsWith("'"))
+    ) {
+      return token.slice(1, -1)
+    }
+
+    return token
+  })
+}
+
+const CONTROL_TOKENS = new Set(["&&", "||", ";", "|"])
+
+function resolveExecutionDirectory(rawCwd: unknown, fallbackDirectory: string): string {
+  if (typeof rawCwd !== "string" || rawCwd.trim() === "") {
+    return fallbackDirectory
+  }
+
+  return path.isAbsolute(rawCwd) ? rawCwd : path.resolve(fallbackDirectory, rawCwd)
+}
+
+function resolveTrackedDeleteTargets(command: string, executionDirectory: string): string[] {
+  const tokens = tokenizeCommand(command.trim())
+  if (tokens.length === 0) {
+    return []
+  }
+
+  const resolvedTargets: string[] = []
+  let currentDirectory = executionDirectory
+  let index = 0
+  let atCommandStart = true
+
+  while (index < tokens.length) {
+    const token = tokens[index]
+
+    if (CONTROL_TOKENS.has(token)) {
+      atCommandStart = true
+      index += 1
+      continue
+    }
+
+    if (!atCommandStart) {
+      index += 1
+      continue
+    }
+
+    if (token === "cd") {
+      const destination = tokens[index + 1]
+      if (destination && !CONTROL_TOKENS.has(destination)) {
+        currentDirectory = path.isAbsolute(destination)
+          ? path.resolve(destination)
+          : path.resolve(currentDirectory, destination)
+        index += 2
+      } else {
+        index += 1
+      }
+      atCommandStart = false
+      continue
+    }
+
+    if (path.basename(token) === "rm") {
+      index += 1
+      while (index < tokens.length && !CONTROL_TOKENS.has(tokens[index])) {
+        const candidate = tokens[index]
+        if (candidate === "--" || candidate.startsWith("-")) {
+          index += 1
+          continue
+        }
+
+        const resolvedCandidate = path.isAbsolute(candidate)
+          ? path.resolve(candidate)
+          : path.resolve(currentDirectory, candidate)
+        if (fs.existsSync(resolvedCandidate) && fs.statSync(resolvedCandidate).isDirectory()) {
+          index += 1
+          continue
+        }
+        resolvedTargets.push(resolvedCandidate)
+        index += 1
+      }
+      atCommandStart = false
+      continue
+    }
+
+    atCommandStart = false
+    index += 1
+  }
+
+  return Array.from(new Set(resolvedTargets))
+}
+
 function normalizeRelativePath(rawPath: string, workspaceDir: string): string {
   const trimmed = rawPath.trim()
   if (!trimmed) {
@@ -80,6 +195,14 @@ function normalizeRelativePath(rawPath: string, workspaceDir: string): string {
   return relativePath.split(path.sep).join("/")
 }
 
+function tryNormalizeRelativePath(rawPath: string, workspaceDir: string): string | null {
+  try {
+    return normalizeRelativePath(rawPath, workspaceDir)
+  } catch {
+    return null
+  }
+}
+
 async function readErrorMessageFromResponse(
   response: Response,
   fallbackMessage: string
@@ -104,6 +227,51 @@ async function readErrorMessageFromResponse(
   }
 }
 
+function collectTrackedPathsForTool(
+  tool: string,
+  inputArgs: ToolArgs,
+  outputArgs: ToolArgs,
+  workspaceDir: string
+): string[] {
+  if (tool === "apply_patch") {
+    const patchPayload = findPatchPayload(outputArgs) ?? findPatchPayload(inputArgs)
+    if (!patchPayload) {
+      return []
+    }
+
+    return extractTrackedPathsFromPatch(patchPayload)
+  }
+
+  if (tool === "write") {
+    const filepath =
+      findNestedStringByKeys(outputArgs, new Set(["filepath", "filePath"])) ??
+      findNestedStringByKeys(inputArgs, new Set(["filepath", "filePath"]))
+    if (!filepath) {
+      return []
+    }
+
+    return [filepath]
+  }
+
+  if (tool === "bash") {
+    const command =
+      findNestedStringByKeys(outputArgs, new Set(["command", "cmd", "script", "arguments"])) ??
+      findNestedStringByKeys(inputArgs, new Set(["command", "cmd", "script", "arguments"]))
+    if (!command) {
+      return []
+    }
+
+    const rawCwd =
+      (outputArgs && (outputArgs.workdir ?? outputArgs.cwd)) ??
+      (inputArgs && (inputArgs.workdir ?? inputArgs.cwd))
+    const executionDirectory = resolveExecutionDirectory(rawCwd, workspaceDir)
+
+    return resolveTrackedDeleteTargets(command, executionDirectory)
+  }
+
+  return []
+}
+
 export const ApplyPatchSessionDiffPlugin: Plugin = async ({ client, directory }) => {
   async function resolveRootSessionID(sessionID: string): Promise<string> {
     let currentSessionID = sessionID
@@ -150,24 +318,22 @@ export const ApplyPatchSessionDiffPlugin: Plugin = async ({ client, directory })
 
   return {
     "tool.execute.before": async (input, output) => {
-      if (input.tool !== "apply_patch") {
+      if (!["apply_patch", "write", "bash"].includes(input.tool)) {
         return
       }
 
       const rawSessionID = typeof input.sessionID === "string" ? input.sessionID.trim() : ""
       if (!rawSessionID) {
-        throw new Error("apply_patch hook could not determine session ID.")
+        return
       }
 
       const rootSessionID = await resolveRootSessionID(rawSessionID)
-      const patchPayload = findPatchPayload(output.args) ?? findPatchPayload(input.args)
-      if (!patchPayload) {
-        throw new Error("apply_patch hook could not find patch payload.")
-      }
-
-      const paths = extractTrackedPathsFromPatch(patchPayload)
+      const paths = collectTrackedPathsForTool(input.tool, input.args, output.args, directory)
       for (const candidatePath of paths) {
-        const relativePath = normalizeRelativePath(candidatePath, directory)
+        const relativePath = tryNormalizeRelativePath(candidatePath, directory)
+        if (!relativePath) {
+          continue
+        }
         await captureBaselineForPath(rootSessionID, relativePath)
       }
     },

package/dist/workspace_files/package.json

@@ -4,4 +4,4 @@
   },
   "devDependencies": {},
   "scripts": {}
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamcopilot",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "A shared AI Agent for Teams",
   "homepage": "https://teamcopilot.ai",
   "repository": {