refactor(intent): add shared project context resolver for validate and edit-package-json

.changeset/busy-peas-fail.md

@@ -0,0 +1,5 @@
+---
+'@tanstack/intent': patch
+---
+
+Fix workspace package discovery for nested glob patterns, including support for `*` and `**`. Workspace patterns and resolved package roots are now normalized, deduped, and sorted, and the shared resolver has been extracted for reuse by internal workspace scanning.

.changeset/red-regions-shine.md

@@ -0,0 +1,5 @@
+---
+'@tanstack/intent': patch
+---
+
+Refactor @tanstack/intent to use a shared project context resolver for workspace and package detection. This fixes monorepo targeting bugs in validate and edit-package-json, including pnpm workspaces defined only by pnpm-workspace.yaml.

packages/intent/src/cli-support.ts

@@ -60,7 +60,7 @@ export async function resolveStaleTargets(
   }
 
   const { findPackagesWithSkills, findWorkspaceRoot } =
-    await import('./setup.js')
+    await import('./workspace-patterns.js')
   const workspaceRoot = findWorkspaceRoot(resolvedRoot)
   if (workspaceRoot) {
     const packageDirs = findPackagesWithSkills(workspaceRoot)

packages/intent/src/commands/validate.ts

@@ -1,7 +1,11 @@
 import { existsSync, readFileSync } from 'node:fs'
-import { dirname, join, relative, sep } from 'node:path'
+import { join, relative, resolve, sep } from 'node:path'
 import { fail } from '../cli-error.js'
 import { printWarnings } from '../cli-support.js'
+import {
+  type ProjectContext,
+  resolveProjectContext,
+} from '../core/project-context.js'
 
 interface ValidationError {
   file: string
@@ -28,27 +32,10 @@ function buildValidationFailure(
   return lines.join('\n')
 }
 
-function isInsideMonorepo(root: string): boolean {
-  let dir = join(root, '..')
-  for (let i = 0; i < 5; i++) {
-    const parentPkg = join(dir, 'package.json')
-    if (existsSync(parentPkg)) {
-      try {
-        const parent = JSON.parse(readFileSync(parentPkg, 'utf8'))
-        return Array.isArray(parent.workspaces) || parent.workspaces?.packages
-      } catch {
-        return false
-      }
-    }
-    const next = dirname(dir)
-    if (next === dir) break
-    dir = next
-  }
-  return false
-}
+function collectPackagingWarnings(context: ProjectContext): Array<string> {
+  if (!context.packageRoot || !context.targetPackageJsonPath) return []
 
-function collectPackagingWarnings(root: string): Array<string> {
-  const pkgJsonPath = join(root, 'package.json')
+  const pkgJsonPath = context.targetPackageJsonPath
   if (!existsSync(pkgJsonPath)) return []
 
   let pkgJson: Record<string, unknown>
@@ -81,9 +68,7 @@ function collectPackagingWarnings(root: string): Array<string> {
 
     // In monorepos, _artifacts lives at repo root, not under packages —
     // the negation pattern is a no-op and shouldn't be added.
-    const isMonorepoPkg = isInsideMonorepo(root)
-
-    if (!isMonorepoPkg && !files.includes('!skills/_artifacts')) {
+    if (!context.isMonorepo && !files.includes('!skills/_artifacts')) {
       warnings.push(
         '"!skills/_artifacts" is not in the "files" array — artifacts will be published unnecessarily',
       )
@@ -93,31 +78,17 @@ function collectPackagingWarnings(root: string): Array<string> {
   return warnings
 }
 
-function resolvePackageRoot(startDir: string): string {
-  let dir = startDir
-
-  while (true) {
-    if (existsSync(join(dir, 'package.json'))) {
-      return dir
-    }
-
-    const next = dirname(dir)
-    if (next === dir) {
-      return startDir
-    }
-
-    dir = next
-  }
-}
-
 export async function runValidateCommand(dir?: string): Promise<void> {
   const [{ parse: parseYaml }, { findSkillFiles }] = await Promise.all([
     import('yaml'),
     import('../utils.js'),
   ])
   const targetDir = dir ?? 'skills'
-  const skillsDir = join(process.cwd(), targetDir)
-  const packageRoot = resolvePackageRoot(skillsDir)
+  const context = resolveProjectContext({
+    cwd: process.cwd(),
+    targetPath: targetDir,
+  })
+  const skillsDir = context.targetSkillsDir ?? resolve(process.cwd(), targetDir)
 
   if (!existsSync(skillsDir)) {
     fail(`Skills directory not found: ${skillsDir}`)
@@ -197,8 +168,9 @@ export async function runValidateCommand(dir?: string): Promise<void> {
     }
   }
 
+  // In monorepos, _artifacts lives at the workspace root, not under each package's skills/ dir.
   const artifactsDir = join(skillsDir, '_artifacts')
-  if (existsSync(artifactsDir)) {
+  if (!context.isMonorepo && existsSync(artifactsDir)) {
     const requiredArtifacts = [
       'domain_map.yaml',
       'skill_spec.md',
@@ -238,7 +210,7 @@ export async function runValidateCommand(dir?: string): Promise<void> {
     }
   }
 
-  const warnings = collectPackagingWarnings(packageRoot)
+  const warnings = collectPackagingWarnings(context)
 
   if (errors.length > 0) {
     fail(buildValidationFailure(errors, warnings))

packages/intent/src/core/project-context.ts

@@ -0,0 +1,104 @@
+import { existsSync, statSync } from 'node:fs'
+import { dirname, join, relative, resolve } from 'node:path'
+import {
+  findWorkspaceRoot,
+  readWorkspacePatterns,
+} from '../workspace-patterns.js'
+
+export type ProjectContext = {
+  cwd: string
+  workspaceRoot: string | null
+  packageRoot: string | null
+  isMonorepo: boolean
+  workspacePatterns: Array<string>
+  targetPackageJsonPath: string | null
+  targetSkillsDir: string | null
+}
+
+/**
+ * Resolves project structure by walking up from targetPath (or cwd) to find the
+ * owning package.json, then searches for a workspace root from the package root.
+ * Falls back to searching from cwd when targetPath points deep into a package.
+ */
+export function resolveProjectContext({
+  cwd,
+  targetPath,
+}: {
+  cwd: string
+  targetPath?: string
+}): ProjectContext {
+  const resolvedCwd = resolve(cwd)
+  const resolvedTargetPath = targetPath
+    ? resolve(resolvedCwd, targetPath)
+    : resolvedCwd
+  const packageRoot = findOwningPackageRoot(resolvedTargetPath)
+  const workspaceRoot =
+    findWorkspaceRoot(packageRoot ?? resolvedTargetPath) ??
+    findWorkspaceRoot(resolvedCwd)
+  const workspacePatterns = workspaceRoot
+    ? (readWorkspacePatterns(workspaceRoot) ?? [])
+    : []
+
+  return {
+    cwd: resolvedCwd,
+    workspaceRoot,
+    packageRoot,
+    isMonorepo: workspaceRoot !== null,
+    workspacePatterns,
+    targetPackageJsonPath: packageRoot
+      ? join(packageRoot, 'package.json')
+      : null,
+    targetSkillsDir: resolveTargetSkillsDir(resolvedTargetPath, packageRoot),
+  }
+}
+
+function findOwningPackageRoot(startPath: string): string | null {
+  let dir = toSearchDir(startPath)
+
+  while (true) {
+    if (existsSync(join(dir, 'package.json'))) {
+      return dir
+    }
+
+    const next = dirname(dir)
+    if (next === dir) {
+      return null
+    }
+
+    dir = next
+  }
+}
+
+function toSearchDir(path: string): string {
+  if (!existsSync(path)) {
+    return path
+  }
+
+  return statSync(path).isDirectory() ? path : dirname(path)
+}
+
+function resolveTargetSkillsDir(
+  targetPath: string,
+  packageRoot: string | null,
+): string | null {
+  if (!packageRoot) {
+    return null
+  }
+
+  const packageSkillsDir = join(packageRoot, 'skills')
+
+  if (isWithinOrEqual(targetPath, packageSkillsDir)) {
+    return packageSkillsDir
+  }
+
+  if (targetPath === packageRoot && existsSync(packageSkillsDir)) {
+    return packageSkillsDir
+  }
+
+  return null
+}
+
+function isWithinOrEqual(path: string, parentDir: string): boolean {
+  const rel = relative(parentDir, path)
+  return rel === '' || (!rel.startsWith('..') && !rel.startsWith('/'))
+}

packages/intent/src/scanner.ts

@@ -11,7 +11,7 @@ import {
   findWorkspaceRoot,
   readWorkspacePatterns,
   resolveWorkspacePackages,
-} from './setup.js'
+} from './workspace-patterns.js'
 import type {
   InstalledVariant,
   IntentConfig,