@yuchenrx/pmt-cli 0.1.2

package/src/completion.ts

@@ -0,0 +1,96 @@
+import omelette from 'omelette'
+import { getCliName } from './cli-name'
+import { loadMergedConfig } from './config'
+import { listFiles } from './helpers'
+import { loadPromptRoot } from './prompt-root'
+
+const commands = [
+  'init',
+  'set',
+  'use',
+  'list',
+  'insert',
+  'apply',
+  'link',
+  'search',
+  'open',
+  'open-config',
+  'status',
+]
+
+const scopes = ['project', 'global']
+
+const listPromptNames = async () => {
+  const info = await loadPromptRoot()
+  if (!info) return []
+  const files = await listFiles(info.root)
+  return files.sort()
+}
+
+const listSourceKeys = async () => {
+  const merged = await loadMergedConfig()
+  if (!merged.hasConfig) return []
+  return Object.keys(merged.resolvedSources).sort()
+}
+
+const hasCommand = (line: string, command: string) => line.trim().includes(` ${command}`)
+
+const createCompletion = () => {
+  const cliName = getCliName()
+  const completion = omelette(`${cliName} <command> <arg1> <arg2> <arg3>`)
+
+  completion.on('command', ({ reply }) => {
+    reply(commands)
+  })
+
+  completion.on('arg1', async ({ line, reply }) => {
+    if (hasCommand(line, 'link')) {
+      reply(await listPromptNames())
+      return
+    }
+
+    if (hasCommand(line, 'set') || hasCommand(line, 'use')) {
+      reply(await listSourceKeys())
+      return
+    }
+
+    if (hasCommand(line, 'open') || hasCommand(line, 'open-config')) {
+      reply(scopes)
+      return
+    }
+
+  })
+
+
+  completion.on('arg2', ({ line, reply }) => {
+    if (hasCommand(line, 'set') || hasCommand(line, 'use') || hasCommand(line, 'link')) {
+      reply(scopes)
+    }
+  })
+
+  completion.init()
+  return completion
+}
+
+let completionInstance: ReturnType<typeof createCompletion> | null = null
+
+const getCompletion = () => {
+  if (!completionInstance) {
+    completionInstance = createCompletion()
+  }
+  return completionInstance
+}
+
+export const initCompletion = () => {
+  getCompletion()
+}
+
+export const installCompletion = () => {
+  const completion = getCompletion()
+  completion.setupShellInitFile()
+}
+
+export const cleanupCompletion = () => {
+  const completion = getCompletion()
+  completion.cleanupShellInitFile()
+}

package/src/config.ts

