@dedesfr/prompter 0.8.23 → 1.0.0

package/src/utils/file-system.ts

@@ -1,252 +0,0 @@
-import { promises as fs, constants as fsConstants } from 'fs';
-import path from 'path';
-
-function isMarkerOnOwnLine(content: string, markerIndex: number, markerLength: number): boolean {
-  let leftIndex = markerIndex - 1;
-  while (leftIndex >= 0 && content[leftIndex] !== '\n') {
-    const char = content[leftIndex];
-    if (char !== ' ' && char !== '\t' && char !== '\r') {
-      return false;
-    }
-    leftIndex--;
-  }
-
-  let rightIndex = markerIndex + markerLength;
-  while (rightIndex < content.length && content[rightIndex] !== '\n') {
-    const char = content[rightIndex];
-    if (char !== ' ' && char !== '\t' && char !== '\r') {
-      return false;
-    }
-    rightIndex++;
-  }
-
-  return true;
-}
-
-function findMarkerIndex(
-  content: string,
-  marker: string,
-  fromIndex = 0
-): number {
-  let currentIndex = content.indexOf(marker, fromIndex);
-
-  while (currentIndex !== -1) {
-    if (isMarkerOnOwnLine(content, currentIndex, marker.length)) {
-      return currentIndex;
-    }
-
-    currentIndex = content.indexOf(marker, currentIndex + marker.length);
-  }
-
-  return -1;
-}
-
-export class FileSystemUtils {
-  /**
-   * Converts a path to use forward slashes (POSIX style).
-   * Essential for cross-platform compatibility with glob libraries like fast-glob.
-   */
-  static toPosixPath(p: string): string {
-    return p.replace(/\\/g, '/');
-  }
-
-  private static isWindowsBasePath(basePath: string): boolean {
-    return /^[A-Za-z]:[\\/]/.test(basePath) || basePath.startsWith('\\');
-  }
-
-  private static normalizeSegments(segments: string[]): string[] {
-    return segments
-      .flatMap((segment) => segment.split(/[\\/]+/u))
-      .filter((part) => part.length > 0);
-  }
-
-  static joinPath(basePath: string, ...segments: string[]): string {
-    const normalizedSegments = this.normalizeSegments(segments);
-
-    if (this.isWindowsBasePath(basePath)) {
-      const normalizedBasePath = path.win32.normalize(basePath);
-      return normalizedSegments.length
-        ? path.win32.join(normalizedBasePath, ...normalizedSegments)
-        : normalizedBasePath;
-    }
-
-    const posixBasePath = basePath.replace(/\\/g, '/');
-
-    return normalizedSegments.length
-      ? path.posix.join(posixBasePath, ...normalizedSegments)
-      : path.posix.normalize(posixBasePath);
-  }
-
-  static async createDirectory(dirPath: string): Promise<void> {
-    await fs.mkdir(dirPath, { recursive: true });
-  }
-
-  static async fileExists(filePath: string): Promise<boolean> {
-    try {
-      await fs.access(filePath);
-      return true;
-    } catch (error: any) {
-      if (error.code !== 'ENOENT') {
-        console.debug(`Unable to check if file exists at ${filePath}: ${error.message}`);
-      }
-      return false;
-    }
-  }
-
-  /**
-   * Finds the first existing parent directory by walking up the directory tree.
-   * @param dirPath Starting directory path
-   * @returns The first existing directory path, or null if root is reached without finding one
-   */
-  private static async findFirstExistingDirectory(dirPath: string): Promise<string | null> {
-    let currentDir = dirPath;
-
-    while (true) {
-      try {
-        const stats = await fs.stat(currentDir);
-        if (stats.isDirectory()) {
-          return currentDir;
-        }
-        // Path component exists but is not a directory (edge case)
-        console.debug(`Path component ${currentDir} exists but is not a directory`);
-        return null;
-      } catch (error: any) {
-        if (error.code === 'ENOENT') {
-          // Directory doesn't exist, move up one level
-          const parentDir = path.dirname(currentDir);
-          if (parentDir === currentDir) {
-            // Reached filesystem root without finding existing directory
-            return null;
-          }
-          currentDir = parentDir;
-        } else {
-          // Unexpected error (permissions, I/O error, etc.)
-          console.debug(`Error checking directory ${currentDir}: ${error.message}`);
-          return null;
-        }
-      }
-    }
-  }
-
-  static async canWriteFile(filePath: string): Promise<boolean> {
-    try {
-      const stats = await fs.stat(filePath);
-
-      if (!stats.isFile()) {
-        return true;
-      }
-
-      // On Windows, stats.mode doesn't reliably indicate write permissions.
-      // Use fs.access with W_OK to check actual write permissions cross-platform.
-      try {
-        await fs.access(filePath, fsConstants.W_OK);
-        return true;
-      } catch {
-        return false;
-      }
-    } catch (error: any) {
-      if (error.code === 'ENOENT') {
-        // File doesn't exist - find first existing parent directory and check its permissions
-        const parentDir = path.dirname(filePath);
-        const existingDir = await this.findFirstExistingDirectory(parentDir);
-
-        if (existingDir === null) {
-          // No existing parent directory found (edge case)
-          return false;
-        }
-
-        // Check if the existing parent directory is writable
-        try {
-          await fs.access(existingDir, fsConstants.W_OK);
-          return true;
-        } catch {
-          return false;
-        }
-      }
-
-      console.debug(`Unable to determine write permissions for ${filePath}: ${error.message}`);
-      return false;
-    }
-  }
-
-  static async directoryExists(dirPath: string): Promise<boolean> {
-    try {
-      const stats = await fs.stat(dirPath);
-      return stats.isDirectory();
-    } catch (error: any) {
-      if (error.code !== 'ENOENT') {
-        console.debug(`Unable to check if directory exists at ${dirPath}: ${error.message}`);
-      }
-      return false;
-    }
-  }
-
-  static async writeFile(filePath: string, content: string): Promise<void> {
-    const dir = path.dirname(filePath);
-    await this.createDirectory(dir);
-    await fs.writeFile(filePath, content, 'utf-8');
-  }
-
-  static async readFile(filePath: string): Promise<string> {
-    return await fs.readFile(filePath, 'utf-8');
-  }
-
-  static async updateFileWithMarkers(
-    filePath: string,
-    content: string,
-    startMarker: string,
-    endMarker: string
-  ): Promise<void> {
-    let existingContent = '';
-    
-    if (await this.fileExists(filePath)) {
-      existingContent = await this.readFile(filePath);
-      
-      const startIndex = findMarkerIndex(existingContent, startMarker);
-      const endIndex = startIndex !== -1
-        ? findMarkerIndex(existingContent, endMarker, startIndex + startMarker.length)
-        : findMarkerIndex(existingContent, endMarker);
-
-      if (startIndex !== -1 && endIndex !== -1) {
-        if (endIndex < startIndex) {
-          throw new Error(
-            `Invalid marker state in ${filePath}. End marker appears before start marker.`
-          );
-        }
-
-        const before = existingContent.substring(0, startIndex);
-        const after = existingContent.substring(endIndex + endMarker.length);
-        existingContent = before + startMarker + '\n' + content + '\n' + endMarker + after;
-      } else if (startIndex === -1 && endIndex === -1) {
-        existingContent = startMarker + '\n' + content + '\n' + endMarker + '\n\n' + existingContent;
-      } else {
-        throw new Error(`Invalid marker state in ${filePath}. Found start: ${startIndex !== -1}, Found end: ${endIndex !== -1}`);
-      }
-    } else {
-      existingContent = startMarker + '\n' + content + '\n' + endMarker;
-    }
-    
-    await this.writeFile(filePath, existingContent);
-  }
-
-  static async ensureWritePermissions(dirPath: string): Promise<boolean> {
-    try {
-      // If directory doesn't exist, check parent directory permissions
-      if (!await this.directoryExists(dirPath)) {
-        const parentDir = path.dirname(dirPath);
-        if (!await this.directoryExists(parentDir)) {
-          await this.createDirectory(parentDir);
-        }
-        return await this.ensureWritePermissions(parentDir);
-      }
-      
-      const testFile = path.join(dirPath, '.prompter-test-' + Date.now());
-      await fs.writeFile(testFile, '');
-      await fs.unlink(testFile);
-      return true;
-    } catch (error: any) {
-      console.debug(`Insufficient permissions to write to ${dirPath}: ${error.message}`);
-      return false;
-    }
-  }
-}

