lsd-pi 1.0.0 → 1.1.1

package/src/resources/extensions/shared/debug-logger.ts

@@ -0,0 +1,102 @@
+import { appendFileSync, mkdirSync, readdirSync, unlinkSync } from 'node:fs'
+import { join } from 'node:path'
+import { resolveProjectStateRoot } from './paths.js'
+
+let _enabled = false
+let _logPath: string | null = null
+let _startTime = 0
+
+const _counters = {
+  deriveStateCalls: 0,
+  deriveStateTotalMs: 0,
+  ttsrChecks: 0,
+  ttsrTotalMs: 0,
+  ttsrPeakBuffer: 0,
+  parseRoadmapCalls: 0,
+  parseRoadmapTotalMs: 0,
+  parsePlanCalls: 0,
+  parsePlanTotalMs: 0,
+  dispatches: 0,
+  renders: 0,
+}
+
+const MAX_DEBUG_LOGS = 5
+
+export function enableDebug(basePath: string): void {
+  const debugDir = join(resolveProjectStateRoot(basePath), 'debug')
+  mkdirSync(debugDir, { recursive: true })
+  try {
+    const files = readdirSync(debugDir)
+      .filter(f => f.startsWith('debug-') && f.endsWith('.log'))
+      .sort()
+    while (files.length >= MAX_DEBUG_LOGS) {
+      const oldest = files.shift()!
+      try { unlinkSync(join(debugDir, oldest)) } catch {}
+    }
+  } catch {}
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
+  _logPath = join(debugDir, `debug-${timestamp}.log`)
+  _startTime = Date.now()
+  _enabled = true
+  for (const key of Object.keys(_counters) as (keyof typeof _counters)[]) {
+    _counters[key] = 0
+  }
+}
+
+export function disableDebug(): string | null {
+  const path = _logPath
+  _enabled = false
+  _logPath = null
+  _startTime = 0
+  return path
+}
+
+export function isDebugEnabled(): boolean { return _enabled }
+export function getDebugLogPath(): string | null { return _logPath }
+
+export function debugLog(event: string, data?: Record<string, unknown>): void {
+  if (!_enabled || !_logPath) return
+  try { appendFileSync(_logPath, JSON.stringify({ ts: new Date().toISOString(), event, ...data }) + '\n') } catch {}
+}
+
+export function debugTime(event: string): (data?: Record<string, unknown>) => void {
+  if (!_enabled) return _noop
+  const start = performance.now()
+  return (data?: Record<string, unknown>) => {
+    const elapsed_ms = Math.round((performance.now() - start) * 100) / 100
+    debugLog(event, { elapsed_ms, ...data })
+  }
+}
+
+export function debugCount(counter: keyof typeof _counters, value = 1): void {
+  if (!_enabled) return
+  _counters[counter] += value
+}
+
+export function debugPeak(counter: keyof typeof _counters, value: number): void {
+  if (!_enabled) return
+  if (value > _counters[counter]) _counters[counter] = value
+}
+
+export function writeDebugSummary(): string | null {
+  if (!_enabled || !_logPath) return null
+  const totalElapsed_ms = Date.now() - _startTime
+  const avgDeriveState_ms = _counters.deriveStateCalls > 0 ? Math.round((_counters.deriveStateTotalMs / _counters.deriveStateCalls) * 100) / 100 : 0
+  const avgTtsrCheck_ms = _counters.ttsrChecks > 0 ? Math.round((_counters.ttsrTotalMs / _counters.ttsrChecks) * 100) / 100 : 0
+  debugLog('debug-summary', {
+    totalElapsed_ms,
+    dispatches: _counters.dispatches,
+    deriveStateCalls: _counters.deriveStateCalls,
+    avgDeriveState_ms,
+    parseRoadmapCalls: _counters.parseRoadmapCalls,
+    avgParseRoadmap_ms: _counters.parseRoadmapCalls > 0 ? Math.round((_counters.parseRoadmapTotalMs / _counters.parseRoadmapCalls) * 100) / 100 : 0,
+    parsePlanCalls: _counters.parsePlanCalls,
+    ttsrChecks: _counters.ttsrChecks,
+    avgTtsrCheck_ms,
+    ttsrPeakBuffer: _counters.ttsrPeakBuffer,
+    renders: _counters.renders,
+  })
+  return disableDebug()
+}
+
+function _noop(_data?: Record<string, unknown>): void {}