@@ -0,0 +1,159 @@
+import path from 'node:path'
+import os from 'node:os'
+import { promises as fs } from 'node:fs'
+import { cosmiconfig } from 'cosmiconfig'
+import { isUrl } from './helpers'
+
+export const CONFIG_NAME = '.promptslotrc.json'
+export const DEFAULT_PLACEHOLDER = '{{promptslot}}'
+export const DEFAULT_MARKERS = {
+  start: '<!-- promptslot:start -->',
+  end: '<!-- promptslot:end -->',
+}
+
+export type ConfigScope = 'project' | 'global'
+
+export type PromptslotConfig = {
+  placeholder: string
+  markers: {
+    start: string
+    end: string
+  }
+  prompts_dir?: string | null
+  prompts_root?: string | null
+  link_default?: string | null
+  current: string | null
+  sources: Record<string, string>
+}
+
+export type LoadedConfig = {
+  config: PromptslotConfig
+  configPath: string
+  baseDir: string
+  scope: ConfigScope
+}
+
+export type MergedConfig = {
+  config: PromptslotConfig
+  resolvedSources: Record<string, string>
+  hasConfig: boolean
+}
+
+const explorer = cosmiconfig('promptslot', {
+  searchPlaces: [CONFIG_NAME],
+})
+
+export const createDefaultConfig = (): PromptslotConfig => ({
+  placeholder: DEFAULT_PLACEHOLDER,
+  markers: { ...DEFAULT_MARKERS },
+  prompts_dir: null,
+  prompts_root: null,
+  link_default: 'AGENTS.md',
+  current: null,
+  sources: {},
+})
+
+export const getProjectConfigPath = () => path.join(process.cwd(), CONFIG_NAME)
+
+export const getGlobalConfigPath = () => path.join(os.homedir(), CONFIG_NAME)
+
+const resolveConfigPath = (scope: ConfigScope) => {
+  if (scope === 'global') return getGlobalConfigPath()
+  return getProjectConfigPath()
+}
+
+export const readConfigFile = async (scope: ConfigScope) => {
+  const configPath = resolveConfigPath(scope)
+  const result = await explorer.load(configPath).catch(() => null)
+  if (!result?.config) return null
+
+  return {
+    config: result.config as PromptslotConfig,
+    configPath,
+    baseDir: path.dirname(configPath),
+    scope,
+  }
+}
+
+export const writeConfigFile = async (scope: ConfigScope, config: PromptslotConfig) => {
+  const configPath = resolveConfigPath(scope)
+  const json = JSON.stringify(config, null, 2)
+  await fs.writeFile(configPath, `${json}\n`)
+  return configPath
+}
+
+export const resolvePromptsRoot = (config: PromptslotConfig, baseDir: string) => {
+  if (config.prompts_root) {
+    return path.resolve(baseDir, config.prompts_root)
+  }
+  if (config.prompts_dir) {
+    return path.resolve(baseDir, config.prompts_dir)
+  }
+  return null
+}
+
+export const resolveSourcePath = (
+  source: string,
+  config: PromptslotConfig,
+  baseDir: string,
+) => {
+  if (isUrl(source)) return source
+  if (path.isAbsolute(source)) return source
+  const promptsRoot = resolvePromptsRoot(config, baseDir)
+  if (promptsRoot) return path.resolve(promptsRoot, source)
+  return path.resolve(baseDir, source)
+}
+
+export const ensurePromptsRoot = async (config: PromptslotConfig, baseDir: string) => {
+  const promptsRoot = resolvePromptsRoot(config, baseDir)
+  if (!promptsRoot) return null
+  await fs.mkdir(promptsRoot, { recursive: true })
+  return promptsRoot
+}
+
+const mergeConfigs = (
+  globalConfig?: PromptslotConfig | null,
+  projectConfig?: PromptslotConfig | null,
+) => {
+  const base = createDefaultConfig()
+  return {
+    ...base,
+    ...(globalConfig ?? {}),
+    ...(projectConfig ?? {}),
+    markers: {
+      ...base.markers,
+      ...(globalConfig?.markers ?? {}),
+      ...(projectConfig?.markers ?? {}),
+    },
+    sources: {
+      ...(globalConfig?.sources ?? {}),
+      ...(projectConfig?.sources ?? {}),
+    },
+  }
+}
+
+const resolveSources = (loaded: LoadedConfig | null) => {
+  if (!loaded) return {}
+  return Object.fromEntries(
+    Object.entries(loaded.config.sources).map(([name, source]) => [
+      name,
+      resolveSourcePath(source, loaded.config, loaded.baseDir),
+    ]),
+  )
+}
+
+export const loadMergedConfig = async (): Promise<MergedConfig> => {
+  const globalConfig = await readConfigFile('global')
+  const projectConfig = await readConfigFile('project')
+  const config = mergeConfigs(globalConfig?.config, projectConfig?.config)
+  const resolvedSources = {
+    ...resolveSources(globalConfig),
+    ...resolveSources(projectConfig),
+  }
+
+  return {
+    config,
+    resolvedSources,
+    hasConfig: Boolean(globalConfig || projectConfig),
+  }
+}

package/src/content-source.ts

@@ -0,0 +1,14 @@
+import { promises as fs } from 'node:fs'
+import { isUrl } from './helpers'
+
+export const readSourceText = async (sourcePath: string) => {
+  if (isUrl(sourcePath)) {
+    const response = await fetch(sourcePath)
+    if (!response.ok) {
+      throw new Error(`无法读取远程文件: ${response.status}`)
+    }
+    return response.text()
+  }
+
+  return fs.readFile(sourcePath, 'utf8')
+}

package/src/helpers.ts

