@yuchenrx/pmt-cli 0.1.2

package/src/link.ts

@@ -0,0 +1,82 @@
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+
+const LINK_PREFIX = '<!-- promptslot-link:'
+const LINK_SUFFIX = '-->'
+
+type LinkMeta = {
+  source: string
+  hash: string | null
+}
+
+const buildHeader = (meta: LinkMeta) => {
+  const payload = JSON.stringify(meta)
+  return `${LINK_PREFIX} ${payload} ${LINK_SUFFIX}`
+}
+
+const splitLines = (content: string) => content.split(/\r?\n/)
+
+const parseHeaderValue = (value: string): LinkMeta | null => {
+  const trimmed = value.trim()
+  if (!trimmed) return null
+
+  if (trimmed.startsWith('{')) {
+    const parsed = JSON.parse(trimmed) as LinkMeta
+    if (!parsed?.source) return null
+    return { source: parsed.source, hash: parsed.hash ?? null }
+  }
+
+  return { source: trimmed, hash: null }
+}
+
+export const parseLinkHeader = (content: string) => {
+  const [firstLine] = splitLines(content)
+  if (!firstLine) return null
+  const trimmed = firstLine.trim()
+  if (!trimmed.startsWith(LINK_PREFIX) || !trimmed.endsWith(LINK_SUFFIX)) return null
+
+  const inner = trimmed.slice(LINK_PREFIX.length, trimmed.length - LINK_SUFFIX.length).trim()
+  return parseHeaderValue(inner)
+}
+
+export const stripLinkHeader = (content: string) => {
+  const lines = splitLines(content)
+  if (!lines.length) return content
+
+  const header = parseLinkHeader(lines[0])
+  if (!header) return content
+
+  return lines.slice(1).join('\n').replace(/^\n+/, '')
+}
+
+export const buildLinkContent = (meta: LinkMeta, payload: string) => {
+  const header = buildHeader(meta)
+  const trimmedPayload = payload.replace(/\s+$/, '')
+  return `${header}\n${trimmedPayload}\n`
+}
+
+export const readLinkMeta = async (targetPath: string) => {
+  const content = await fs.readFile(targetPath, 'utf8')
+  const meta = parseLinkHeader(content)
+  if (!meta) return null
+  return { meta, content }
+}
+
+export const readLinkTarget = async (targetPath: string) => {
+  const link = await readLinkMeta(targetPath)
+  if (!link) return null
+  return link.meta.source
+}
+
+export const writeLinkFile = async (
+  targetPath: string,
+  sourcePath: string,
+  payload: string,
+  hash: string | null,
+) => {
+  const absoluteSource = path.resolve(sourcePath)
+  const content = buildLinkContent({ source: absoluteSource, hash }, payload)
+  await fs.writeFile(targetPath, content)
+}
+
+export type { LinkMeta }

package/src/links-store.ts

@@ -0,0 +1,47 @@
+import path from 'node:path'
+import { promises as fs } from 'node:fs'
+
+export type LinkMode = 'hardlink' | 'symlink' | 'meta'
+
+export type LinkEntry = {
+  source: string
+  mode: LinkMode
+}
+
+const LINKS_FILE = '.promptslot-links.json'
+
+const resolveStorePath = () => path.join(process.cwd(), LINKS_FILE)
+
+const normalizeTarget = (targetPath: string) =>
+  path.relative(process.cwd(), path.resolve(targetPath))
+
+export const readLinks = async (): Promise<Record<string, LinkEntry>> => {
+  const storePath = resolveStorePath()
+  const content = await fs.readFile(storePath, 'utf8').catch(() => null)
+  if (!content) return {}
+
+  try {
+    const parsed = JSON.parse(content) as Record<string, LinkEntry>
+    return parsed ?? {}
+  } catch {
+    return {}
+  }
+}
+
+export const writeLinks = async (entries: Record<string, LinkEntry>) => {
+  const storePath = resolveStorePath()
+  const json = JSON.stringify(entries, null, 2)
+  await fs.writeFile(storePath, `${json}\n`)
+  return storePath
+}
+
+export const upsertLink = async (targetPath: string, entry: LinkEntry) => {
+  const entries = await readLinks()
+  entries[normalizeTarget(targetPath)] = entry
+  await writeLinks(entries)
+}
+
+export const getLinkEntry = async (targetPath: string) => {
+  const entries = await readLinks()
+  return entries[normalizeTarget(targetPath)] ?? null
+}

package/src/lock.ts

