@fractary/codex-cli 0.8.0 → 0.9.1

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import * as path4 from 'path';
+import * as path5 from 'path';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import * as fs from 'fs/promises';
@@ -161,7 +161,7 @@ async function migrateConfig(legacyConfigPath, options) {
   }
 }
 async function writeYamlConfig(config, outputPath) {
-  const dir = path4.dirname(outputPath);
+  const dir = path5.dirname(outputPath);
   await fs.mkdir(dir, { recursive: true });
   const yamlContent = yaml.dump(config, {
     indent: 2,
@@ -385,7 +385,7 @@ var init_codex_client = __esm({
         const { readYamlConfig: readYamlConfig2 } = await Promise.resolve().then(() => (init_migrate_config(), migrate_config_exports));
         const { resolveEnvVarsInConfig: resolveEnvVarsInConfig2 } = await Promise.resolve().then(() => (init_config_types(), config_types_exports));
         try {
-          const configPath = path4.join(process.cwd(), ".fractary", "codex", "config.yaml");
+          const configPath = path5.join(process.cwd(), ".fractary", "codex", "config.yaml");
           let config;
           try {
             config = await readYamlConfig2(configPath);
@@ -655,7 +655,7 @@ function getTempCodexPath(config) {
   const codexRepo = config.codex_repository || "codex";
   const sanitizedOrg = sanitizePathComponent(config.organization);
   const sanitizedRepo = sanitizePathComponent(codexRepo);
-  return path4.join(
+  return path5.join(
     os.tmpdir(),
     "fractary-codex-clone",
     `${sanitizedOrg}-${sanitizedRepo}-${process.pid}`
@@ -663,7 +663,7 @@ function getTempCodexPath(config) {
 }
 async function isValidGitRepo(repoPath) {
   try {
-    const gitDir = path4.join(repoPath, ".git");
+    const gitDir = path5.join(repoPath, ".git");
     const stats = await fs.stat(gitDir);
     return stats.isDirectory();
   } catch {
@@ -696,7 +696,7 @@ async function execGit(repoPath, args) {
   }
 }
 async function gitClone(url, targetPath, options) {
-  const parentDir = path4.dirname(targetPath);
+  const parentDir = path5.dirname(targetPath);
   await fs.mkdir(parentDir, { recursive: true });
   const args = ["clone"];
   if (options?.depth) {
@@ -868,7 +868,229 @@ init_esm_shims();
 
 // src/commands/config/init.ts
 init_esm_shims();
-init_migrate_config();
+
+// src/config/unified-config.ts
+init_esm_shims();
+function sanitizeForS3BucketName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-").substring(0, 63);
+}
+function getDefaultUnifiedConfig(organization, project) {
+  const sanitizedProject = sanitizeForS3BucketName(project);
+  return {
+    file: {
+      schema_version: "2.0",
+      sources: {
+        specs: {
+          type: "s3",
+          bucket: `${sanitizedProject}-files`,
+          prefix: "specs/",
+          region: "us-east-1",
+          local: {
+            base_path: ".fractary/specs"
+          },
+          push: {
+            compress: false,
+            keep_local: true
+          },
+          auth: {
+            profile: "default"
+          }
+        },
+        logs: {
+          type: "s3",
+          bucket: `${sanitizedProject}-files`,
+          prefix: "logs/",
+          region: "us-east-1",
+          local: {
+            base_path: ".fractary/logs"
+          },
+          push: {
+            compress: true,
+            keep_local: true
+          },
+          auth: {
+            profile: "default"
+          }
+        }
+      }
+    },
+    codex: {
+      schema_version: "2.0",
+      organization,
+      project,
+      dependencies: {}
+    }
+  };
+}
+async function readUnifiedConfig(configPath) {
+  try {
+    const content = await fs.readFile(configPath, "utf-8");
+    const config = yaml.load(content);
+    return config;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeUnifiedConfig(config, outputPath) {
+  const dir = path5.dirname(outputPath);
+  await fs.mkdir(dir, { recursive: true });
+  const yamlContent = yaml.dump(config, {
+    indent: 2,
+    lineWidth: 120,
+    noRefs: true,
+    sortKeys: false
+  });
+  await fs.writeFile(outputPath, yamlContent, "utf-8");
+}
+function mergeUnifiedConfigs(existing, updates) {
+  const merged = {};
+  if (updates.file || existing.file) {
+    merged.file = {
+      schema_version: updates.file?.schema_version || existing.file?.schema_version || "2.0",
+      sources: {
+        ...existing.file?.sources || {},
+        ...updates.file?.sources || {}
+      }
+    };
+  }
+  if (updates.codex || existing.codex) {
+    merged.codex = {
+      schema_version: updates.codex?.schema_version || existing.codex?.schema_version || "2.0",
+      organization: updates.codex?.organization || existing.codex?.organization || "default",
+      project: updates.codex?.project || existing.codex?.project || "default",
+      dependencies: {
+        ...existing.codex?.dependencies || {},
+        ...updates.codex?.dependencies || {}
+      }
+    };
+  }
+  return merged;
+}
+async function initializeUnifiedConfig(configPath, organization, project, options) {
+  const existingConfig = await readUnifiedConfig(configPath);
+  if (existingConfig && !options?.force) {
+    const defaultConfig = getDefaultUnifiedConfig(organization, project);
+    const merged = mergeUnifiedConfigs(existingConfig, defaultConfig);
+    await writeUnifiedConfig(merged, configPath);
+    return {
+      created: false,
+      merged: true,
+      config: merged
+    };
+  }
+  const config = getDefaultUnifiedConfig(organization, project);
+  await writeUnifiedConfig(config, configPath);
+  return {
+    created: true,
+    merged: false,
+    config
+  };
+}
+
+// src/config/gitignore-utils.ts
+init_esm_shims();
+var DEFAULT_FRACTARY_GITIGNORE = `# .fractary/.gitignore
+# This file is managed by multiple plugins - each plugin manages its own section
+
+# ===== fractary-codex (managed) =====
+codex/cache/
+# ===== end fractary-codex =====
+`;
+var DEFAULT_CACHE_DIR = "codex/cache/";
+async function readFractaryGitignore(projectRoot) {
+  const gitignorePath = path5.join(projectRoot, ".fractary", ".gitignore");
+  try {
+    return await fs.readFile(gitignorePath, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeFractaryGitignore(projectRoot, content) {
+  const gitignorePath = path5.join(projectRoot, ".fractary", ".gitignore");
+  await fs.mkdir(path5.join(projectRoot, ".fractary"), { recursive: true });
+  await fs.writeFile(gitignorePath, content, "utf-8");
+}
+function normalizeCachePath(cachePath) {
+  let normalized = cachePath.replace(/\\/g, "/");
+  normalized = normalized.replace(/^\.fractary\//, "");
+  if (!normalized.endsWith("/")) {
+    normalized += "/";
+  }
+  return normalized;
+}
+function isCachePathIgnored(gitignoreContent, cachePath) {
+  const normalized = normalizeCachePath(cachePath);
+  const lines = gitignoreContent.split("\n").map((l) => l.trim());
+  return lines.some((line) => {
+    if (line.startsWith("#") || line === "") return false;
+    let normalizedLine = line.replace(/\\/g, "/");
+    if (!normalizedLine.endsWith("/")) {
+      normalizedLine += "/";
+    }
+    return normalizedLine === normalized;
+  });
+}
+function addCachePathToGitignore(gitignoreContent, cachePath, comment) {
+  const normalized = normalizeCachePath(cachePath);
+  if (isCachePathIgnored(gitignoreContent, cachePath)) {
+    return gitignoreContent;
+  }
+  let addition = "";
+  {
+    addition += `
+# ${comment}
+`;
+  }
+  addition += normalized + "\n";
+  return gitignoreContent.trimEnd() + addition;
+}
+async function ensureCachePathIgnored(projectRoot, cachePath) {
+  const gitignorePath = path5.join(projectRoot, ".fractary", ".gitignore");
+  let relativeCachePath = cachePath;
+  if (path5.isAbsolute(cachePath)) {
+    relativeCachePath = path5.relative(path5.join(projectRoot, ".fractary"), cachePath);
+  }
+  relativeCachePath = normalizeCachePath(relativeCachePath);
+  let content = await readFractaryGitignore(projectRoot);
+  const gitignoreExists = content !== null;
+  if (!gitignoreExists) {
+    content = DEFAULT_FRACTARY_GITIGNORE;
+    if (!isCachePathIgnored(content, relativeCachePath)) {
+      content = addCachePathToGitignore(content, relativeCachePath, "Custom cache directory");
+    }
+    await writeFractaryGitignore(projectRoot, content);
+    return {
+      created: true,
+      updated: false,
+      alreadyIgnored: false,
+      gitignorePath
+    };
+  }
+  if (isCachePathIgnored(content, relativeCachePath)) {
+    return {
+      created: false,
+      updated: false,
+      alreadyIgnored: true,
+      gitignorePath
+    };
+  }
+  content = addCachePathToGitignore(content, relativeCachePath, "Custom cache directory");
+  await writeFractaryGitignore(projectRoot, content);
+  return {
+    created: false,
+    updated: true,
+    alreadyIgnored: false,
+    gitignorePath
+  };
+}
+
+// src/commands/config/init.ts
 async function getOrgFromGitRemote() {
   try {
     const { execSync } = __require("child_process");
@@ -890,9 +1112,9 @@ async function fileExists(filePath) {
 }
 function initCommand() {
   const cmd = new Command("init");
-  cmd.description("Initialize Codex v3.0 with YAML configuration").option("--org <slug>", 'Organization slug (e.g., "fractary")').option("--mcp", "Enable MCP server registration").option("--force", "Overwrite existing configuration").action(async (options) => {
+  cmd.description("Initialize unified Fractary configuration (.fractary/config.yaml)").option("--org <slug>", 'Organization slug (e.g., "fractary")').option("--project <name>", "Project name (default: derived from directory)").option("--force", "Overwrite existing configuration").action(async (options) => {
     try {
-      console.log(chalk8.blue("Initializing Codex v3.0 (YAML format)...\n"));
+      console.log(chalk8.blue("Initializing unified Fractary configuration...\n"));
       let org = options.org;
       if (!org) {
         org = await getOrgFromGitRemote();
@@ -901,60 +1123,79 @@ function initCommand() {
         try {
           const { resolveOrganization } = await import('@fractary/codex');
           org = resolveOrganization({
-            repoName: path4.basename(process.cwd())
+            repoName: path5.basename(process.cwd())
           });
         } catch {
         }
       }
       if (!org) {
-        org = path4.basename(process.cwd()).split("-")[0] || "default";
+        org = path5.basename(process.cwd()).split("-")[0] || "default";
         console.log(chalk8.yellow(`\u26A0 Could not detect organization, using: ${org}`));
         console.log(chalk8.dim("  Use --org <slug> to specify explicitly\n"));
       } else {
         console.log(chalk8.dim(`Organization: ${chalk8.cyan(org)}
 `));
       }
-      const configDir = path4.join(process.cwd(), ".fractary", "codex");
-      const configPath = path4.join(configDir, "config.yaml");
+      let project = options.project;
+      if (!project) {
+        project = path5.basename(process.cwd());
+        console.log(chalk8.dim(`Project: ${chalk8.cyan(project)}
+`));
+      }
+      const configPath = path5.join(process.cwd(), ".fractary", "config.yaml");
       const configExists = await fileExists(configPath);
       if (configExists && !options.force) {
-        console.log(chalk8.yellow("\u26A0 Configuration already exists at .fractary/codex/config.yaml"));
-        console.log(chalk8.dim("Use --force to overwrite"));
-        process.exit(1);
+        console.log(chalk8.yellow(`\u26A0 Configuration already exists at .fractary/config.yaml`));
+        console.log(chalk8.dim("Merging with existing configuration...\n"));
       }
       console.log("Creating directory structure...");
       const dirs = [
+        ".fractary",
+        ".fractary/specs",
+        ".fractary/logs",
         ".fractary/codex",
         ".fractary/codex/cache"
       ];
       for (const dir of dirs) {
-        await fs.mkdir(path4.join(process.cwd(), dir), { recursive: true });
+        await fs.mkdir(path5.join(process.cwd(), dir), { recursive: true });
         console.log(chalk8.green("\u2713"), chalk8.dim(dir + "/"));
       }
-      console.log("\nCreating YAML configuration...");
-      const config = getDefaultYamlConfig(org);
-      if (options.mcp && config.mcp) {
-        config.mcp.enabled = true;
+      const gitignoreResult = await ensureCachePathIgnored(process.cwd(), ".fractary/codex/cache");
+      if (gitignoreResult.created) {
+        console.log(chalk8.green("\u2713"), chalk8.dim(".fractary/.gitignore (created)"));
+      } else if (gitignoreResult.updated) {
+        console.log(chalk8.green("\u2713"), chalk8.dim(".fractary/.gitignore (updated)"));
+      } else {
+        console.log(chalk8.green("\u2713"), chalk8.dim(".fractary/.gitignore (exists)"));
+      }
+      console.log("\nInitializing configuration...");
+      const result = await initializeUnifiedConfig(
+        configPath,
+        org,
+        project,
+        { force: options.force }
+      );
+      if (result.created) {
+        console.log(chalk8.green("\u2713"), chalk8.dim(".fractary/config.yaml (created)"));
+      } else if (result.merged) {
+        console.log(chalk8.green("\u2713"), chalk8.dim(".fractary/config.yaml (merged with existing)"));
       }
-      await writeYamlConfig(config, configPath);
-      console.log(chalk8.green("\u2713"), chalk8.dim(".fractary/codex/config.yaml"));
-      console.log(chalk8.green("\n\u2713 Codex v4.0 initialized successfully!\n"));
+      console.log(chalk8.green("\n\u2713 Unified configuration initialized successfully!\n"));
       console.log(chalk8.bold("Configuration:"));
       console.log(chalk8.dim(`  Organization: ${org}`));
-      console.log(chalk8.dim(`  Cache: .fractary/codex/cache/`));
-      console.log(chalk8.dim(`  Config: .fractary/codex/config.yaml`));
-      if (options.mcp) {
-        console.log(chalk8.dim(`  MCP Server: Enabled (port 3000)`));
-      }
-      console.log(chalk8.bold("\nStorage providers configured:"));
-      console.log(chalk8.dim("  - Local filesystem (./knowledge)"));
-      console.log(chalk8.dim("  - GitHub (requires GITHUB_TOKEN)"));
-      console.log(chalk8.dim("  - HTTP endpoint"));
+      console.log(chalk8.dim(`  Project: ${project}`));
+      console.log(chalk8.dim(`  Config: .fractary/config.yaml`));
+      console.log(chalk8.bold("\nFile plugin sources:"));
+      console.log(chalk8.dim("  - specs: .fractary/specs/ \u2192 S3"));
+      console.log(chalk8.dim("  - logs: .fractary/logs/ \u2192 S3"));
+      console.log(chalk8.bold("\nCodex plugin:"));
+      console.log(chalk8.dim("  - Cache: .fractary/codex/cache/"));
+      console.log(chalk8.dim("  - Dependencies: (none configured)"));
       console.log(chalk8.bold("\nNext steps:"));
-      console.log(chalk8.dim('  1. Set your GitHub token: export GITHUB_TOKEN="your_token"'));
-      console.log(chalk8.dim("  2. Edit .fractary/codex/config.yaml to configure storage providers"));
-      console.log(chalk8.dim("  3. Fetch a document: fractary codex fetch codex://org/project/path"));
-      console.log(chalk8.dim("  4. Check cache: fractary codex cache list"));
+      console.log(chalk8.dim("  1. Configure AWS credentials for S3 access"));
+      console.log(chalk8.dim("  2. Edit .fractary/config.yaml to add external project dependencies"));
+      console.log(chalk8.dim("  3. Access current project files: codex://specs/SPEC-001.md"));
+      console.log(chalk8.dim("  4. Access external projects: codex://org/project/docs/README.md"));
     } catch (error) {
       console.error(chalk8.red("Error:"), error.message);
       process.exit(1);
@@ -981,8 +1222,8 @@ function migrateCommand() {
   const cmd = new Command("migrate");
   cmd.description("Migrate legacy JSON configuration to v3.0 YAML format").option("--dry-run", "Show migration plan without executing").option("--no-backup", "Skip creating backup of old config").option("--json", "Output as JSON").action(async (options) => {
     try {
-      const legacyConfigPath = path4.join(process.cwd(), ".fractary", "plugins", "codex", "config.json");
-      const newConfigPath = path4.join(process.cwd(), ".fractary", "codex", "config.yaml");
+      const legacyConfigPath = path5.join(process.cwd(), ".fractary", "plugins", "codex", "config.json");
+      const newConfigPath = path5.join(process.cwd(), ".fractary", "codex", "config.yaml");
       if (!await fileExists2(legacyConfigPath)) {
         if (options.json) {
           console.log(JSON.stringify({
@@ -1015,8 +1256,9 @@ function migrateCommand() {
       let legacyConfig;
       try {
         legacyConfig = JSON.parse(legacyContent);
-      } catch {
+      } catch (parseError) {
         console.error(chalk8.red("Error:"), "Invalid JSON in legacy config file.");
+        console.error(chalk8.dim("Details:"), parseError.message);
         process.exit(1);
       }
       if (!options.json && !options.dryRun) {
@@ -1077,19 +1319,34 @@ function migrateCommand() {
       }
       if (!options.dryRun) {
         await writeYamlConfig(migrationResult.yamlConfig, newConfigPath);
-        const cacheDir = path4.join(process.cwd(), ".codex-cache");
+        const configuredCacheDir = migrationResult.yamlConfig.cacheDir || ".fractary/codex/cache";
+        const cacheDir = path5.join(process.cwd(), configuredCacheDir);
         await fs.mkdir(cacheDir, { recursive: true });
+        const gitignoreResult = await ensureCachePathIgnored(process.cwd(), configuredCacheDir);
+        const isCustomCachePath = normalizeCachePath(configuredCacheDir) !== DEFAULT_CACHE_DIR;
         if (!options.json) {
           console.log(chalk8.green("\u2713"), "YAML configuration created");
           console.log(chalk8.green("\u2713"), "Cache directory initialized");
           if (migrationResult.backupPath) {
             console.log(chalk8.green("\u2713"), "Legacy config backed up");
           }
+          if (gitignoreResult.created) {
+            console.log(chalk8.green("\u2713"), ".fractary/.gitignore created");
+          } else if (gitignoreResult.updated) {
+            console.log(chalk8.green("\u2713"), ".fractary/.gitignore updated with cache path");
+          } else if (gitignoreResult.alreadyIgnored) {
+            console.log(chalk8.green("\u2713"), "Cache path already in .fractary/.gitignore");
+          }
+          if (isCustomCachePath) {
+            console.log("");
+            console.log(chalk8.yellow("\u26A0 Custom cache directory detected:"), chalk8.dim(configuredCacheDir));
+            console.log(chalk8.dim("  Ensure .fractary/.gitignore includes this path to avoid committing cache files."));
+          }
           console.log("");
           console.log(chalk8.bold("New Configuration:"));
           console.log(chalk8.dim(`  Path: ${newConfigPath}`));
           console.log(chalk8.dim(`  Organization: ${migrationResult.yamlConfig.organization}`));
-          console.log(chalk8.dim(`  Cache: ${migrationResult.yamlConfig.cacheDir || ".codex-cache"}`));
+          console.log(chalk8.dim(`  Cache: ${configuredCacheDir}`));
           console.log(chalk8.dim(`  Storage Providers: ${migrationResult.yamlConfig.storage?.length || 0}`));
           console.log("");
           console.log(chalk8.bold("Next Steps:"));
@@ -1098,7 +1355,7 @@ function migrateCommand() {
           console.log(chalk8.dim("  3. Test fetching: fractary codex fetch codex://org/project/path"));
           if (migrationResult.backupPath) {
             console.log("");
-            console.log(chalk8.dim(`Backup saved: ${path4.basename(migrationResult.backupPath)}`));
+            console.log(chalk8.dim(`Backup saved: ${path5.basename(migrationResult.backupPath)}`));
           }
         }
       }
@@ -1308,8 +1565,8 @@ async function fileExists3(filePath) {
   }
 }
 async function checkConfiguration() {
-  const configPath = path4.join(process.cwd(), ".fractary", "codex", "config.yaml");
-  const legacyConfigPath = path4.join(process.cwd(), ".fractary", "plugins", "codex", "config.json");
+  const configPath = path5.join(process.cwd(), ".fractary", "codex", "config.yaml");
+  const legacyConfigPath = path5.join(process.cwd(), ".fractary", "plugins", "codex", "config.json");
   try {
     if (!await fileExists3(configPath)) {
       if (await fileExists3(legacyConfigPath)) {
@@ -1416,7 +1673,7 @@ async function checkCache() {
   }
 }
 async function checkStorage() {
-  const configPath = path4.join(process.cwd(), ".fractary", "codex", "config.yaml");
+  const configPath = path5.join(process.cwd(), ".fractary", "codex", "config.yaml");
   try {
     const config = await readYamlConfig(configPath);
     const providers = config.storage || [];
@@ -1574,7 +1831,7 @@ function syncCommand() {
   const cmd = new Command("sync");
   cmd.description("Sync single project with codex repository").argument("[name]", "Project name (auto-detected if not provided)").option("--env <env>", "Target environment (dev/test/staging/prod)", "prod").option("--dry-run", "Show what would sync without executing").option("--direction <dir>", "Sync direction (to-codex/from-codex/bidirectional)", "bidirectional").option("--include <pattern>", "Include files matching pattern (can be used multiple times)", (val, prev) => prev.concat([val]), []).option("--exclude <pattern>", "Exclude files matching pattern (can be used multiple times)", (val, prev) => prev.concat([val]), []).option("--force", "Force sync without checking timestamps").option("--json", "Output as JSON").action(async (name, options) => {
     try {
-      const configPath = path4.join(process.cwd(), ".fractary", "codex", "config.yaml");
+      const configPath = path5.join(process.cwd(), ".fractary", "codex", "config.yaml");
       let config;
       try {
         config = await readYamlConfig(configPath);
@@ -1608,7 +1865,7 @@ function syncCommand() {
       const syncManager = createSyncManager({
         localStorage,
         config: config.sync,
-        manifestPath: path4.join(process.cwd(), ".fractary", ".codex-sync-manifest.json")
+        manifestPath: path5.join(process.cwd(), ".fractary", ".codex-sync-manifest.json")
       });
       const defaultToCodexPatterns = [
         "docs/**/*.md",
@@ -1659,8 +1916,8 @@ function syncCommand() {
       }
       const targetFiles = await Promise.all(
         Array.from(matchedFilePaths).map(async (filePath) => {
-          const fullPath = path4.join(sourceDir, filePath);
-          const stats = await import('fs/promises').then((fs7) => fs7.stat(fullPath));
+          const fullPath = path5.join(sourceDir, filePath);
+          const stats = await import('fs/promises').then((fs9) => fs9.stat(fullPath));
           return {
             path: filePath,
             size: stats.size,
@@ -2108,7 +2365,7 @@ function typesAddCommand() {
         console.log(chalk8.dim("Examples: 30m, 24h, 7d"));
         process.exit(1);
       }
-      const configPath = path4.join(process.cwd(), ".fractary", "codex", "config.yaml");
+      const configPath = path5.join(process.cwd(), ".fractary", "codex", "config.yaml");
       const config = await readYamlConfig(configPath);
       if (!config.types) {
         config.types = { custom: {} };
@@ -2177,7 +2434,7 @@ function typesRemoveCommand() {
         process.exit(1);
       }
       const typeInfo = registry.get(name);
-      const configPath = path4.join(process.cwd(), ".fractary", "codex", "config.yaml");
+      const configPath = path5.join(process.cwd(), ".fractary", "codex", "config.yaml");
       const config = await readYamlConfig(configPath);
       if (!config.types?.custom?.[name]) {
         console.error(chalk8.red("Error:"), `Custom type "${name}" not found in configuration.`);