package/src/utils/index.ts

@@ -1,12 +0,0 @@
-// Shared utilities
-export { validateChangeName, createChange } from './change-utils.js';
-export type { ValidationResult, CreateChangeOptions } from './change-utils.js';
-
-// Change metadata utilities
-export {
-  readChangeMetadata,
-  writeChangeMetadata,
-  resolveSchemaForChange,
-  validateSchemaName,
-  ChangeMetadataError,
-} from './change-metadata.js';

package/src/utils/interactive.ts

@@ -1,29 +0,0 @@
-export type InteractiveOptions = {
-  /**
-   * Explicit "disable prompts" flag passed by internal callers.
-   */
-  noInteractive?: boolean;
-  /**
-   * Commander-style negated option: `--no-interactive` sets this to false.
-   */
-  interactive?: boolean;
-};
-
-/**
- * Resolves whether non-interactive mode is requested.
- * Handles both explicit `noInteractive: true` and Commander.js style `interactive: false`.
- * Use this helper instead of manually checking options.noInteractive to avoid bugs.
- */
-export function resolveNoInteractive(value?: boolean | InteractiveOptions): boolean {
-  if (typeof value === 'boolean') return value;
-  return value?.noInteractive === true || value?.interactive === false;
-}
-
-export function isInteractive(value?: boolean | InteractiveOptions): boolean {
-  if (resolveNoInteractive(value)) return false;
-  if (process.env.OPEN_SPEC_INTERACTIVE === '0') return false;
-  // Respect the standard CI environment variable (set by GitHub Actions, GitLab CI, Travis, etc.)
-  if ('CI' in process.env) return false;
-  return !!process.stdin.isTTY;
-}
-