@@ -0,0 +1,59 @@
+import { promises as fs } from 'node:fs'
+
+const LOCK_TIMEOUT_MS = 10000
+const LOCK_INTERVAL_MS = 200
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
+
+const tryCreateLock = async (lockPath: string) => {
+  try {
+    const handle = await fs.open(lockPath, 'wx')
+    await handle.close()
+    return true
+  } catch (error) {
+    const err = error as NodeJS.ErrnoException
+    if (err.code === 'EEXIST') return false
+    throw error
+  }
+}
+
+export const waitForUnlock = async (lockPath: string) => {
+  const start = Date.now()
+  while (true) {
+    const exists = await fs
+      .access(lockPath)
+      .then(() => true)
+      .catch(() => false)
+
+    if (!exists) return
+
+    const elapsed = Date.now() - start
+    if (elapsed >= LOCK_TIMEOUT_MS) {
+      throw new Error('写入锁等待超时，请稍后重试')
+    }
+
+    await sleep(LOCK_INTERVAL_MS)
+  }
+}
+
+export const withLock = async <T>(lockPath: string, task: () => Promise<T>) => {
+  const start = Date.now()
+
+  while (true) {
+    const created = await tryCreateLock(lockPath)
+    if (created) break
+
+    const elapsed = Date.now() - start
+    if (elapsed >= LOCK_TIMEOUT_MS) {
+      throw new Error('写入锁等待超时，请稍后重试')
+    }
+
+    await sleep(LOCK_INTERVAL_MS)
+  }
+
+  try {
+    return await task()
+  } finally {
+    await fs.unlink(lockPath).catch(() => null)
+  }
+}

package/src/prompt-root.ts

@@ -0,0 +1,27 @@
+import { readConfigFile, resolvePromptsRoot, type ConfigScope } from './config'
+
+export type PromptRootInfo = {
+  root: string
+  scope: ConfigScope
+}
+
+const resolveRoot = async (scope: ConfigScope) => {
+  const config = await readConfigFile(scope)
+  if (!config) return null
+  const root = resolvePromptsRoot(config.config, config.baseDir)
+  if (!root) return null
+  return { root, scope }
+}
+
+export const loadPromptRoot = async (scope?: ConfigScope): Promise<PromptRootInfo | null> => {
+  if (scope === 'project') return resolveRoot('project')
+  if (scope === 'global') return resolveRoot('global')
+
+  const project = await resolveRoot('project')
+  if (project) return project
+
+  const globalConfig = await resolveRoot('global')
+  if (globalConfig) return globalConfig
+
+  return null
+}

package/src/prompt.ts

@@ -0,0 +1,20 @@
+import { createInterface } from 'node:readline/promises'
+
+export const ask = async (question: string, fallback: string) => {
+  if (!process.stdin.isTTY) return fallback
+
+  const prompt = `${question} (${fallback}): `
+  const readline = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  })
+
+  try {
+    const answer = await readline.question(prompt)
+    const trimmed = answer.trim()
+    if (!trimmed) return fallback
+    return trimmed
+  } finally {
+    readline.close()
+  }
+}

package/src/rename-daemon.ts