package/src/resources/extensions/shared/env-utils.ts

@@ -0,0 +1,18 @@
+import { readFile } from 'node:fs/promises'
+
+export async function checkExistingEnvKeys(keys: string[], envFilePath: string): Promise<string[]> {
+  let fileContent = ''
+  try {
+    fileContent = await readFile(envFilePath, 'utf8')
+  } catch {}
+
+  const existing: string[] = []
+  for (const key of keys) {
+    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    const regex = new RegExp(`^${escaped}\\s*=`, 'm')
+    if (regex.test(fileContent) || key in process.env) {
+      existing.push(key)
+    }
+  }
+  return existing
+}

package/src/resources/extensions/shared/paths.ts

@@ -0,0 +1,15 @@
+import { existsSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+
+export function resolveProjectStateRoot(basePath: string): string {
+  let current = resolve(basePath)
+  while (true) {
+    const lsdDir = join(current, '.lsd')
+    if (existsSync(lsdDir)) return lsdDir
+    const legacyDir = join(current, '.gsd')
+    if (existsSync(legacyDir)) return legacyDir
+    const parent = dirname(current)
+    if (parent === current) return join(resolve(basePath), '.lsd')
+    current = parent
+  }
+}

package/src/resources/extensions/shared/preferences.ts

@@ -0,0 +1,122 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join, dirname } from 'node:path'
+import { parse as parseYaml } from 'yaml'
+import { resolveProjectStateRoot } from './paths.js'
+
+export type SearchProviderPreference = 'tavily' | 'brave' | 'ollama' | 'native' | 'auto'
+
+export interface RemoteQuestionsConfig {
+  channel?: 'slack' | 'discord' | 'telegram'
+  channel_id?: string | number
+  timeout_minutes?: number
+  poll_interval_seconds?: number
+}
+
+export interface CmuxPreferences {
+  enabled?: boolean
+  notifications?: boolean
+  sidebar?: boolean
+  splits?: boolean
+  browser?: boolean
+}
+
+export interface SubagentPreferences {
+  budget_model?: string
+}
+
+export interface SharedPreferences {
+  experimental?: { rtk?: boolean }
+  remote_questions?: RemoteQuestionsConfig
+  search_provider?: SearchProviderPreference
+  cmux?: CmuxPreferences
+  subagent?: SubagentPreferences
+}
+
+export interface LoadedSharedPreferences {
+  path: string
+  scope: 'global' | 'project'
+  preferences: SharedPreferences
+}
+
+export function getGlobalPreferencesPath(): string {
+  const appRoot = process.env.LSD_HOME || join(homedir(), '.lsd')
+  return join(appRoot, 'PREFERENCES.md')
+}
+
+function getGlobalPreferenceCandidates(): string[] {
+  const appRoot = process.env.LSD_HOME || join(homedir(), '.lsd')
+  return [join(appRoot, 'preferences.md'), join(appRoot, 'PREFERENCES.md')]
+}
+
+function getProjectPreferenceCandidates(basePath: string = process.cwd()): string[] {
+  const root = resolveProjectStateRoot(basePath)
+  return [join(root, 'preferences.md'), join(root, 'PREFERENCES.md')]
+}
+
+function parsePreferencesMarkdown(content: string): SharedPreferences | null {
+  const startMarker = content.startsWith('---\r\n') ? '---\r\n' : '---\n'
+  if (!content.startsWith(startMarker)) return null
+  const endIdx = content.indexOf('\n---', startMarker.length)
+  if (endIdx === -1) return null
+  const block = content.slice(startMarker.length, endIdx).replace(/\r/g, '')
+  try {
+    const parsed = parseYaml(block)
+    if (!parsed || typeof parsed !== 'object') return {}
+    return parsed as SharedPreferences
+  } catch {
+    return {}
+  }
+}
+
+function deepMerge<T>(base: T, override: T): T {
+  if (Array.isArray(base) || Array.isArray(override)) return override
+  if (!base || typeof base !== 'object') return override
+  if (!override || typeof override !== 'object') return override
+  const result: Record<string, unknown> = { ...(base as Record<string, unknown>) }
+  for (const [key, value] of Object.entries(override as Record<string, unknown>)) {
+    const current = result[key]
+    if (current && value && typeof current === 'object' && typeof value === 'object' && !Array.isArray(current) && !Array.isArray(value)) {
+      result[key] = deepMerge(current as Record<string, unknown>, value as Record<string, unknown>)
+    } else {
+      result[key] = value
+    }
+  }
+  return result as T
+}
+
+function loadFromCandidates(candidates: string[], scope: 'global' | 'project'): LoadedSharedPreferences | null {
+  for (const path of candidates) {
+    if (!existsSync(path)) continue
+    const raw = readFileSync(path, 'utf-8')
+    const preferences = parsePreferencesMarkdown(raw)
+    if (!preferences) continue
+    return { path, scope, preferences }
+  }
+  return null
+}
+
+export function loadGlobalPreferences(): LoadedSharedPreferences | null {
+  return loadFromCandidates(getGlobalPreferenceCandidates(), 'global')
+}
+
+export function loadProjectPreferences(basePath: string = process.cwd()): LoadedSharedPreferences | null {
+  return loadFromCandidates(getProjectPreferenceCandidates(basePath), 'project')
+}
+
+export function loadEffectivePreferences(basePath: string = process.cwd()): LoadedSharedPreferences | null {
+  const globalPrefs = loadGlobalPreferences()
+  const projectPrefs = loadProjectPreferences(basePath)
+  if (!globalPrefs && !projectPrefs) return null
+  if (!globalPrefs) return projectPrefs
+  if (!projectPrefs) return globalPrefs
+  return {
+    path: projectPrefs.path,
+    scope: 'project',
+    preferences: deepMerge(globalPrefs.preferences, projectPrefs.preferences),
+  }
+}
+
+export function resolveSearchProviderFromPreferences(basePath: string = process.cwd()): SearchProviderPreference | undefined {
+  return loadEffectivePreferences(basePath)?.preferences.search_provider
+}