package/src/utils/item-discovery.ts

@@ -1,66 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-
-export async function getActiveChangeIds(root: string = process.cwd()): Promise<string[]> {
-  const changesPath = path.join(root, 'prompter', 'changes');
-  try {
-    const entries = await fs.readdir(changesPath, { withFileTypes: true });
-    const result: string[] = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === 'archive') continue;
-      const proposalPath = path.join(changesPath, entry.name, 'proposal.md');
-      try {
-        await fs.access(proposalPath);
-        result.push(entry.name);
-      } catch {
-        // skip directories without proposal.md
-      }
-    }
-    return result.sort();
-  } catch {
-    return [];
-  }
-}
-
-export async function getSpecIds(root: string = process.cwd()): Promise<string[]> {
-  const specsPath = path.join(root, 'prompter', 'specs');
-  const result: string[] = [];
-  try {
-    const entries = await fs.readdir(specsPath, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
-      const specFile = path.join(specsPath, entry.name, 'spec.md');
-      try {
-        await fs.access(specFile);
-        result.push(entry.name);
-      } catch {
-        // ignore
-      }
-    }
-  } catch {
-    // ignore
-  }
-  return result.sort();
-}
-
-export async function getArchivedChangeIds(root: string = process.cwd()): Promise<string[]> {
-  const archivePath = path.join(root, 'prompter', 'changes', 'archive');
-  try {
-    const entries = await fs.readdir(archivePath, { withFileTypes: true });
-    const result: string[] = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
-      const proposalPath = path.join(archivePath, entry.name, 'proposal.md');
-      try {
-        await fs.access(proposalPath);
-        result.push(entry.name);
-      } catch {
-        // skip directories without proposal.md
-      }
-    }
-    return result.sort();
-  } catch {
-    return [];
-  }
-}
-

package/src/utils/match.ts

@@ -1,26 +0,0 @@
-export function nearestMatches(input: string, candidates: string[], max: number = 5): string[] {
-  const scored = candidates.map(candidate => ({ candidate, distance: levenshtein(input, candidate) }));
-  scored.sort((a, b) => a.distance - b.distance);
-  return scored.slice(0, max).map(s => s.candidate);
-}
-
-export function levenshtein(a: string, b: string): number {
-  const m = a.length;
-  const n = b.length;
-  const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
-  for (let i = 0; i <= m; i++) dp[i][0] = i;
-  for (let j = 0; j <= n; j++) dp[0][j] = j;
-  for (let i = 1; i <= m; i++) {
-    for (let j = 1; j <= n; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      dp[i][j] = Math.min(
-        dp[i - 1][j] + 1,
-        dp[i][j - 1] + 1,
-        dp[i - 1][j - 1] + cost
-      );
-    }
-  }
-  return dp[m][n];
-}
-
-