@@ -0,0 +1,95 @@
+/// <reference types="bun" />
+import path from 'node:path'
+import { promises as fs } from 'node:fs'
+
+export const resolvePath = (input: string, baseDir = process.cwd()) =>
+  path.resolve(baseDir, input)
+
+export const fileExists = async (filePath: string) =>
+  fs.access(filePath).then(() => true).catch(() => false)
+
+export const isSubpath = (parent: string, child: string) => {
+  const relative = path.relative(parent, child)
+  return Boolean(relative) && !relative.startsWith('..') && !path.isAbsolute(relative)
+}
+
+export const listFiles = async (dirPath: string) => {
+  const entries = await fs.readdir(dirPath, { withFileTypes: true }).catch(() => [])
+  return entries.filter((entry) => entry.isFile()).map((entry) => entry.name)
+}
+
+export const isFile = async (filePath: string) => {
+  const stats = await fs.stat(filePath).catch(() => null)
+  if (!stats) return false
+  return stats.isFile()
+}
+
+export const isUrl = (value: string) => /^https?:\/\//i.test(value)
+
+export const getSourceExtension = (sourcePath: string) => {
+  if (isUrl(sourcePath)) {
+    const url = new URL(sourcePath)
+    return path.extname(url.pathname)
+  }
+  return path.extname(sourcePath)
+}
+
+export const ensureTargetExtension = (
+  targetPath: string,
+  sourcePath: string,
+  fallbackExtension = '.md',
+) => {
+  const sourceExtension = getSourceExtension(sourcePath) || fallbackExtension
+  const targetExtension = path.extname(targetPath)
+
+  if (!sourceExtension) return targetPath
+  if (!targetExtension) return `${targetPath}${sourceExtension}`
+  if (targetExtension === sourceExtension) return targetPath
+
+  return `${targetPath.slice(0, -targetExtension.length)}${sourceExtension}`
+}
+
+export const parseContentDisposition = (value: string | null) => {
+  if (!value) return null
+
+  const filenameMatch = /filename\*?=(?:UTF-8''|"?)([^";]+)/i.exec(value)
+  if (!filenameMatch?.[1]) return null
+
+  const filename = filenameMatch[1].trim()
+  if (!filename) return null
+
+  return decodeURIComponent(filename)
+}
+
+export const getUrlBasename = (value: string) => {
+  try {
+    const url = new URL(value)
+    if (url.pathname.endsWith('/')) return null
+
+    const base = path.basename(url.pathname)
+    if (!base || base === '/') return null
+    return base
+  } catch {
+    return null
+  }
+}
+
+export const resolveTargets = async (
+  inputs: string[],
+  excludedFiles: string[],
+) => {
+  if (inputs.length) return inputs
+
+  const glob = new Bun.Glob('**/*.md')
+  const targets: string[] = []
+  const excluded = new Set(excludedFiles.map((file) => path.resolve(file)))
+
+  for await (const file of glob.scan({ cwd: process.cwd(), onlyFiles: true })) {
+    if (file.includes('node_modules')) continue
+    const resolved = path.resolve(file)
+    if (excluded.has(resolved)) continue
+    targets.push(file)
+  }
+
+  return targets
+}

package/src/link-index.ts

@@ -0,0 +1,101 @@
+import path from 'node:path'
+import { promises as fs } from 'node:fs'
+
+export type LinkIndex = {
+  sources: Record<string, string[]>
+  roots: string[]
+}
+
+const INDEX_FILE = '.promptslot-index.json'
+
+const resolveIndexPath = () => path.join(process.cwd(), INDEX_FILE)
+
+const normalizeTarget = (targetPath: string) =>
+  path.relative(process.cwd(), path.resolve(targetPath))
+
+const normalizeRoot = (rootPath: string) => path.resolve(process.cwd(), rootPath)
+
+export const readIndex = async (): Promise<LinkIndex> => {
+  const indexPath = resolveIndexPath()
+  const content = await fs.readFile(indexPath, 'utf8').catch(() => null)
+  if (!content) return { sources: {}, roots: [] }
+
+  try {
+    const parsed = JSON.parse(content) as LinkIndex
+    return {
+      sources: parsed.sources ?? {},
+      roots: parsed.roots ?? [],
+    }
+  } catch {
+    return { sources: {}, roots: [] }
+  }
+}
+
+export const writeIndex = async (index: LinkIndex) => {
+  const indexPath = resolveIndexPath()
+  const json = JSON.stringify(index, null, 2)
+  await fs.writeFile(indexPath, `${json}\n`)
+  return indexPath
+}
+
+export const addRoot = async (rootPath: string) => {
+  const index = await readIndex()
+  const normalized = normalizeRoot(rootPath)
+  if (!index.roots.includes(normalized)) {
+    index.roots.push(normalized)
+    await writeIndex(index)
+  }
+}
+
+export const recordLink = async (source: string, targetPath: string, rootPath: string) => {
+  const index = await readIndex()
+  const normalizedTarget = normalizeTarget(targetPath)
+  const entries = index.sources[source] ?? []
+
+  if (!entries.includes(normalizedTarget)) {
+    entries.push(normalizedTarget)
+  }
+
+  index.sources[source] = entries
+
+  const normalizedRoot = normalizeRoot(rootPath)
+  if (!index.roots.includes(normalizedRoot)) {
+    index.roots.push(normalizedRoot)
+  }
+
+  await writeIndex(index)
+}
+
+export const replaceLinkTarget = async (
+  source: string,
+  oldTargetPath: string,
+  newTargetPath: string,
+) => {
+  const index = await readIndex()
+  const normalizedOld = normalizeTarget(oldTargetPath)
+  const normalizedNew = normalizeTarget(newTargetPath)
+  const entries = index.sources[source] ?? []
+
+  const next = entries.filter((item) => item !== normalizedOld)
+  if (!next.includes(normalizedNew)) {
+    next.push(normalizedNew)
+  }
+
+  index.sources[source] = next
+  await writeIndex(index)
+}
+
+export const removeLinkTarget = async (source: string, targetPath: string) => {
+  const index = await readIndex()
+  const normalized = normalizeTarget(targetPath)
+  const entries = index.sources[source] ?? []
+  const next = entries.filter((item) => item !== normalized)
+
+  if (!next.length) {
+    delete index.sources[source]
+  } else {
+    index.sources[source] = next
+  }
+
+  await writeIndex(index)
+}

