@banbolee/dsh-lsp-diagnostics 0.1.1 → 0.1.2

package/README.md

@@ -2,9 +2,10 @@
 
 Host-plane Cordis bundle plugin for DeepSeek Harness: after an official
 `write`/`edit`/`str_replace_editor` mutation lands inside the session
-workspace, the tool result still succeeds and the next model inference carries
-a single persistent LSP diagnostics plugin notice. It also registers the
-model-callable `lsp_diagnostics(file_path)` tool for explicit diagnosis.
+workspace, or inside a marker-rooted sibling worktree/project, the tool result
+still succeeds and the next model inference carries a single persistent LSP
+diagnostics plugin notice. It also registers the model-callable
+`lsp_diagnostics(file_path)` tool for explicit diagnosis.
 
 The plugin is a named namespace function plugin: it exports `name`, `inject`,
 `Config`, and `apply`, and has no default export. The real Loader reads the
@@ -16,7 +17,13 @@ monkey-patches official objects.
 
 ## Usage
 
-Install the bundle into any DSH profile from the repository root. The
+**Install from npm (recommended)** — no clone needed:
+
+```sh
+dsh plugin --profile <name> add @banbolee/dsh-lsp-diagnostics
+```
+
+For local development, install the bundle into any DSH profile from the repository root. The
 workspace-root flag `-w` is required: without it pnpm cannot resolve the local
 package inside the profile's generated workspace.
 
@@ -59,20 +66,22 @@ deviation from the closed extension route fail loud at load time.
 | `servers` | TypeScript + Go | Closed provider catalog; TypeScript and Go are enabled by default, while `clangd`, `rust`, and `python` are opt-in. |
 
 The extension route is closed: `.ts` → typescript/typescript, `.tsx` →
-typescript/typescriptreact, `.go` → go/go, `.c` → clangd/c,
-`.cc`/`.cpp`/`.cxx` → clangd/cpp, `.h`/`.hh`/`.hpp`/`.hxx` → clangd/cpp,
-`.rs` → rust/rust, and `.py`/`.pyi` → python/python; any other extension key,
-missing canonical provider entry, cross-provider collision, or rewritten
-language id fails loud at load time, while other extensions at runtime are
-silently ignored.
+typescript/typescriptreact, optional explicit `.js` → typescript/javascript,
+`.go` → go/go, `.c` → clangd/c, `.cc`/`.cpp`/`.cxx` → clangd/cpp,
+`.h`/`.hh`/`.hpp`/`.hxx` → clangd/cpp, `.rs` → rust/rust, and
+`.py`/`.pyi` → python/python; any other extension key, missing canonical
+provider entry, cross-provider collision, or rewritten language id fails loud at
+load time, while other extensions at runtime are silently ignored.
 
 The `servers` block is a provider-level partial overlay: omitting `servers` or
 supplying `servers: {}` keeps exactly the TypeScript and Go defaults, while
 supplying a known optional `clangd`, `rust`, or `python` key activates that
 provider. For example, `servers: { go: { command: '/path/trae-gopls' } }`
 changes only Go without requiring a TypeScript block. The legacy
-`extensionToLanguage` field is accepted only when it exactly equals that
-provider's canonical mapping; it never defines new routes.
+`extensionToLanguage` field is accepted only when it contains that provider's
+canonical mapping and only supported provider-owned extras. `.js` is accepted
+for compatibility with explicit TypeScript configs, but it is not enabled by
+default.
 
 Default commands are `typescript-language-server --stdio`, `gopls`, `clangd`,
 `rust-analyzer`, and `pyright-langserver --stdio`. clangd, rust-analyzer, and
@@ -81,13 +90,16 @@ gopls receive no default arguments. Per-server `env`, `configuration`, and
 
 ## Behavior
 