package/src/utils/shell-detection.ts

@@ -1,62 +0,0 @@
-/**
- * Supported shell types for completion generation
- */
-export type SupportedShell = 'zsh' | 'bash' | 'fish' | 'powershell';
-
-/**
- * Result of shell detection
- */
-export interface ShellDetectionResult {
-  /** The detected shell if supported, otherwise undefined */
-  shell: SupportedShell | undefined;
-  /** The raw shell name detected (even if unsupported), or undefined if nothing detected */
-  detected: string | undefined;
-}
-
-/**
- * Detects the current user's shell based on environment variables
- *
- * @returns Detection result with supported shell and raw detected name
- */
-export function detectShell(): ShellDetectionResult {
-  // Try SHELL environment variable first (Unix-like systems)
-  const shellPath = process.env.SHELL;
-
-  if (shellPath) {
-    const shellName = shellPath.toLowerCase();
-
-    if (shellName.includes('zsh')) {
-      return { shell: 'zsh', detected: 'zsh' };
-    }
-    if (shellName.includes('bash')) {
-      return { shell: 'bash', detected: 'bash' };
-    }
-    if (shellName.includes('fish')) {
-      return { shell: 'fish', detected: 'fish' };
-    }
-
-    // Shell detected but not supported
-    // Extract shell name from path (e.g., /bin/tcsh -> tcsh)
-    const match = shellPath.match(/\/([^/]+)$/);
-    const detectedName = match ? match[1] : shellPath;
-    return { shell: undefined, detected: detectedName };
-  }
-
-  // Check for PowerShell on Windows
-  // PSModulePath is a reliable PowerShell-specific environment variable
-  if (process.env.PSModulePath || process.platform === 'win32') {
-    const comspec = process.env.COMSPEC?.toLowerCase();
-
-    // If PSModulePath exists, we're definitely in PowerShell
-    if (process.env.PSModulePath) {
-      return { shell: 'powershell', detected: 'powershell' };
-    }
-
-    // On Windows without PSModulePath, we might be in cmd.exe
-    if (comspec?.includes('cmd.exe')) {
-      return { shell: undefined, detected: 'cmd.exe' };
-    }
-  }
-
-  return { shell: undefined, detected: undefined };
-}

package/src/utils/task-progress.ts

@@ -1,43 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-
-const TASK_PATTERN = /^[-*]\s+\[[\sx]\]/i;
-const COMPLETED_TASK_PATTERN = /^[-*]\s+\[x\]/i;
-
-export interface TaskProgress {
-  total: number;
-  completed: number;
-}
-
-export function countTasksFromContent(content: string): TaskProgress {
-  const lines = content.split('\n');
-  let total = 0;
-  let completed = 0;
-  for (const line of lines) {
-    if (line.match(TASK_PATTERN)) {
-      total++;
-      if (line.match(COMPLETED_TASK_PATTERN)) {
-        completed++;
-      }
-    }
-  }
-  return { total, completed };
-}
-
-export async function getTaskProgressForChange(changesDir: string, changeName: string): Promise<TaskProgress> {
-  const tasksPath = path.join(changesDir, changeName, 'tasks.md');
-  try {
-    const content = await fs.readFile(tasksPath, 'utf-8');
-    return countTasksFromContent(content);
-  } catch {
-    return { total: 0, completed: 0 };
-  }
-}
-
-export function formatTaskStatus(progress: TaskProgress): string {
-  if (progress.total === 0) return 'No tasks';
-  if (progress.completed === progress.total) return '✓ Complete';
-  return `${progress.completed}/${progress.total} tasks`;
-}
-
-

package/tsconfig.json

@@ -1,28 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ES2022",
-        "module": "NodeNext",
-        "moduleResolution": "NodeNext",
-        "lib": [
-            "ES2022"
-        ],
-        "outDir": "./dist",
-        "rootDir": "./src",
-        "strict": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "forceConsistentCasingInFileNames": true,
-        "resolveJsonModule": true,
-        "declaration": true,
-        "declarationMap": true,
-        "sourceMap": true
-    },
-    "include": [
-        "src/**/*"
-    ],
-    "exclude": [
-        "node_modules",
-        "dist",
-        "test"
-    ]
-}