@vibe-forge/workspace-assets 2.0.0 → 2.0.2

package/src/workspace-config.ts

@@ -0,0 +1,132 @@
+import { stat } from 'node:fs/promises'
+
+import type { Config, WorkspaceConfigEntry } from '@vibe-forge/types'
+import { glob } from 'fast-glob'
+
+const DEFAULT_WORKSPACE_IGNORES = [
+  '**/.git/**',
+  '**/.ai/**',
+  '**/node_modules/**'
+]
+
+export interface NormalizedWorkspaceEntry {
+  enabled?: boolean
+  name?: string
+  description?: string
+  path?: string
+  include?: string[]
+  exclude?: string[]
+}
+
+const isRecord = (value: unknown): value is Record<string, unknown> => (
+  value != null && typeof value === 'object' && !Array.isArray(value)
+)
+
+const toStringList = (value: unknown): string[] => {
+  if (typeof value === 'string' && value.trim() !== '') {
+    return [value.trim()]
+  }
+  if (!Array.isArray(value)) return []
+
+  return value
+    .filter((item): item is string => typeof item === 'string' && item.trim() !== '')
+    .map(item => item.trim())
+}
+
+const normalizeWorkspaceEntry = (
+  id: string,
+  value: string | WorkspaceConfigEntry
+): NormalizedWorkspaceEntry | undefined => {
+  if (typeof value === 'string') {
+    return { path: value }
+  }
+
+  if (!isRecord(value)) return undefined
+  const enabled = typeof value.enabled === 'boolean' ? value.enabled : undefined
+  if (enabled === false) return { enabled: false }
+
+  return {
+    enabled,
+    name: typeof value.name === 'string' && value.name.trim() !== '' ? value.name.trim() : id,
+    description: typeof value.description === 'string' && value.description.trim() !== ''
+      ? value.description.trim()
+      : undefined,
+    path: typeof value.path === 'string' && value.path.trim() !== '' ? value.path.trim() : undefined,
+    include: [
+      ...toStringList(value.include),
+      ...toStringList(value.glob),
+      ...toStringList(value.globs)
+    ],
+    exclude: toStringList(value.exclude)
+  }
+}
+
+export const normalizeWorkspaceConfig = (config: Config['workspaces'] | undefined) => {
+  if (config == null) {
+    return {
+      include: [] as string[],
+      exclude: [] as string[],
+      entries: {} as Record<string, NormalizedWorkspaceEntry>
+    }
+  }
+
+  if (typeof config === 'string' || Array.isArray(config)) {
+    return {
+      include: toStringList(config),
+      exclude: [] as string[],
+      entries: {} as Record<string, NormalizedWorkspaceEntry>
+    }
+  }
+
+  if (!isRecord(config)) {
+    return {
+      include: [] as string[],
+      exclude: [] as string[],
+      entries: {} as Record<string, NormalizedWorkspaceEntry>
+    }
+  }
+
+  const entries = Object.fromEntries(
+    Object.entries(config.entries ?? {})
+      .map(([id, value]) => [id, normalizeWorkspaceEntry(id, value)])
+      .filter((entry): entry is [string, NormalizedWorkspaceEntry] => entry[1] != null)
+  )
+
+  return {
+    include: [
+      ...toStringList(config.include),
+      ...toStringList(config.glob),
+      ...toStringList(config.globs)
+    ],
+    exclude: toStringList(config.exclude),
+    entries
+  }
+}
+
+export const isDirectory = async (path: string) => {
+  try {
+    return (await stat(path)).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+export const scanWorkspacePatterns = async (
+  cwd: string,
+  patterns: string[],
+  exclude: string[]
+) => {
+  if (patterns.length === 0) return []
+
+  return await glob(patterns, {
+    cwd,
+    absolute: true,
+    onlyDirectories: true,
+    unique: true,
+    followSymbolicLinks: true,
+    ignore: [
+      ...DEFAULT_WORKSPACE_IGNORES,
+      ...exclude
+    ]
+  })
+}

package/src/workspace-prompt.ts

@@ -0,0 +1,33 @@
+import type { WorkspaceDefinitionPayload } from '@vibe-forge/types'
+import { CANONICAL_VIBE_FORGE_MCP_SERVER_NAME, resolvePromptPath } from '@vibe-forge/utils'
+
+import { buildManagedTaskToolGuidance } from './task-tool-guidance'
+
+export const generateWorkspaceRoutePrompt = (
+  cwd: string,
+  workspaces: WorkspaceDefinitionPayload[]
+) => {
+  if (workspaces.length === 0) return ''
+  const taskToolGuidance = buildManagedTaskToolGuidance(CANONICAL_VIBE_FORGE_MCP_SERVER_NAME)
+
+  const workspaceList = workspaces
+    .map((workspace) => {
+      const description = workspace.description?.trim() || workspace.name?.trim() || workspace.path
+      return (
+        `  - Identifier: ${workspace.id}\n` +
+        `    - Path: ${resolvePromptPath(cwd, workspace.cwd)}\n` +
+        `    - Description: ${description}\n`
+      )
+    })
+    .join('')
+
+  return (
+    '<system-prompt>\n' +
+    'The project includes the following registered workspaces:\n' +
+    `${workspaceList}\n` +
+    `When a user request targets one of these workspaces, start a child task with \`${CANONICAL_VIBE_FORGE_MCP_SERVER_NAME}.StartTasks\` using \`type: "workspace"\` and \`name\` set to the workspace identifier. ` +
+    'Do not directly edit files inside a registered workspace from the current session unless the user explicitly asks this session to work in that directory.\n' +
+    `${taskToolGuidance}\n` +
+    '</system-prompt>\n'
+  )
+}

package/src/workspaces.ts

@@ -0,0 +1,188 @@
+import { basename, resolve } from 'node:path'
+
+import { mergeConfigs } from '@vibe-forge/config'
+import type { Config, WorkspaceAsset } from '@vibe-forge/types'
+import { normalizePath, resolveRelativePath } from '@vibe-forge/utils'
+
+import { isDirectory, normalizeWorkspaceConfig, scanWorkspacePatterns } from './workspace-config'
+
+interface WorkspaceCandidate {
+  preferredId?: string
+  name?: string
+  description?: string
+  cwd: string
+  path: string
+  pattern?: string
+  sourcePath: string
+}
+
+const createWorkspaceAsset = (params: {
+  id: string
+  name?: string
+  description?: string
+  cwd: string
+  path: string
+  pattern?: string
+  sourcePath: string
+}) => ({
+  id: `workspace:workspace:workspace:${params.id}:${params.path}`,
+  kind: 'workspace',
+  name: params.id,
+  displayName: params.id,
+  origin: 'workspace',
+  sourcePath: params.sourcePath,
+  payload: {
+    id: params.id,
+    name: params.name,
+    description: params.description,
+    path: params.path,
+    cwd: params.cwd,
+    pattern: params.pattern
+  }
+} satisfies Extract<WorkspaceAsset, { kind: 'workspace' }>)
+
+const addCandidate = (
+  candidates: Map<string, WorkspaceCandidate>,
+  candidate: WorkspaceCandidate
+) => {
+  const key = normalizePath(candidate.cwd)
+  const existing = candidates.get(key)
+  if (existing == null) {
+    candidates.set(key, candidate)
+    return
+  }
+
+  candidates.set(key, {
+    ...existing,
+    ...candidate,
+    preferredId: candidate.preferredId ?? existing.preferredId,
+    name: candidate.name ?? existing.name,
+    description: candidate.description ?? existing.description
+  })
+}
+
+const assignWorkspaceIds = (candidates: WorkspaceCandidate[]) => {
+  const preferredIds = new Set(
+    candidates
+      .map(candidate => candidate.preferredId)
+      .filter((value): value is string => value != null && value.trim() !== '')
+  )
+  const basenameCounts = candidates.reduce<Map<string, number>>((counts, candidate) => {
+    if (candidate.preferredId != null) return counts
+    const id = basename(candidate.path)
+    counts.set(id, (counts.get(id) ?? 0) + 1)
+    return counts
+  }, new Map())
+  const usedIds = new Set<string>()
+
+  return candidates.map((candidate) => {
+    const preferredId = candidate.preferredId?.trim()
+    if (preferredId != null && preferredId !== '' && !usedIds.has(preferredId)) {
+      usedIds.add(preferredId)
+      return [preferredId, candidate] as const
+    }
+
+    const basenameId = basename(candidate.path)
+    const shouldUsePathId = preferredIds.has(basenameId) || (basenameCounts.get(basenameId) ?? 0) > 1
+    const id = shouldUsePathId ? candidate.path : basenameId
+    const uniqueId = usedIds.has(id) ? candidate.path : id
+    usedIds.add(uniqueId)
+    return [uniqueId, candidate] as const
+  })
+}
+
+export const resolveConfiguredWorkspaceAssets = async (params: {
+  cwd: string
+  configs?: [Config?, Config?]
+}): Promise<Array<Extract<WorkspaceAsset, { kind: 'workspace' }>>> => {
+  const [config, userConfig] = params.configs ?? [undefined, undefined]
+  const mergedConfig = mergeConfigs(config, userConfig)
+  const workspaceConfig = normalizeWorkspaceConfig(mergedConfig?.workspaces)
+  const sourcePath = resolve(params.cwd, '.ai.config.json')
+  const candidates = new Map<string, WorkspaceCandidate>()
+
+  for (const path of await scanWorkspacePatterns(params.cwd, workspaceConfig.include, workspaceConfig.exclude)) {
+    const relativePath = resolveRelativePath(params.cwd, path)
+    if (relativePath === '') continue
+    addCandidate(candidates, {
+      cwd: path,
+      path: relativePath,
+      sourcePath
+    })
+  }
+
+  for (const [id, entry] of Object.entries(workspaceConfig.entries)) {
+    if (entry.enabled === false) continue
+
+    if (entry.path != null) {
+      const workspaceCwd = resolve(params.cwd, entry.path)
+      if (await isDirectory(workspaceCwd)) {
+        addCandidate(candidates, {
+          preferredId: id,
+          name: entry.name,
+          description: entry.description,
+          cwd: workspaceCwd,
+          path: resolveRelativePath(params.cwd, workspaceCwd),
+          sourcePath
+        })
+      }
+    }
+
+    for (
+      const path of await scanWorkspacePatterns(
+        params.cwd,
+        entry.include ?? [],
+        [
+          ...workspaceConfig.exclude,
+          ...(entry.exclude ?? [])
+        ]
+      )
+    ) {
+      const relativePath = resolveRelativePath(params.cwd, path)
+      if (relativePath === '') continue
+      addCandidate(candidates, {
+        name: entry.name,
+        description: entry.description,
+        cwd: path,
+        path: relativePath,
+        pattern: entry.include?.join(', '),
+        sourcePath
+      })
+    }
+  }
+
+  return assignWorkspaceIds(Array.from(candidates.values()))
+    .map(([id, candidate]) =>
+      createWorkspaceAsset({
+        id,
+        name: candidate.name,
+        description: candidate.description,
+        cwd: candidate.cwd,
+        path: candidate.path,
+        pattern: candidate.pattern,
+        sourcePath: candidate.sourcePath
+      })
+    )
+}
+
+export const findWorkspaceAsset = (
+  workspaces: Array<Extract<WorkspaceAsset, { kind: 'workspace' }>>,
+  ref: string
+) => {
+  const normalizedRef = normalizePath(ref.trim())
+  const matches = workspaces.filter(workspace =>
+    workspace.displayName === normalizedRef ||
+    workspace.name === normalizedRef ||
+    workspace.payload.id === normalizedRef ||
+    workspace.payload.path === normalizedRef ||
+    workspace.payload.name === normalizedRef
+  )
+
+  if (matches.length === 0) return undefined
+  if (matches.length > 1) {
+    throw new Error(
+      `Ambiguous workspace reference ${ref}. Candidates: ${matches.map(match => match.displayName).join(', ')}`
+    )
+  }
+  return matches[0]
+}