package/src/resources/extensions/shared/remote-questions-config.ts

@@ -0,0 +1,30 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs'
+import { dirname } from 'node:path'
+import { getGlobalPreferencesPath } from './preferences.js'
+
+export function saveRemoteQuestionsConfig(channel: 'slack' | 'discord' | 'telegram', channelId: string): void {
+  const prefsPath = getGlobalPreferencesPath()
+  const block = [
+    'remote_questions:',
+    `  channel: ${channel}`,
+    `  channel_id: "${channelId}"`,
+    '  timeout_minutes: 5',
+    '  poll_interval_seconds: 5',
+  ].join('\n')
+
+  const content = existsSync(prefsPath) ? readFileSync(prefsPath, 'utf-8') : ''
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/)
+  let next = content
+
+  if (fmMatch) {
+    let frontmatter = fmMatch[1]
+    const regex = /remote_questions:[\s\S]*?(?=\n[a-zA-Z_]|\n---|$)/
+    frontmatter = regex.test(frontmatter) ? frontmatter.replace(regex, block) : `${frontmatter.trimEnd()}\n${block}`
+    next = `---\n${frontmatter}\n---${content.slice(fmMatch[0].length)}`
+  } else {
+    next = `---\n${block}\n---\n\n${content}`
+  }
+
+  mkdirSync(dirname(prefsPath), { recursive: true })
+  writeFileSync(prefsPath, next, 'utf-8')
+}

