@lumy-pack/syncpoint 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -49,6 +49,14 @@ async function fileExists(filePath) {
     return false;
   }
 }
+async function isDirectory(filePath) {
+  try {
+    const stats = await stat(filePath);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
 
 // src/constants.ts
 var APP_NAME = "syncpoint";
@@ -64,7 +72,6 @@ var LOGS_DIR = "logs";
 function getAppDir() {
   return join2(getHomeDir(), APP_DIR);
 }
-var APP_VERSION = "0.0.1";
 function getSubDir(sub) {
   return join2(getAppDir(), sub);
 }
@@ -72,8 +79,106 @@ function getSubDir(sub) {
 // src/schemas/ajv.ts
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
+
+// src/utils/pattern.ts
+import micromatch from "micromatch";
+function detectPatternType(pattern) {
+  if (pattern.startsWith("/") && pattern.endsWith("/") && pattern.length > 2) {
+    const inner = pattern.slice(1, -1);
+    const hasUnescapedSlash = /(?<!\\)\//.test(inner);
+    if (!hasUnescapedSlash) {
+      return "regex";
+    }
+  }
+  if (pattern.includes("*") || pattern.includes("?") || pattern.includes("{")) {
+    return "glob";
+  }
+  return "literal";
+}
+function parseRegexPattern(pattern) {
+  if (!pattern.startsWith("/") || !pattern.endsWith("/")) {
+    throw new Error(
+      `Invalid regex pattern format: ${pattern}. Must be enclosed in slashes like /pattern/`
+    );
+  }
+  const regexBody = pattern.slice(1, -1);
+  try {
+    return new RegExp(regexBody);
+  } catch (error) {
+    throw new Error(
+      `Invalid regex pattern: ${pattern}. ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function createExcludeMatcher(excludePatterns) {
+  if (excludePatterns.length === 0) {
+    return () => false;
+  }
+  const regexPatterns = [];
+  const globPatterns = [];
+  const literalPatterns = /* @__PURE__ */ new Set();
+  for (const pattern of excludePatterns) {
+    const type = detectPatternType(pattern);
+    if (type === "regex") {
+      try {
+        regexPatterns.push(parseRegexPattern(pattern));
+      } catch {
+        console.warn(`Skipping invalid regex pattern: ${pattern}`);
+      }
+    } else if (type === "glob") {
+      globPatterns.push(pattern);
+    } else {
+      literalPatterns.add(pattern);
+    }
+  }
+  return (filePath) => {
+    if (literalPatterns.has(filePath)) {
+      return true;
+    }
+    if (globPatterns.length > 0 && micromatch.isMatch(filePath, globPatterns, {
+      dot: true,
+      // Match dotfiles
+      matchBase: false
+      // Don't use basename matching, match full path
+    })) {
+      return true;
+    }
+    for (const regex of regexPatterns) {
+      if (regex.test(filePath)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+function isValidPattern(pattern) {
+  if (typeof pattern !== "string" || pattern.length === 0) {
+    return false;
+  }
+  const type = detectPatternType(pattern);
+  if (type === "regex") {
+    try {
+      parseRegexPattern(pattern);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/schemas/ajv.ts
 var ajv = new Ajv({ allErrors: true });
 addFormats(ajv);
+ajv.addKeyword({
+  keyword: "validPattern",
+  type: "string",
+  validate: function validate(schema, data) {
+    if (!schema) return true;
+    return isValidPattern(data);
+  },
+  errors: true
+});
 
 // src/schemas/config.schema.ts
 var configSchema = {
@@ -86,11 +191,11 @@ var configSchema = {
       properties: {
         targets: {
           type: "array",
-          items: { type: "string" }
+          items: { type: "string", validPattern: true }
         },
         exclude: {
           type: "array",
-          items: { type: "string" }
+          items: { type: "string", validPattern: true }
         },
         filename: {
           type: "string",
@@ -114,11 +219,11 @@ var configSchema = {
   },
   additionalProperties: false
 };
-var validate = ajv.compile(configSchema);
+var validate2 = ajv.compile(configSchema);
 function validateConfig(data) {
-  const valid = validate(data);
+  const valid = validate2(data);
   if (valid) return { valid: true };
-  const errors = validate.errors?.map(
+  const errors = validate2.errors?.map(
     (e) => `${e.instancePath || "/"} ${e.message ?? "unknown error"}`
   );
   return { valid: false, errors };
@@ -170,20 +275,16 @@ Run "syncpoint init" first.`
   const data = stripDangerousKeys(YAML.parse(raw));
   const result = validateConfig(data);
   if (!result.valid) {
-    throw new Error(
-      `Invalid config:
-${(result.errors ?? []).join("\n")}`
-    );
+    throw new Error(`Invalid config:
+${(result.errors ?? []).join("\n")}`);
   }
   return data;
 }
 async function saveConfig(config) {
   const result = validateConfig(config);
   if (!result.valid) {
-    throw new Error(
-      `Invalid config:
-${(result.errors ?? []).join("\n")}`
-    );
+    throw new Error(`Invalid config:
+${(result.errors ?? []).join("\n")}`);
   }
   const configPath = getConfigPath();
   await ensureDir(getAppDir());
@@ -223,11 +324,11 @@ async function initDefaultConfig() {
 
 // src/core/backup.ts
 import { readdir } from "fs/promises";
-import { join as join7, basename } from "path";
+import { basename, join as join7 } from "path";
 import fg from "fast-glob";
 
 // src/utils/system.ts
-import { hostname as osHostname, platform, release, arch } from "os";
+import { arch, hostname as osHostname, platform, release } from "os";
 function getHostname() {
   return osHostname();
 }
@@ -240,7 +341,7 @@ function getSystemInfo() {
 }
 function formatHostname(name) {
   const raw = name ?? getHostname();
-  return raw.replace(/\s+/g, "-").replace(/\./g, "-").replace(/[^a-zA-Z0-9\-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return raw.replace(/\s+/g, "-").replace(/\./g, "-").replace(/[^a-zA-Z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
 
 // src/utils/format.ts
@@ -332,7 +433,7 @@ var logger = {
 
 // src/core/metadata.ts
 import { createHash } from "crypto";
-import { readFile as readFile2, lstat } from "fs/promises";
+import { lstat, readFile as readFile2 } from "fs/promises";
 
 // src/schemas/metadata.schema.ts
 var metadataSchema = {
@@ -398,23 +499,26 @@ var metadataSchema = {
   },
   additionalProperties: false
 };
-var validate2 = ajv.compile(metadataSchema);
+var validate3 = ajv.compile(metadataSchema);
 function validateMetadata(data) {
-  const valid = validate2(data);
+  const valid = validate3(data);
   if (valid) return { valid: true };
-  const errors = validate2.errors?.map(
+  const errors = validate3.errors?.map(
     (e) => `${e.instancePath || "/"} ${e.message ?? "unknown error"}`
   );
   return { valid: false, errors };
 }
 
+// src/version.ts
+var VERSION = "0.0.2";
+
 // src/core/metadata.ts
 var METADATA_VERSION = "1.0.0";
 function createMetadata(files, config) {
   const totalSize = files.reduce((sum, f) => sum + f.size, 0);
   return {
     version: METADATA_VERSION,
-    toolVersion: APP_VERSION,
+    toolVersion: VERSION,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     hostname: getHostname(),
     system: getSystemInfo(),
@@ -434,10 +538,8 @@ function parseMetadata(data) {
   const parsed = JSON.parse(str);
   const result = validateMetadata(parsed);
   if (!result.valid) {
-    throw new Error(
-      `Invalid metadata:
-${(result.errors ?? []).join("\n")}`
-    );
+    throw new Error(`Invalid metadata:
+${(result.errors ?? []).join("\n")}`);
   }
   return parsed;
 }
@@ -453,6 +555,9 @@ async function collectFileInfo(absolutePath, logicalPath) {
     type = "symlink";
   } else if (lstats.isDirectory()) {
     type = "directory";
+    throw new Error(
+      `Cannot collect file info for directory: ${logicalPath}. Directories should be converted to glob patterns before calling collectFileInfo().`
+    );
   }
   let hash;
   if (lstats.isSymbolicLink()) {
@@ -480,7 +585,10 @@ async function createArchive(files, outputPath) {
     const fileNames = [];
     for (const file of files) {
       const targetPath = join6(tmpDir, file.name);
-      const parentDir = join6(tmpDir, file.name.split("/").slice(0, -1).join("/"));
+      const parentDir = join6(
+        tmpDir,
+        file.name.split("/").slice(0, -1).join("/")
+      );
       if (parentDir !== tmpDir) {
         await mkdir3(parentDir, { recursive: true });
       }
@@ -557,18 +665,48 @@ function isSensitiveFile(filePath) {
 async function scanTargets(config) {
   const found = [];
   const missing = [];
+  const isExcluded = createExcludeMatcher(config.backup.exclude);
   for (const target of config.backup.targets) {
     const expanded = expandTilde(target);
-    if (expanded.includes("*") || expanded.includes("?") || expanded.includes("{")) {
+    const patternType = detectPatternType(expanded);
+    if (patternType === "regex") {
+      try {
+        const regex = parseRegexPattern(expanded);
+        const homeDir = expandTilde("~/");
+        const homeDirNormalized = homeDir.endsWith("/") ? homeDir : `${homeDir}/`;
+        const allFiles = await fg(`${homeDirNormalized}**`, {
+          dot: true,
+          absolute: true,
+          onlyFiles: true,
+          deep: 5
+          // Limit depth for performance
+        });
+        for (const match of allFiles) {
+          if (regex.test(match) && !isExcluded(match)) {
+            const entry = await collectFileInfo(match, match);
+            found.push(entry);
+          }
+        }
+      } catch (error) {
+        logger.warn(
+          `Invalid regex pattern "${target}": ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    } else if (patternType === "glob") {
+      const globExcludes = config.backup.exclude.filter(
+        (p) => detectPatternType(p) === "glob"
+      );
       const matches = await fg(expanded, {
         dot: true,
         absolute: true,
-        ignore: config.backup.exclude,
+        ignore: globExcludes,
         onlyFiles: true
       });
       for (const match of matches) {
-        const entry = await collectFileInfo(match, match);
-        found.push(entry);
+        if (!isExcluded(match)) {
+          const entry = await collectFileInfo(match, match);
+          found.push(entry);
+        }
       }
     } else {
       const absPath = resolveTargetPath(target);
@@ -577,16 +715,43 @@ async function scanTargets(config) {
         missing.push(target);
         continue;
       }
-      const entry = await collectFileInfo(absPath, absPath);
-      if (entry.size > LARGE_FILE_THRESHOLD) {
-        logger.warn(
-          `Large file (>${Math.round(LARGE_FILE_THRESHOLD / 1024 / 1024)}MB): ${target}`
+      const isDir = await isDirectory(absPath);
+      if (isDir) {
+        const dirGlob = `${expanded}/**/*`;
+        const globExcludes = config.backup.exclude.filter(
+          (p) => detectPatternType(p) === "glob"
         );
+        const matches = await fg(dirGlob, {
+          dot: true,
+          absolute: true,
+          ignore: globExcludes,
+          onlyFiles: true
+          // Only include files, not subdirectories
+        });
+        for (const match of matches) {
+          if (!isExcluded(match)) {
+            const entry = await collectFileInfo(match, match);
+            found.push(entry);
+          }
+        }
+        if (matches.length === 0) {
+          logger.warn(`Directory is empty or fully excluded: ${target}`);
+        }
+      } else {
+        if (isExcluded(absPath)) {
+          continue;
+        }
+        const entry = await collectFileInfo(absPath, absPath);
+        if (entry.size > LARGE_FILE_THRESHOLD) {
+          logger.warn(
+            `Large file (>${Math.round(LARGE_FILE_THRESHOLD / 1024 / 1024)}MB): ${target}`
+          );
+        }
+        if (isSensitiveFile(absPath)) {
+          logger.warn(`Sensitive file detected: ${target}`);
+        }
+        found.push(entry);
       }
-      if (isSensitiveFile(absPath)) {
-        logger.warn(`Sensitive file detected: ${target}`);
-      }
-      found.push(entry);
     }
   }
   return { found, missing };
@@ -612,8 +777,10 @@ async function collectScripts() {
 }
 async function createBackup(config, options = {}) {
   const { found, missing } = await scanTargets(config);
-  for (const m of missing) {
-    logger.warn(`File not found, skipping: ${m}`);
+  if (options.verbose && missing.length > 0) {
+    for (const m of missing) {
+      logger.warn(`File not found, skipping: ${m}`);
+    }
   }
   let allFiles = [...found];
   if (config.scripts.includeInBackup) {
@@ -652,7 +819,7 @@ async function createBackup(config, options = {}) {
 
 // src/core/restore.ts
 import { copyFile, lstat as lstat2, readdir as readdir2, stat as stat2 } from "fs/promises";
-import { join as join8, dirname as dirname2 } from "path";
+import { dirname as dirname2, join as join8 } from "path";
 async function getBackupList(config) {
   const backupDir = config?.backup.destination ? resolveTargetPath(config.backup.destination) : getSubDir(BACKUPS_DIR);
   const exists = await fileExists(backupDir);
@@ -842,11 +1009,11 @@ var templateSchema = {
   },
   additionalProperties: false
 };
-var validate3 = ajv.compile(templateSchema);
+var validate4 = ajv.compile(templateSchema);
 function validateTemplate(data) {
-  const valid = validate3(data);
+  const valid = validate4(data);
   if (valid) return { valid: true };
-  const errors = validate3.errors?.map(
+  const errors = validate4.errors?.map(
     (e) => `${e.instancePath || "/"} ${e.message ?? "unknown error"}`
   );
   return { valid: false, errors };
@@ -930,7 +1097,9 @@ function execAsync(command) {
 }
 async function evaluateSkipIf(command, stepName) {
   if (containsRemoteScriptPattern(command)) {
-    throw new Error(`Blocked dangerous remote script pattern in skip_if: ${stepName}`);
+    throw new Error(
+      `Blocked dangerous remote script pattern in skip_if: ${stepName}`
+    );
   }
   try {
     await execAsync(command);
@@ -942,7 +1111,9 @@ async function evaluateSkipIf(command, stepName) {
 async function executeStep(step) {
   const startTime = Date.now();
   if (containsRemoteScriptPattern(step.command)) {
-    throw new Error(`Blocked dangerous remote script pattern in command: ${step.name}`);
+    throw new Error(
+      `Blocked dangerous remote script pattern in command: ${step.name}`
+    );
   }
   if (step.skip_if) {
     const shouldSkip = await evaluateSkipIf(step.skip_if, step.name);
@@ -996,9 +1167,7 @@ async function* runProvision(templatePath, options = {}) {
     const result = await executeStep(step);
     yield result;
     if (result.status === "failed" && !step.continue_on_error) {
-      logger.error(
-        `Step "${step.name}" failed. Stopping provisioning.`
-      );
+      logger.error(`Step "${step.name}" failed. Stopping provisioning.`);
       return;
     }
   }

package/dist/prompts/wizard-config.d.ts

@@ -0,0 +1,9 @@
+import type { FileStructure } from '../utils/file-scanner.js';
+export interface ConfigPromptVariables {
+    fileStructure: FileStructure;
+    defaultConfig: string;
+}
+/**
+ * Generate the LLM prompt for config wizard
+ */
+export declare function generateConfigWizardPrompt(variables: ConfigPromptVariables): string;

package/dist/prompts/wizard-template.d.ts

@@ -0,0 +1,7 @@
+export interface TemplatePromptVariables {
+    exampleTemplate: string;
+}
+/**
+ * Generate the LLM prompt for template creation wizard
+ */
+export declare function generateTemplateWizardPrompt(variables: TemplatePromptVariables): string;

package/dist/schemas/ajv.d.ts

@@ -1,3 +1,3 @@
-import Ajv from "ajv";
+import Ajv from 'ajv';
 declare const ajv: Ajv;
 export { ajv };

package/dist/utils/claude-code-runner.d.ts

@@ -0,0 +1,29 @@
+export interface ClaudeCodeResult {
+    success: boolean;
+    output: string;
+    error?: string;
+    sessionId?: string;
+}
+/**
+ * Check if Claude Code CLI is available
+ */
+export declare function isClaudeCodeAvailable(): Promise<boolean>;
+/**
+ * Invoke Claude Code in edit mode with a prompt
+ */
+export declare function invokeClaudeCode(prompt: string, options?: {
+    sessionId?: string;
+    timeout?: number;
+}): Promise<ClaudeCodeResult>;
+/**
+ * Resume a Claude Code session with additional context
+ */
+export declare function resumeClaudeCodeSession(sessionId: string, prompt: string, options?: {
+    timeout?: number;
+}): Promise<ClaudeCodeResult>;
+/**
+ * Invoke Claude Code in interactive mode
+ * User can directly interact with Claude Code UI
+ * @param prompt - Context prompt with file structure
+ */
+export declare function invokeClaudeCodeInteractive(prompt: string): Promise<ClaudeCodeResult>;

package/dist/utils/command-registry.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Central command registry for syncpoint CLI
+ * This ensures consistency between custom help and Commander.js --help
+ */
+export interface CommandOption {
+    flag: string;
+    description: string;
+    default?: string;
+}
+export interface CommandArgument {
+    name: string;
+    description: string;
+    required: boolean;
+}
+export interface CommandInfo {
+    name: string;
+    description: string;
+    usage: string;
+    arguments?: CommandArgument[];
+    options?: CommandOption[];
+    examples?: string[];
+}
+export declare const COMMANDS: Record<string, CommandInfo>;

package/dist/utils/error-formatter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Format validation errors for human-readable feedback to LLM
+ */
+export declare function formatValidationErrors(errors: string[]): string;
+/**
+ * Create a retry prompt with validation error context
+ */
+export declare function createRetryPrompt(originalPrompt: string, errors: string[], attemptNumber: number): string;
+/**
+ * Format error for display in terminal UI
+ */
+export declare function formatErrorForDisplay(error: string | Error): string;
+/**
+ * Create user-friendly error messages
+ */
+export declare function createUserFriendlyError(context: string, error: unknown): string;

package/dist/utils/file-scanner.d.ts

@@ -0,0 +1,25 @@
+export interface FileCategory {
+    category: string;
+    files: string[];
+}
+export interface FileStructure {
+    homeDir: string;
+    categories: FileCategory[];
+    totalFiles: number;
+}
+/**
+ * Scan home directory and categorize files for backup suggestions
+ */
+export declare function scanHomeDirectory(options?: {
+    maxDepth?: number;
+    maxFiles?: number;
+    ignorePatterns?: string[];
+}): Promise<FileStructure>;
+/**
+ * Convert file structure to JSON format for LLM prompt
+ */
+export declare function fileStructureToJSON(structure: FileStructure): string;
+/**
+ * Get a list of recommended backup targets based on scan results
+ */
+export declare function getRecommendedTargets(structure: FileStructure): string[];

package/dist/utils/paths.d.ts

@@ -19,4 +19,9 @@ export declare function ensureDir(dirPath: string): Promise<void>;
  * Check if a file exists.
  */
 export declare function fileExists(filePath: string): Promise<boolean>;
+/**
+ * Check if a path is a directory.
+ * Returns false if path doesn't exist or is not a directory.
+ */
+export declare function isDirectory(filePath: string): Promise<boolean>;
 export declare function isInsideDir(filePath: string, dir: string): boolean;

package/dist/utils/pattern.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Pattern type classification for targets and excludes.
+ */
+export type PatternType = 'literal' | 'glob' | 'regex';
+/**
+ * Detect the type of a pattern string.
+ *
+ * Rules:
+ * - Regex: Starts and ends with `/`, and the content between doesn't contain unescaped `/`
+ *   Example: `/\.conf$/`, `/test/` (simple)
+ * - Glob: Contains glob metacharacters: `*`, `?`, `{`
+ *   Example: `*.conf`, `~/.config/{a,b}`
+ * - Literal: Everything else
+ *   Example: `~/.zshrc`, `/usr/local/bin`
+ *
+ * Special handling for absolute paths vs regex:
+ * - `/usr/local/bin` is literal (multiple `/` inside, not at boundaries)
+ * - `/test/` is regex (starts and ends with `/`, single segment inside)
+ * - `/\.conf$/` is regex (starts and ends with `/`, no unescaped `/` inside)
+ */
+export declare function detectPatternType(pattern: string): PatternType;
+/**
+ * Parse a regex pattern string (e.g., `/\.conf$/`) into a RegExp object.
+ *
+ * @throws {Error} If the pattern is invalid regex syntax
+ */
+export declare function parseRegexPattern(pattern: string): RegExp;
+/**
+ * Create an optimized exclude matcher function.
+ *
+ * This function pre-compiles all patterns for efficient repeated matching.
+ * It handles three pattern types: glob, regex, and literal.
+ *
+ * @param excludePatterns - Array of exclude pattern strings
+ * @returns A function that tests if a file path should be excluded
+ */
+export declare function createExcludeMatcher(excludePatterns: string[]): (filePath: string) => boolean;
+/**
+ * Validate that a pattern string is well-formed.
+ *
+ * Used for schema validation at config load time.
+ *
+ * @param pattern - Pattern string to validate
+ * @returns true if valid, false otherwise
+ */
+export declare function isValidPattern(pattern: string): boolean;

package/dist/utils/types.d.ts

@@ -65,7 +65,7 @@ export interface RestorePlan {
 }
 export interface RestoreAction {
     path: string;
-    action: "overwrite" | "skip" | "create";
+    action: 'overwrite' | 'skip' | 'create';
     currentSize?: number;
     backupSize?: number;
     reason: string;
@@ -76,7 +76,7 @@ export interface ProvisionResult {
 }
 export interface StepResult {
     name: string;
-    status: "success" | "skipped" | "failed" | "running" | "pending";
+    status: 'success' | 'skipped' | 'failed' | 'running' | 'pending';
     duration?: number;
     error?: string;
     output?: string;
@@ -84,6 +84,7 @@ export interface StepResult {
 export interface BackupOptions {
     dryRun?: boolean;
     tag?: string;
+    verbose?: boolean;
 }
 export interface RestoreOptions {
     dryRun?: boolean;
@@ -121,7 +122,7 @@ export interface StatusInfo {
     oldestBackup?: Date;
 }
 export interface CleanupPolicy {
-    type: "keep-recent" | "older-than" | "select";
+    type: 'keep-recent' | 'older-than' | 'select';
     count?: number;
     days?: number;
     indices?: number[];

package/dist/utils/yaml-parser.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Extract YAML content from LLM response
+ * Handles markdown code blocks and pure YAML
+ * Rejects plain text and scalar values
+ */
+export declare function extractYAML(response: string): string | null;
+/**
+ * Parse YAML string to object
+ */
+export declare function parseYAML<T = unknown>(yamlString: string): T;
+/**
+ * Extract and parse YAML from LLM response
+ */
+export declare function extractAndParseYAML<T = unknown>(response: string): T | null;
+/**
+ * Extract config-specific YAML (requires 'backup:' key)
+ * More strict validation for Syncpoint config files
+ */
+export declare function extractConfigYAML(response: string): string | null;