-Only a non-empty `session.header.cwd` that canonicalizes to a directory and
-contains the target is eligible; missing or empty cwd, non-directory
-canonicalization, and outside-workspace targets are ineligible and silently
-ignored — never a `workspace unavailable` or `outside workspace` notice.
-Workspace, cwd, and URI are always derived through the public `ctx.fs` API
-(`resolve`/`stat`/`contains`/`targetKey`/`processPath`/`fileUrl`), never from
-`displayPath` or the host `process.cwd()`.
+A non-empty `session.header.cwd` that canonicalizes to a directory is required.
+Automatic feedback first keeps the old behavior for targets contained by that
+workspace; targets outside it are eligible only when a target-local `.git` file
+or directory identifies their own git worktree root. Missing or empty cwd,
+non-directory canonicalization, and outside targets without a marker-rooted
+git worktree are silently ignored — never a `workspace unavailable` or
+`outside workspace` notice. Workspace, cwd, and URI are always
+derived through the public `ctx.fs` API (`resolve`/`stat`/`contains`/`targetKey`/
+`processPath`/`fileUrl`), never from raw `displayPath` or the host
+`process.cwd()`.
 
 Fail-open is plugin-owned post-processing failure only: after the downstream
 `await next()` decision succeeded, a diagnostics error, missing or crashed
@@ -187,13 +199,14 @@ natural-close wait → conditional `handle.terminate()` (only while still alive)
 existing file that `ctx.fs` permits the session to read. It accepts a
 workspace-relative or absolute path and uses every configured provider and the
 closed extension route documented above. It has the same path authority as the
-official `read` tool: the session cwd is only the LSP project root, so an
-explicit direct call may diagnose a readable file outside that root. It never
-creates, edits, or deletes a file. Invalid requests fail explicitly with
-`file_path must be a non-empty string`, `session workspace cwd`, `session
-workspace is not an existing directory`, `target does not exist`, `target is
-not a regular file`, `no configured diagnostics provider`, or `target changed
-during diagnosis`.
+official `read` tool: for files contained by `session.header.cwd`, that cwd
+remains the LSP project root; for a readable file outside the session cwd, the
+tool prefers the target's marker-rooted project/worktree root and then falls
+back to the session cwd. It never creates, edits, or deletes a file. Invalid
+requests fail explicitly with `file_path must be a non-empty string`, `session
+workspace cwd`, `session workspace is not an existing directory`, `target does
+not exist`, `target is not a regular file`, `no configured diagnostics
+provider`, or `target changed during diagnosis`.
 
 The direct tool has exactly three canonical outcomes: `diagnostics` with the
 normalized list sorted by the same comparator as automatic rendering and sliced
@@ -231,13 +244,13 @@ unavailable`.
 - shell redirection, `sed -i`, scripts, formatters, generators, and external
   editors that bypass `ctx.fs`/`fs/observed` are out of scope for automatic
   feedback; the model may call `lsp_diagnostics(file_path)` afterward. There is no
-  filesystem watcher and no project-root probing — the session cwd is the
-  workspace root.
+  filesystem watcher; project-root probing is marker-based and only runs for
+  supported source files.
 - For automatic feedback, agentless tool execution, missing/empty or
-  non-directory cwd, and outside-workspace targets are silently out of scope
-  and never produce a notice. Direct calls use official `read`-equivalent path
-  authority instead: a readable file outside the session cwd is eligible, while
-  that cwd remains the LSP project root.
+  non-directory cwd, and outside targets without a marker-rooted git worktree are
+  silently out of scope and never produce a notice. Direct calls use official
+  `read`-equivalent path authority instead: a readable file outside the session
+  cwd is eligible, using its marker-rooted project/worktree root when available.
 - The plugin does not install or download `typescript-language-server`,
   `gopls`, `clangd`, `rust-analyzer`, or `pyright-langserver`; install requested
   executables yourself and configure their paths. A missing server fails open

package/coordinator.js

@@ -17,13 +17,14 @@
 
 import { boundContextSummary, createUserMessage } from '@deepseek-ai/dsh-llm'
 import { compareEligibleTargets, renderDiagnostics, sanitizeDisplayPath } from './render.js'
+import { resolveWorkspaceRoot } from './workspace-root.js'
 
 /**
  * Loose structural seams, mirroring the runtime's own public shapes. The
  * coordinator only consumes the documented surface (`take/isCurrent/
  * retireIfCurrent`, `diagnose/stopAdmission/dispose`, `resolve/stat/