package/src/resources/extensions/shared/rtk-session-stats.ts

@@ -2,7 +2,7 @@ import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { gsdRoot } from "../gsd/paths.js";
+import { resolveProjectStateRoot } from "./paths.js";
 import { formatTokenCount } from "./format-utils.js";
 import { buildRtkEnv, isRtkEnabled, resolveRtkBinaryPath } from "./rtk.js";
 
@@ -46,7 +46,7 @@ interface BaselineStore {
 let cachedSummary: { at: number; binaryPath: string; summary: RtkGainSummary | null } | null = null;
 
 function getRuntimeDir(basePath: string): string {
-  return join(gsdRoot(basePath), "runtime");
+  return join(resolveProjectStateRoot(basePath), "runtime");
 }
 
 function getBaselinesPath(basePath: string): string {

package/src/resources/extensions/shared/secrets-manifest.ts

@@ -0,0 +1,130 @@
+import { readFile, writeFile } from 'node:fs/promises'
+import { existsSync, readdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { resolveProjectStateRoot } from './paths.js'
+
+export type SecretsManifestEntryStatus = 'pending' | 'collected' | 'skipped'
+
+export interface SecretsManifestEntry {
+  key: string
+  service: string
+  dashboardUrl: string
+  guidance: string[]
+  formatHint: string
+  status: SecretsManifestEntryStatus
+  destination: string
+}
+
+export interface SecretsManifest {
+  milestone: string
+  generatedAt: string
+  entries: SecretsManifestEntry[]
+}
+
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function extractBoldField(text: string, key: string): string | null {
+  const regex = new RegExp(`^\\*\\*${escapeRegex(key)}:\\*\\*\\s*(.+)$`, 'm')
+  const match = regex.exec(text)
+  return match ? match[1].trim() : null
+}
+
+function extractAllSections(body: string, level = 3): Map<string, string> {
+  const prefix = '#'.repeat(level) + ' '
+  const regex = new RegExp(`^${prefix}(.+)$`, 'gm')
+  const sections = new Map<string, string>()
+  const matches = [...body.matchAll(regex)]
+  for (let i = 0; i < matches.length; i++) {
+    const heading = matches[i][1].trim()
+    const start = matches[i].index! + matches[i][0].length
+    const end = i + 1 < matches.length ? matches[i + 1].index! : body.length
+    sections.set(heading, body.slice(start, end).trim())
+  }
+  return sections
+}
+
+const VALID_STATUSES = new Set<SecretsManifestEntryStatus>(['pending', 'collected', 'skipped'])
+
+export function parseSecretsManifest(content: string): SecretsManifest {
+  const milestone = extractBoldField(content, 'Milestone') || ''
+  const generatedAt = extractBoldField(content, 'Generated') || ''
+  const h3Sections = extractAllSections(content, 3)
+  const entries: SecretsManifestEntry[] = []
+  for (const [heading, sectionContent] of h3Sections) {
+    const key = heading.trim()
+    if (!key) continue
+    const service = extractBoldField(sectionContent, 'Service') || ''
+    const dashboardUrl = extractBoldField(sectionContent, 'Dashboard') || ''
+    const formatHint = extractBoldField(sectionContent, 'Format hint') || ''
+    const rawStatus = (extractBoldField(sectionContent, 'Status') || 'pending').toLowerCase().trim() as SecretsManifestEntryStatus
+    const status = VALID_STATUSES.has(rawStatus) ? rawStatus : 'pending'
+    const destination = extractBoldField(sectionContent, 'Destination') || 'dotenv'
+    const guidance: string[] = []
+    for (const line of sectionContent.split('\n')) {
+      const numMatch = line.match(/^\s*\d+\.\s+(.+)/)
+      if (numMatch) guidance.push(numMatch[1].trim())
+    }
+    entries.push({ key, service, dashboardUrl, guidance, formatHint, status, destination })
+  }
+  return { milestone, generatedAt, entries }
+}
+
+export function formatSecretsManifest(manifest: SecretsManifest): string {
+  const lines: string[] = []
+  lines.push('# Secrets Manifest')
+  lines.push('')
+  lines.push(`**Milestone:** ${manifest.milestone}`)
+  lines.push(`**Generated:** ${manifest.generatedAt}`)
+  for (const entry of manifest.entries) {
+    lines.push('')
+    lines.push(`### ${entry.key}`)
+    lines.push('')
+    lines.push(`**Service:** ${entry.service}`)
+    if (entry.dashboardUrl) lines.push(`**Dashboard:** ${entry.dashboardUrl}`)
+    if (entry.formatHint) lines.push(`**Format hint:** ${entry.formatHint}`)
+    lines.push(`**Status:** ${entry.status}`)
+    lines.push(`**Destination:** ${entry.destination}`)
+    lines.push('')
+    for (let i = 0; i < entry.guidance.length; i++) lines.push(`${i + 1}. ${entry.guidance[i]}`)
+  }
+  return lines.join('\n') + '\n'
+}
+
+export function resolveMilestoneFile(basePath: string, milestoneId: string, suffix: string): string | null {
+  const root = resolveProjectStateRoot(basePath)
+  const milestonesDir = join(root, 'milestones')
+  if (!existsSync(milestonesDir)) return null
+  const directDir = join(milestonesDir, milestoneId)
+  const candidateDirs = existsSync(directDir) ? [milestoneId] : []
+  if (candidateDirs.length === 0) {
+    try {
+      for (const name of readdirSync(milestonesDir, { withFileTypes: true })) {
+        if (name.isDirectory() && name.name.startsWith(milestoneId)) candidateDirs.push(name.name)
+      }
+    } catch {}
+  }
+  const dirName = candidateDirs[0]
+  if (!dirName) return null
+  const dir = join(milestonesDir, dirName)
+  const directFile = join(dir, `${milestoneId}-${suffix}.md`)
+  if (existsSync(directFile)) return directFile
+  try {
+    const file = readdirSync(dir).find((name: string) => name.startsWith(`${milestoneId}-`) && name.endsWith(`-${suffix}.md`))
+    return file ? join(dir, file) : null
+  } catch {
+    return null
+  }
+}
+
+export async function loadSecretsManifestFile(basePath: string, milestoneId: string): Promise<{ path: string; manifest: SecretsManifest } | null> {
+  const path = resolveMilestoneFile(basePath, milestoneId, 'SECRETS')
+  if (!path) return null
+  const content = await readFile(path, 'utf8')
+  return { path, manifest: parseSecretsManifest(content) }
+}
+
+export async function saveSecretsManifestFile(path: string, manifest: SecretsManifest): Promise<void> {
+  await writeFile(path, formatSecretsManifest(manifest), 'utf8')
+}

package/src/resources/extensions/slash-commands/extension-manifest.json

@@ -6,6 +6,7 @@
   "tier": "bundled",
   "requires": { "platform": ">=2.29.0" },
   "provides": {
-    "commands": ["create-slash-command", "create-extension", "audit", "clear"]
+    "commands": ["create-slash-command", "create-extension", "audit", "clear", "plan", "execute", "cancel-plan"],
+    "flags": ["plan"]
   }
 }

package/src/resources/extensions/slash-commands/index.ts

@@ -3,10 +3,12 @@ import createSlashCommand from "./create-slash-command.js";
 import createExtension from "./create-extension.js";
 import auditCommand from "./audit.js";
 import clearCommand from "./clear.js";
+import planCommand from "./plan.js";
 
 export default function slashCommands(pi: ExtensionAPI) {
   createSlashCommand(pi);
   createExtension(pi);
   auditCommand(pi);
   clearCommand(pi);
+  planCommand(pi);
 }