package/src/link-manager.ts

@@ -0,0 +1,180 @@
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import crypto from 'node:crypto'
+import { readLinkMeta, stripLinkHeader, writeLinkFile } from './link'
+import { waitForUnlock, withLock } from './lock'
+import type { LinkMode } from './links-store'
+import { isFile, isUrl } from './helpers'
+
+const getLockPath = (sourcePath: string) => `${sourcePath}.lock`
+
+const isRemote = (sourcePath: string) => isUrl(sourcePath)
+
+const hashContent = (content: string) =>
+  crypto.createHash('sha256').update(content).digest('hex')
+
+const readSource = async (sourcePath: string) => {
+  const content = await fs.readFile(sourcePath, 'utf8')
+  return { content, hash: hashContent(content) }
+}
+
+const readRemote = async (sourcePath: string) => {
+  const response = await fetch(sourcePath)
+  if (!response.ok) {
+    throw new Error(`无法读取远程文件: ${response.status}`)
+  }
+  const content = await response.text()
+  return { content, hash: hashContent(content) }
+}
+
+const readSourceContent = async (sourcePath: string) => {
+  if (isRemote(sourcePath)) {
+    return readRemote(sourcePath)
+  }
+  return readSource(sourcePath)
+}
+
+export const createLink = async (sourcePath: string, targetPath: string) => {
+  const source = await readSourceContent(sourcePath)
+  await writeLinkFile(targetPath, sourcePath, source.content, source.hash)
+}
+
+export const createAutoLink = async (sourcePath: string, targetPath: string) => {
+  if (!isRemote(sourcePath)) {
+    try {
+      await fs.link(sourcePath, targetPath)
+      return { mode: 'hardlink' as LinkMode }
+    } catch (error) {
+      const err = error as NodeJS.ErrnoException
+      const fallback = err.code === 'EXDEV' || err.code === 'EPERM' || err.code === 'EACCES'
+      if (!fallback) throw error
+    }
+
+    try {
+      await fs.symlink(sourcePath, targetPath, 'file')
+      return { mode: 'symlink' as LinkMode }
+    } catch (error) {
+      const err = error as NodeJS.ErrnoException
+      const fallback = err.code === 'EPERM' || err.code === 'EACCES'
+      if (!fallback) throw error
+    }
+  }
+
+  await createLink(sourcePath, targetPath)
+  return { mode: 'meta' as LinkMode }
+}
+
+export const pullLink = async (sourcePath: string, targetPath: string) => {
+  if (!isRemote(sourcePath)) {
+    const lockPath = getLockPath(sourcePath)
+    await waitForUnlock(lockPath)
+  }
+
+  const source = await readSourceContent(sourcePath)
+  await writeLinkFile(targetPath, sourcePath, source.content, source.hash)
+}
+
+const resolveConflict = (sourceHash: string, linkHash: string | null, payloadHash: string) => {
+  if (!linkHash) return null
+  if (sourceHash !== linkHash && payloadHash !== linkHash) {
+    return '检测到冲突，请先 pull 更新后再写入'
+  }
+  return null
+}
+
+const resolveScopeChange = (sourceHash: string, linkHash: string | null, payloadHash: string) => {
+  if (!linkHash) return null
+  if (sourceHash !== linkHash && payloadHash === linkHash) {
+    return '源文件已更新，请先 pull 同步'
+  }
+  return null
+}
+
+export const pushLink = async (sourcePath: string, targetPath: string) => {
+  if (isRemote(sourcePath)) {
+    throw new Error('远程文件不支持写入')
+  }
+
+  const lockPath = getLockPath(sourcePath)
+  const link = await readLinkMeta(targetPath)
+  if (!link) {
+    throw new Error('文件不是 link 文件')
+  }
+
+  const payload = stripLinkHeader(link.content)
+  const payloadHash = hashContent(payload)
+
+  await withLock(lockPath, async () => {
+    const source = await readSourceContent(sourcePath)
+    const conflict = resolveConflict(source.hash, link.meta.hash, payloadHash)
+    if (conflict) {
+      throw new Error(conflict)
+    }
+
+    const sourceChanged = resolveScopeChange(source.hash, link.meta.hash, payloadHash)
+    if (sourceChanged) {
+      throw new Error(sourceChanged)
+    }
+
+    if (payloadHash !== source.hash) {
+      await fs.writeFile(sourcePath, payload)
+    }
+  })
+
+  const finalContent = await readSourceContent(sourcePath)
+  await writeLinkFile(targetPath, sourcePath, finalContent.content, finalContent.hash)
+
+}
+
+export const syncLink = async (sourcePath: string, targetPath: string) => {
+  if (isRemote(sourcePath)) {
+    throw new Error('远程文件不支持写入')
+  }
+
+  const lockPath = getLockPath(sourcePath)
+  const link = await readLinkMeta(targetPath)
+  if (!link) {
+    throw new Error('文件不是 link 文件')
+  }
+
+  const payload = stripLinkHeader(link.content)
+  const payloadHash = hashContent(payload)
+
+  await withLock(lockPath, async () => {
+    const source = await readSourceContent(sourcePath)
+
+    const conflict = resolveConflict(source.hash, link.meta.hash, payloadHash)
+    if (conflict) {
+      throw new Error(conflict)
+    }
+
+    const sourceChanged = resolveScopeChange(source.hash, link.meta.hash, payloadHash)
+    if (sourceChanged) {
+      throw new Error(sourceChanged)
+    }
+
+    if (payloadHash !== link.meta.hash && payloadHash !== source.hash) {
+      await fs.writeFile(sourcePath, payload)
+    }
+  })
+
+  const finalContent = await readSourceContent(sourcePath)
+  await writeLinkFile(targetPath, sourcePath, finalContent.content, finalContent.hash)
+}
+
+export const resolvePromptPath = (root: string, name: string) => {
+  const direct = path.resolve(root, name)
+  return direct
+}
+
+export const resolvePromptFile = async (root: string, name: string) => {
+  const direct = resolvePromptPath(root, name)
+  const directExists = await isFile(direct)
+  if (directExists) return direct
+
+  const withMd = resolvePromptPath(root, `${name}.md`)
+  const withMdExists = await isFile(withMd)
+  if (withMdExists) return withMd
+
+  return null
+}

package/src/link-repair.ts

@@ -0,0 +1,30 @@
+/// <reference types="bun" />
+import path from 'node:path'
+import { readLinks, writeLinks } from './links-store'
+import { removeLinkTarget } from './link-index'
+import { fileExists } from './helpers'
+
+export const autoRepairLinks = async () => {
+  const entries = await readLinks()
+  const keys = Object.keys(entries)
+  if (!keys.length) return
+
+  let changed = false
+
+  for (const key of keys) {
+    const entry = entries[key]
+    if (entry.mode !== 'meta') continue
+
+    const targetPath = path.resolve(process.cwd(), key)
+    const exists = await fileExists(targetPath)
+    if (exists) continue
+
+    delete entries[key]
+    await removeLinkTarget(entry.source, targetPath)
+    changed = true
+  }
+
+  if (changed) {
+    await writeLinks(entries)
+  }
+}