@@ -0,0 +1,98 @@
+import path from 'node:path'
+import { promises as fs, watch } from 'node:fs'
+import { startRenameWatcher } from './rename-watcher'
+import { readLinks } from './links-store'
+
+const PID_FILE = '.promptslot-rename.pid'
+const STORE_FILE = '.promptslot-links.json'
+
+const getPidPath = () => path.join(process.cwd(), PID_FILE)
+const getStorePath = () => path.join(process.cwd(), STORE_FILE)
+
+const isProcessAlive = (pid: number) => {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+const readPid = async () => {
+  const content = await fs.readFile(getPidPath(), 'utf8').catch(() => null)
+  if (!content) return null
+  const pid = Number.parseInt(content, 10)
+  if (!Number.isFinite(pid)) return null
+  return pid
+}
+
+const writePid = async () => {
+  await fs.writeFile(getPidPath(), `${process.pid}\n`)
+}
+
+const deletePid = async () => {
+  await fs.unlink(getPidPath()).catch(() => null)
+}
+
+const watchStore = (onChange: () => void) => {
+  const storePath = getStorePath()
+  const watcher = watch(storePath, { persistent: true }, () => {
+    onChange()
+  })
+  return watcher
+}
+
+export const ensureRenameDaemon = async () => {
+  const pid = await readPid()
+  if (pid && isProcessAlive(pid)) return false
+
+  await deletePid()
+
+  const { spawn } = await import('node:child_process')
+  const execPath = process.argv[0]
+  const scriptPath = process.argv[1]
+  const args: string[] = []
+
+  if (scriptPath && path.extname(scriptPath) === '.ts') {
+    args.push(scriptPath)
+  }
+
+  args.push('rename-daemon')
+
+  const proc = spawn(execPath, args, {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+  })
+
+  proc.unref()
+  return true
+}
+
+export const runRenameDaemon = async () => {
+  const entries = await readLinks()
+  if (!Object.keys(entries).length) return
+
+  await writePid()
+
+  let watcher = await startRenameWatcher()
+
+  const storeWatcher = await watchStore(() => {
+    watcher?.close()
+    void startRenameWatcher().then((next) => {
+      watcher = next
+    })
+  })
+
+  const shutdown = async () => {
+    storeWatcher.close()
+    watcher?.close()
+    await deletePid()
+    process.exit(0)
+  }
+
+  process.on('SIGINT', shutdown)
+  process.on('SIGTERM', shutdown)
+
+  await new Promise(() => {})
+}

package/src/rename-watcher.ts

@@ -0,0 +1,110 @@
+import Watcher from 'watcher'
+import path from 'node:path'
+import { readLinkMeta } from './link'
+import { replaceLinkTarget } from './link-index'
+import { fileExists } from './helpers'
+import { readLinks, writeLinks } from './links-store'
+
+const normalizeTarget = (targetPath: string) =>
+  path.relative(process.cwd(), path.resolve(targetPath))
+
+const loadDirectories = async () => {
+  const entries = await readLinks()
+  const dirs = new Set<string>()
+
+  for (const target of Object.keys(entries)) {
+    const dir = path.dirname(path.resolve(process.cwd(), target))
+    dirs.add(dir)
+  }
+
+  return Array.from(dirs)
+}
+
+const updateLinkRecord = async (oldPath: string, newPath: string, source: string) => {
+  const entries = await readLinks()
+  const oldKey = normalizeTarget(oldPath)
+  const newKey = normalizeTarget(newPath)
+
+  const existing = entries[oldKey]
+
+  if (existing) {
+    entries[newKey] = existing
+    delete entries[oldKey]
+  } else {
+    entries[newKey] = { source, mode: 'meta' }
+  }
+
+  await writeLinks(entries)
+  await replaceLinkTarget(source, oldPath, newPath)
+}
+
+const resolveSource = async (filePath: string) => {
+  const meta = await readLinkMeta(filePath).catch(() => null)
+  return meta?.meta.source ?? null
+}
+
+export const startRenameWatcher = async () => {
+  const roots = await loadDirectories()
+  if (!roots.length) return null
+
+  const watcher = new Watcher(roots, {
+    renameDetection: true,
+    renameTimeout: 500,
+    ignore: /node_modules|\.git/,
+    recursive: true,
+  })
+
+  watcher.on('rename', async (oldPath: string, newPath: string) => {
+    const oldExists = await fileExists(oldPath)
+    const newExists = await fileExists(newPath)
+
+    if (oldExists || !newExists) return
+
+    const source = await resolveSource(newPath)
+    if (!source) return
+
+    await updateLinkRecord(oldPath, newPath, source)
+  })
+
+  watcher.on('delete', async (filePath: string) => {
+    const entries = await readLinks()
+    const key = normalizeTarget(filePath)
+    if (!entries[key]) return
+
+    delete entries[key]
+    await writeLinks(entries)
+  })
+
+  watcher.on('add', async (filePath: string) => {
+    const source = await resolveSource(filePath)
+    if (!source) return
+
+    const entries = await readLinks()
+    const key = normalizeTarget(filePath)
+    if (entries[key]) return
+
+    entries[key] = { source, mode: 'meta' }
+    await writeLinks(entries)
+  })
+
+  watcher.on('renameDir', async (oldPath: string, newPath: string) => {
+    const entries = await readLinks()
+    const pairs = Object.entries(entries)
+
+    for (const [target] of pairs) {
+      const absoluteOld = path.resolve(process.cwd(), target)
+      if (!absoluteOld.startsWith(oldPath)) continue
+
+      const absoluteNew = path.join(newPath, path.relative(oldPath, absoluteOld))
+      const exists = await fileExists(absoluteNew)
+      if (!exists) continue
+
+      const source = await resolveSource(absoluteNew)
+      if (!source) continue
+
+      await updateLinkRecord(absoluteOld, absoluteNew, source)
+    }
+  })
+
+  return watcher
+}

package/src/scope.ts

@@ -0,0 +1,13 @@
+import type { ConfigScope } from './config'
+
+export type ScopeResult = {
+  scope: ConfigScope
+  error: string | null
+}
+
+export const resolveScope = (input?: string): ScopeResult => {
+  if (!input) return { scope: 'global', error: null }
+  if (input === 'global') return { scope: 'global', error: null }
+  if (input === 'project') return { scope: 'project', error: null }
+  return { scope: 'global', error: 'scope 必须是 project 或 global' }
+}