- * contains/fileUrl`); keeping these structural keeps both the real services
- * and the deterministic test fakes assignable.
+ * contains/fileUrl/processPath`); keeping these structural keeps both the real
+ * services and the deterministic test fakes assignable.
  * @typedef {object} CollectorSeam
  * @property {(exec: any, target: any, observation: any) => void} observe
  * @property {(exec: any) => import('./collector.js').MutationCandidate[]} take
@@ -44,6 +45,7 @@ import { compareEligibleTargets, renderDiagnostics, sanitizeDisplayPath } from '
  * @property {(target: any, signal?: AbortSignal) => Promise<{ version: string, type: string, size?: number } | undefined>} stat
  * @property {(parent: any, child: any) => boolean} contains
  * @property {(target: any) => string} fileUrl
+ * @property {(target: any) => string} processPath
  */
 
 /**
@@ -382,10 +384,12 @@ export function createDiagnosticsCoordinator({ collector, runtime, config, fs, n
         retireAll()
         return decision
       }
-      // 2. Workspace root from the session header; missing/empty is ineligible.
+      // 2. Canonicalize the session workspace once. Files inside it keep the
+      // original behavior; files outside it may still resolve to their own
+      // project/worktree root.
       const execRecord = /** @type {{ agent?: { session?: { header?: { cwd?: unknown } } } }} */ (exec)
-      const workspaceRoot = execRecord?.agent?.session?.header?.cwd
-      if (typeof workspaceRoot !== 'string' || workspaceRoot.length === 0) {
+      const sessionRoot = execRecord?.agent?.session?.header?.cwd
+      if (typeof sessionRoot !== 'string' || sessionRoot.length === 0) {
         retireAll()
         return decision
       }
@@ -393,10 +397,9 @@ export function createDiagnosticsCoordinator({ collector, runtime, config, fs, n
         retireAll()
         return decision
       }
-      // 3. Canonicalize the workspace exactly once.
-      let workspaceTarget
+      let sessionWorkspace
       try {
-        workspaceTarget = await fs.resolve(workspaceRoot, { signal })
+        sessionWorkspace = await fs.resolve(sessionRoot, { signal })
       } catch {
         retireAll()
         return decision
@@ -405,9 +408,9 @@ export function createDiagnosticsCoordinator({ collector, runtime, config, fs, n
         retireAll()
         return decision
       }
-      let workspaceInfo
+      let sessionWorkspaceInfo
       try {
-        workspaceInfo = await fs.stat(workspaceTarget, signal)
+        sessionWorkspaceInfo = await fs.stat(sessionWorkspace, signal)
       } catch {
         retireAll()
         return decision
@@ -416,26 +419,43 @@ export function createDiagnosticsCoordinator({ collector, runtime, config, fs, n
         retireAll()
         return decision
       }
-      if (workspaceInfo === undefined || workspaceInfo.type !== 'directory') {
+      if (sessionWorkspaceInfo === undefined || sessionWorkspaceInfo.type !== 'directory') {
         retireAll()
         return decision
       }
-      // 4. Per-target eligibility: contains with pre/post abort checks, then
-      // freeze renderPath + canonicalUri exactly once. Every early exit and
-      // abort break retires the remaining taken candidates.
-      /** @type {{ candidate: import('./collector.js').MutationCandidate, renderPath: string, targetKey: string, canonicalUri: string }[]} */
+      // 3. Per-target eligibility: use session cwd when it contains the target;
+      // otherwise resolve the LSP workspace from target-local markers
+      // (go.mod/.git/package markers). Then freeze renderPath + canonicalUri.
+      /** @type {{ candidate: import('./collector.js').MutationCandidate, workspaceTarget: any, renderPath: string, targetKey: string, canonicalUri: string }[]} */
       const eligible = []
       for (const route of routed) {
         const { candidate, canonicalUri } = route
         if (signal.aborted) break
         let contained = false
         try {
-          contained = fs.contains(workspaceTarget, candidate.target) === true
+          contained = fs.contains(sessionWorkspace, candidate.target) === true
         } catch {
           contained = false
         }
         if (signal.aborted) break
-        if (!contained) {
+        let workspaceTarget = contained ? sessionWorkspace : undefined
+        if (workspaceTarget === undefined) {
+          try {
+            workspaceTarget = await resolveWorkspaceRoot({
+              fs,
+              target: candidate.target,
+              extension: extensionOf(canonicalUri),
+              sessionRoot,
+              signal,
+              sessionFallback: 'never',
+              markerMode: 'git',
+            })
+          } catch {
+            workspaceTarget = undefined
+          }
+        }
+        if (signal.aborted) break
+        if (workspaceTarget === undefined) {
           collector.retireIfCurrent(candidate)
           continue
         }
@@ -448,6 +468,7 @@ export function createDiagnosticsCoordinator({ collector, runtime, config, fs, n
         }
         eligible.push({
           candidate,
+          workspaceTarget,
           renderPath,
           targetKey: String(candidate.target.targetKey ?? ''),
           canonicalUri,
@@ -470,7 +491,7 @@ export function createDiagnosticsCoordinator({ collector, runtime, config, fs, n
         /** @type {import('./runtime.js').DiagnosisOutcome} */
         let outcome
         try {
-          outcome = await runtime.diagnose(target.candidate, workspaceTarget, target.canonicalUri, signal)
+          outcome = await runtime.diagnose(target.candidate, target.workspaceTarget, target.canonicalUri, signal)
         } catch (error) {
           if (signal.aborted) break
           // Plugin-owned failure after eligibility: bounded unavailable with

package/index.js

@@ -90,6 +90,7 @@ const DEFAULT_ENABLED_PROVIDERS = Object.freeze(['typescript', 'go'])
  * @type {Readonly<Record<string, Readonly<{ provider: ProviderId, language: string }>>>}
  */
 const CANONICAL_ROUTE = Object.freeze({
+  '.js': Object.freeze({ provider: 'typescript', language: 'javascript' }),
   '.ts': Object.freeze({ provider: 'typescript', language: 'typescript' }),
   '.tsx': Object.freeze({ provider: 'typescript', language: 'typescriptreact' }),
   '.go': Object.freeze({ provider: 'go', language: 'go' }),
@@ -290,11 +291,8 @@ function assertExtensionToLanguage(map, provider) {
   if (defaults === undefined) fail(`provider ${provider} has no catalog defaults`)
   const expected = defaults.extensionToLanguage
   const expectedExtensions = Object.keys(expected)
-  if (
-    routes.size !== expectedExtensions.length
-    || !expectedExtensions.every((extension) => routes.get(extension) === expected[extension])
-  ) {
-    fail(`servers.${provider}.extensionToLanguage must equal the canonical provider mapping`)
+  if (!expectedExtensions.every((extension) => routes.get(extension) === expected[extension])) {
+    fail(`servers.${provider}.extensionToLanguage must include the canonical provider mapping`)
   }
   return Object.fromEntries(routes)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@banbolee/dsh-lsp-diagnostics",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Automatic post-write and model-callable read-only LSP diagnostics for existing files in DeepSeek Harness.",
   "type": "module",
   "main": "index.js",
@@ -16,6 +16,7 @@
     "tool.js",
     "render.js",
     "coordinator.js",
+    "workspace-root.js",
     "cordis.patch.yml",
     "README.md"
   ],

package/tool.js

@@ -1,5 +1,6 @@
 import { defineTool } from '@deepseek-ai/dsh-tools'
 import { compareDiagnostics, sanitizeDisplayPath } from './render.js'
+import { resolveWorkspaceRoot } from './workspace-root.js'
 
 /** Closed runtime reasons exposed by the canonical tool output. */
 const UNAVAILABLE_REASONS = /** @type {const} */ ([
@@ -105,7 +106,9 @@ const OUTPUT_SCHEMA = /** @type {const} */ ({
  * @typedef {object} FsSeam
  * @property {(path: string, opts?: { cwd?: string, signal?: AbortSignal }) => Promise<import('@deepseek-ai/dsh-fs').FsTarget>} resolve
  * @property {(target: import('@deepseek-ai/dsh-fs').FsTarget, signal?: AbortSignal) => Promise<import('@deepseek-ai/dsh-fs').FsInfo | undefined>} stat
+ * @property {(parent: import('@deepseek-ai/dsh-fs').FsTarget, child: import('@deepseek-ai/dsh-fs').FsTarget) => boolean} contains
  * @property {(target: import('@deepseek-ai/dsh-fs').FsTarget) => string} fileUrl
+ * @property {(target: import('@deepseek-ai/dsh-fs').FsTarget) => string} processPath
  */
 
 /**
@@ -351,13 +354,13 @@ export function createDiagnosticsTool({ fs, runtime, config, now = () => perform
       let early = abortOutcome(operation)
       if (early !== undefined) return early
       const signal = operation.controller.signal
-      const workspace = await fs.resolve(workspaceRoot, { signal })
+      const sessionWorkspace = await fs.resolve(workspaceRoot, { signal })
       early = abortOutcome(operation)
       if (early !== undefined) return early
-      const workspaceInfo = await fs.stat(workspace, signal)
+      const sessionWorkspaceInfo = await fs.stat(sessionWorkspace, signal)
       early = abortOutcome(operation)
       if (early !== undefined) return early
-      if (workspaceInfo === undefined || workspaceInfo.type !== 'directory') {
+      if (sessionWorkspaceInfo === undefined || sessionWorkspaceInfo.type !== 'directory') {
         throw new Error('lsp_diagnostics: session workspace is not an existing directory')
       }
 
@@ -379,6 +382,28 @@ export function createDiagnosticsTool({ fs, runtime, config, now = () => perform
         const label = extension.length === 0 ? '(none)' : extension
         throw new Error(`lsp_diagnostics: no configured diagnostics provider for extension ${label}`)
       }
+      /** @type {import('@deepseek-ai/dsh-fs').FsTarget | undefined} */
+      let workspace = sessionWorkspace
+      try {
+        if (fs.contains(sessionWorkspace, target) !== true) workspace = undefined
+      } catch {
+        workspace = undefined
+      }
+      if (workspace === undefined) {
+        workspace = await resolveWorkspaceRoot({
+          fs,
+          target,
+          extension,
+          sessionRoot: workspaceRoot,
+          signal,
+          sessionFallback: 'always',
+        })
+      }
+      early = abortOutcome(operation)
+      if (early !== undefined) return early
+      if (workspace === undefined) {
+        throw new Error('lsp_diagnostics: workspace root could not be resolved')
+      }
 
       const outcome = await runtime.diagnoseTarget(
         target,

package/workspace-root.js

@@ -0,0 +1,155 @@
+import { dirname, isAbsolute, join } from 'node:path'
+
+/** @typedef {'always' | 'if-contained' | 'never'} SessionFallback */
+
+/**
+ * @typedef {object} FsSeam
+ * @property {(path: string, opts?: { cwd?: string, signal?: AbortSignal }) => Promise<any>} resolve
+ * @property {(statTarget: any, signal?: AbortSignal) => Promise<{ version: string, type: string, size?: number } | undefined>} stat
+ * @property {(parentTarget: any, childTarget: any) => boolean} contains
+ * @property {(processTarget: any) => string} processPath
+ */
+
+const GO_MARKERS = /** @type {const} */ (['go.work', 'go.mod', '.git'])
+const TYPESCRIPT_MARKERS = /** @type {const} */ (['tsconfig.json', 'jsconfig.json', 'package.json', '.git'])
+const DEFAULT_MARKERS = /** @type {const} */ (['.git'])
+
+/**
+ * Return project markers for the already-routed source extension.
+ * @param {string} extension
+ * @returns {readonly string[]}
+ */
+function markersForExtension(extension) {
+  if (extension === '.go') return GO_MARKERS
+  if (extension === '.ts' || extension === '.tsx') return TYPESCRIPT_MARKERS
+  return DEFAULT_MARKERS
+}
+
+/**
+ * Stat one marker path. Missing or inaccessible markers are simply not roots.
+ * @param {FsSeam} fs
+ * @param {string} markerPath
+ * @param {AbortSignal | undefined} signal
+ * @returns {Promise<boolean>}
+ */
+async function markerExists(fs, markerPath, signal) {
+  try {
+    if (signal?.aborted) return false
+    const marker = await fs.resolve(markerPath, { signal })
+    if (signal?.aborted) return false
+    const info = await fs.stat(marker, signal)
+    if (signal?.aborted) return false
+    return info?.type === 'file' || info?.type === 'directory'
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Resolve an existing directory root candidate.
+ * @param {FsSeam} fs
+ * @param {string} directory
+ * @param {AbortSignal | undefined} signal
+ * @returns {Promise<any | undefined>}
+ */
+async function resolveDirectory(fs, directory, signal) {
+  try {
+    if (signal?.aborted) return undefined
+    const root = await fs.resolve(directory, { signal })
+    if (signal?.aborted) return undefined
+    const info = await fs.stat(root, signal)
+    if (signal?.aborted) return undefined
+    return info?.type === 'directory' ? root : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Walk from the target's directory to the filesystem root looking for project markers.
+ * @param {FsSeam} fs
+ * @param {string} startDirectory
+ * @param {readonly string[]} markers
+ * @param {AbortSignal | undefined} signal
+ * @returns {Promise<any | undefined>}
+ */
+async function nearestMarkedDirectory(fs, startDirectory, markers, signal) {
+  let directory = startDirectory
+  for (;;) {
+    for (const marker of markers) {
+      if (await markerExists(fs, join(directory, marker), signal)) {
+        return resolveDirectory(fs, directory, signal)
+      }
+    }
+    const parent = dirname(directory)
+    if (parent === directory) return undefined
+    directory = parent
+  }
+}
+
+/**
+ * Resolve the session root fallback and optionally require it to contain target.
+ * @param {FsSeam} fs
+ * @param {string} sessionRoot
+ * @param {any} target
+ * @param {SessionFallback} fallback
+ * @param {AbortSignal | undefined} signal
+ * @returns {Promise<any | undefined>}
+ */
+async function resolveSessionFallback(fs, sessionRoot, target, fallback, signal) {
+  if (fallback === 'never') return undefined
+  if (typeof sessionRoot !== 'string' || sessionRoot.trim().length === 0) return undefined
+  const workspace = await resolveDirectory(fs, sessionRoot, signal)
+  if (workspace === undefined) return undefined
+  if (fallback === 'always') return workspace
+  try {
+    return fs.contains(workspace, target) === true ? workspace : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Resolve the LSP workspace for a target. Prefer a project marker rooted at the
+ * target itself (so sibling git worktrees work), then fall back to the session
+ * workspace according to the caller's policy.
+ *
+ * @param {object} input
+ * @param {FsSeam} input.fs
+ * @param {any} input.target
+ * @param {string} input.extension
+ * @param {string} input.sessionRoot
+ * @param {AbortSignal} [input.signal]
+ * @param {SessionFallback} [input.sessionFallback]
+ * @param {'language' | 'git'} [input.markerMode]
+ * @returns {Promise<any | undefined>}
+ */
+export async function resolveWorkspaceRoot({
+  fs,
+  target,
+  extension,
+  sessionRoot,
+  signal,
+  sessionFallback = 'if-contained',
+  markerMode = 'language',
+}) {
+  if (sessionFallback === 'if-contained') {
+    const sessionWorkspace = await resolveSessionFallback(fs, sessionRoot, target, sessionFallback, signal)
+    if (sessionWorkspace !== undefined) return sessionWorkspace
+  }
+
+  try {
+    if (signal?.aborted) return undefined
+    const targetPath = fs.processPath(target)
+    if (typeof targetPath === 'string' && isAbsolute(targetPath)) {
+      const markers = markerMode === 'git' ? DEFAULT_MARKERS : markersForExtension(extension)
+      const marked = await nearestMarkedDirectory(fs, dirname(targetPath), markers, signal)
+      if (marked !== undefined) return marked
+    }
+  } catch {
+    // Fall through to the configured session fallback.
+  }
+
+  if (sessionFallback === 'if-contained') return undefined
+  return resolveSessionFallback(fs, sessionRoot, target, sessionFallback, signal)
+}