ferix-code 0.0.2-beta.23 → 0.0.2-beta.25

package/dist/index.d.ts

@@ -330,9 +330,9 @@ declare const isContentBlockStart: (u: unknown, overrideOptions?: effect_SchemaA
         readonly text?: string | undefined;
     } | {
         readonly type: "tool_use";
+        readonly name: string;
         readonly input?: unknown;
         readonly id?: string | undefined;
-        readonly name: string;
     };
 };
 declare const isContentBlockDelta: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
@@ -358,9 +358,9 @@ declare const isAssistantMessage: (u: unknown, overrideOptions?: effect_SchemaAS
             readonly text: string;
         } | {
             readonly type: "tool_use";
+            readonly name: string;
             readonly input: unknown;
             readonly id?: string | undefined;
-            readonly name: string;
         })[];
     };
 };
@@ -378,9 +378,9 @@ declare const isInputJsonDelta: (u: unknown, overrideOptions?: effect_SchemaAST.
 };
 declare const isToolUseContentBlock: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
     readonly type: "tool_use";
+    readonly name: string;
     readonly input: unknown;
     readonly id?: string | undefined;
-    readonly name: string;
 };
 declare const isTextContentBlock: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
     readonly type: "text";
@@ -397,9 +397,9 @@ declare const decodeClaudeCliEvent: (u: unknown, overrideOptions?: effect_Schema
         readonly text?: string | undefined;
     } | {
         readonly type: "tool_use";
+        readonly name: string;
         readonly input?: unknown;
         readonly id?: string | undefined;
-        readonly name: string;
     };
 } | {
     readonly type: "content_block_delta";
@@ -422,9 +422,9 @@ declare const decodeClaudeCliEvent: (u: unknown, overrideOptions?: effect_Schema
             readonly text: string;
         } | {
             readonly type: "tool_use";
+            readonly name: string;
             readonly input: unknown;
             readonly id?: string | undefined;
-            readonly name: string;
         })[];
     };
 } | {
@@ -439,9 +439,9 @@ declare const decodeClaudeCliEventSync: (u: unknown, overrideOptions?: effect_Sc
         readonly text?: string | undefined;
     } | {
         readonly type: "tool_use";
+        readonly name: string;
         readonly input?: unknown;
         readonly id?: string | undefined;
-        readonly name: string;
     };
 } | {
     readonly type: "content_block_delta";
@@ -464,9 +464,9 @@ declare const decodeClaudeCliEventSync: (u: unknown, overrideOptions?: effect_Sc
             readonly text: string;
         } | {
             readonly type: "tool_use";
+            readonly name: string;
             readonly input: unknown;
             readonly id?: string | undefined;
-            readonly name: string;
         })[];
     };
 } | {
@@ -1604,15 +1604,15 @@ declare const isBashToolInput: (u: unknown, overrideOptions?: effect_SchemaAST.P
     readonly [x: string]: unknown;
 };
 declare const isGlobToolInput: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
-    readonly pattern: string;
     readonly path?: string | undefined;
+    readonly pattern: string;
 } & {
     readonly [x: string]: unknown;
 };
 declare const isGrepToolInput: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions | number) => u is {
     readonly type?: string | undefined;
-    readonly pattern: string;
     readonly path?: string | undefined;
+    readonly pattern: string;
     readonly glob?: string | undefined;
     readonly output_mode?: "content" | "files_with_matches" | "count" | undefined;
 } & {
@@ -1728,8 +1728,8 @@ interface ValidatedToolUseEvent {
     readonly input: AnyToolInput;
 }
 declare const decodeLLMEvent: (u: unknown, overrideOptions?: effect_SchemaAST.ParseOptions) => effect_Effect.Effect<{
-    readonly _tag: "Text";
     readonly text: string;
+    readonly _tag: "Text";
 } | {
     readonly _tag: "ToolStart";
     readonly tool: string;
@@ -1903,17 +1903,17 @@ declare const decodePlan: (u: unknown, overrideOptions?: effect_SchemaAST.ParseO
     readonly context?: string | undefined;
     readonly tasks: readonly {
         readonly phases: readonly {
-            readonly status: "pending" | "in_progress" | "done" | "failed";
+            readonly status: "failed" | "pending" | "in_progress" | "done";
             readonly id: string;
             readonly description: string;
         }[];
-        readonly status: "planning" | "pending" | "in_progress" | "done" | "failed" | "skipped";
+        readonly status: "planning" | "failed" | "pending" | "in_progress" | "done" | "skipped";
         readonly attempts: number;
         readonly id: string;
         readonly description: string;
         readonly title: string;
         readonly criteria: readonly {
-            readonly status: "pending" | "failed" | "passed";
+            readonly status: "failed" | "pending" | "passed";
             readonly id: string;
             readonly description: string;
             readonly failureReason?: string | undefined;
@@ -1929,17 +1929,17 @@ declare const decodePlanData: (u: unknown, overrideOptions?: effect_SchemaAST.Pa
     readonly context?: string | undefined;
     readonly tasks: readonly {
         readonly phases: readonly {
-            readonly status: "pending" | "in_progress" | "done" | "failed";
+            readonly status: "failed" | "pending" | "in_progress" | "done";
             readonly id: string;
             readonly description: string;
         }[];
-        readonly status: "planning" | "pending" | "in_progress" | "done" | "failed" | "skipped";
+        readonly status: "planning" | "failed" | "pending" | "in_progress" | "done" | "skipped";
         readonly attempts: number;
         readonly id: string;
         readonly description: string;
         readonly title: string;
         readonly criteria: readonly {
-            readonly status: "pending" | "failed" | "passed";
+            readonly status: "failed" | "pending" | "passed";
             readonly id: string;
             readonly description: string;
             readonly failureReason?: string | undefined;
@@ -2382,8 +2382,8 @@ declare const decodeSignal: (u: unknown, overrideOptions?: effect_SchemaAST.Pars
 } | {
     readonly _tag: "LoopComplete";
 } | {
-    readonly _tag: "SessionNameDefined";
     readonly name: string;
+    readonly _tag: "SessionNameDefined";
 } | {
     readonly _tag: "Learning";
     readonly content: string;
@@ -2449,8 +2449,8 @@ declare const decodeSignalSync: (u: unknown, overrideOptions?: effect_SchemaAST.
 } | {
     readonly _tag: "LoopComplete";
 } | {
-    readonly _tag: "SessionNameDefined";
     readonly name: string;
+    readonly _tag: "SessionNameDefined";
 } | {
     readonly _tag: "Learning";
     readonly content: string;

package/dist/index.js

@@ -70,6 +70,8 @@ var init_registry = __esm({
 
 // src/index.ts
 init_esm_shims();
+import { access as access3, readdir as readdir2, readFile as readFile7 } from "fs/promises";
+import { dirname as dirname2, join as join7, resolve } from "path";
 
 // ../sync/dist/index.js
 init_esm_shims();
@@ -149,12 +151,6 @@ var decodeSkillReposResponse = S.decodeUnknown(
 var CONVEX_URL_PROD = "https://groovy-mallard-649.convex.cloud";
 var CONVEX_URL_DEV = "https://majestic-gnu-964.convex.cloud";
 var getConvexUrl = (dev) => dev ? CONVEX_URL_DEV : CONVEX_URL_PROD;
-var NON_NPM_VERSION_PREFIXES = [
-  "workspace:",
-  "file:",
-  "link:",
-  "portal:"
-];
 
 // ../sync/dist/chunk-3LE2T6D2.js
 init_esm_shims();
@@ -6116,7 +6112,7 @@ var findSkillRepos = (orgs, dev) => Effect.gen(function* () {
   return validated;
 });
 
-// ../sync/dist/chunk-3CFQKJND.js
+// ../sync/dist/chunk-FXKCLMLB.js
 init_esm_shims();
 import { exec } from "child_process";
 import { promisify } from "util";
@@ -6126,7 +6122,7 @@ var installSingleSkill = (repo, options) => Effect2.tryPromise({
   try: async () => {
     const repoId = `${repo.owner}/${repo.repo}`;
     const globalFlag = options.global === true ? " --global" : "";
-    const command = `npx skills add ${repoId}${globalFlag}`;
+    const command = `npx skills add ${repoId}${globalFlag} --yes`;
     await execAsync(command);
     return repoId;
   },
@@ -6180,202 +6176,18 @@ var resolvePackageOrgs = (packageNames, dev) => Effect3.gen(function* () {
 });
 
 // ../sync/dist/index.js
-import { access, readdir, readFile } from "fs/promises";
-import { dirname, join, resolve } from "path";
 import { Effect as Effect4, Schema as S4 } from "effect";
-var validateFileExists = (filePath) => Effect4.tryPromise({
-  try: async () => {
-    const absolutePath = resolve(filePath);
-    await access(absolutePath);
-    return absolutePath;
-  },
-  catch: () => new PackageJsonError({
-    message: `File not found: ${filePath}`,
-    path: filePath
-  })
-});
-var readFileContent = (absolutePath) => Effect4.tryPromise({
-  try: async () => await readFile(absolutePath, "utf-8"),
-  catch: (error) => new PackageJsonError({
-    message: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`,
-    path: absolutePath,
-    cause: error
-  })
-});
-var parseJson = (content, path2) => Effect4.try({
-  try: () => JSON.parse(content),
-  catch: (error) => new PackageJsonError({
-    message: `Invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
-    path: path2,
-    cause: error
-  })
-});
-var validatePackageJson = (json, path2) => S4.decodeUnknown(PackageJsonSchema)(json).pipe(
-  Effect4.mapError(
-    (error) => new SchemaValidationError({
-      message: "Invalid package.json structure",
-      context: path2,
-      cause: error
-    })
-  )
-);
-var isNonNpmDependency = (version2) => NON_NPM_VERSION_PREFIXES.some((prefix) => version2.startsWith(prefix));
-var extractDependencies = (pkg) => {
-  const deps = pkg.dependencies ?? {};
-  const devDeps = pkg.devDependencies ?? {};
-  const allDeps = /* @__PURE__ */ new Map();
-  for (const [name, version2] of Object.entries(deps)) {
-    if (!isNonNpmDependency(version2)) {
-      allDeps.set(name, version2);
-    }
-  }
-  for (const [name, version2] of Object.entries(devDeps)) {
-    if (!(allDeps.has(name) || isNonNpmDependency(version2))) {
-      allDeps.set(name, version2);
-    }
-  }
-  return Array.from(allDeps.keys());
-};
-var emptyResult = (dependencies = [], orgs = [], packageJsonCount = 1) => ({
-  dependencies: [...dependencies],
-  orgs: [...orgs],
-  skillRepos: [],
-  installed: [],
-  packageJsonCount
-});
-var toMutableSkillRepos = (repos) => repos.map((r) => ({ owner: r.owner, repo: r.repo, githubUrl: r.githubUrl }));
-var extractWorkspacePatterns = (pkg) => {
-  const workspaces = pkg.workspaces;
-  if (!workspaces) {
-    return [];
-  }
-  if (Array.isArray(workspaces)) {
-    return workspaces.filter((w) => typeof w === "string");
-  }
-  if (typeof workspaces === "object" && "packages" in workspaces) {
-    const packages = workspaces.packages;
-    if (Array.isArray(packages)) {
-      return packages.filter((w) => typeof w === "string");
-    }
-  }
-  return [];
-};
-var expandGlobPattern = async (rootDir, pattern) => {
-  if (pattern.endsWith("/*")) {
-    const baseDir = pattern.slice(0, -2);
-    const fullPath2 = join(rootDir, baseDir);
-    try {
-      const entries = await readdir(fullPath2, { withFileTypes: true });
-      return entries.filter((entry) => entry.isDirectory()).map((entry) => join(fullPath2, entry.name));
-    } catch {
-      return [];
-    }
-  }
-  if (pattern.endsWith("/**")) {
-    const baseDir = pattern.slice(0, -3);
-    const fullPath2 = join(rootDir, baseDir);
-    try {
-      const entries = await readdir(fullPath2, { withFileTypes: true });
-      return entries.filter((entry) => entry.isDirectory()).map((entry) => join(fullPath2, entry.name));
-    } catch {
-      return [];
-    }
-  }
-  const fullPath = join(rootDir, pattern);
-  try {
-    await access(fullPath);
-    return [fullPath];
-  } catch {
-    return [];
-  }
-};
-var discoverPackageJsonFiles = (rootPath, rootPkg) => Effect4.tryPromise({
-  try: async () => {
-    const rootDir = dirname(rootPath);
-    const patterns = extractWorkspacePatterns(rootPkg);
-    if (patterns.length === 0) {
-      return [rootPath];
-    }
-    const packageJsonPaths = [rootPath];
-    for (const pattern of patterns) {
-      const dirs = await expandGlobPattern(rootDir, pattern);
-      for (const dir of dirs) {
-        const pkgPath = join(dir, "package.json");
-        try {
-          await access(pkgPath);
-          packageJsonPaths.push(pkgPath);
-        } catch {
-        }
-      }
-    }
-    return packageJsonPaths;
-  },
-  catch: (error) => new PackageJsonError({
-    message: `Failed to discover workspace packages: ${error instanceof Error ? error.message : String(error)}`,
-    path: rootPath,
-    cause: error
-  })
-});
-var readPackageJson = (filePath) => Effect4.gen(function* () {
-  const content = yield* readFileContent(filePath);
-  const json = yield* parseJson(content, filePath);
-  return yield* validatePackageJson(json, filePath);
-});
-var sync = (packageJsonPath, options = {}) => Effect4.gen(function* () {
-  const absolutePath = yield* validateFileExists(packageJsonPath);
-  const rootPkg = yield* readPackageJson(absolutePath);
-  const packageJsonPaths = yield* discoverPackageJsonFiles(
-    absolutePath,
-    rootPkg
-  );
-  const packageJsonCount = packageJsonPaths.length;
-  const allDependencies = /* @__PURE__ */ new Set();
-  for (const pkgPath of packageJsonPaths) {
-    const pkg = yield* readPackageJson(pkgPath);
-    const deps = extractDependencies(pkg);
-    for (const dep of deps) {
-      allDependencies.add(dep);
-    }
-  }
-  const dependencies = Array.from(allDependencies);
-  if (dependencies.length === 0) {
-    return emptyResult([], [], packageJsonCount);
-  }
-  const packageOrgs = yield* resolvePackageOrgs(dependencies, options.dev);
-  const orgs = Array.from(
-    new Set(
-      packageOrgs.map((p) => p.githubOrg).filter((org) => org !== null)
-    )
-  );
-  if (orgs.length === 0) {
-    return emptyResult([...dependencies], [], packageJsonCount);
-  }
-  const skillRepos = yield* findSkillRepos(orgs, options.dev);
-  if (skillRepos.length === 0) {
-    return emptyResult([...dependencies], orgs, packageJsonCount);
-  }
-  const installed = yield* installSkills(skillRepos, {
-    dryRun: options.dryRun,
-    global: options.global
-  });
-  return {
-    dependencies: [...dependencies],
-    orgs,
-    skillRepos: toMutableSkillRepos(skillRepos),
-    installed: [...installed],
-    packageJsonCount
-  };
-});
 
 // src/index.ts
 import { Command } from "commander";
 import { Effect as Effect29 } from "effect";
+import ora from "ora";
 import pc17 from "picocolors";
 
 // package.json
 var package_default = {
   name: "ferix-code",
-  version: "0.0.2-beta.23",
+  version: "0.0.2-beta.25",
   description: "Composable RALPH loops for AI coding agents - v2 with Effect",
   type: "module",
   bin: {
@@ -6397,6 +6209,7 @@ var package_default = {
     commander: "^14.0.0",
     effect: "^3.19.15",
     "human-id": "^4.1.3",
+    ora: "^9.1.0",
     picocolors: "^1.1.1"
   },
   devDependencies: {
@@ -8877,14 +8690,14 @@ import { Layer as Layer14 } from "effect";
 init_esm_shims();
 import { exec as exec2 } from "child_process";
 import {
-  access as access2,
+  access,
   appendFile,
   copyFile,
   mkdir,
-  readFile as readFile2,
+  readFile,
   rm
 } from "fs/promises";
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname, join } from "path";
 import { promisify as promisify2 } from "util";
 import { Effect as Effect8, Layer } from "effect";
 
@@ -8930,7 +8743,7 @@ var WORKTREES_DIR = ".ferix/worktrees";
 var GITDIR_REGEX = /^gitdir:\s*(.+)$/m;
 var BRANCH_PREFIX = "ferix";
 function getWorktreeDir(sessionId) {
-  return join2(process.cwd(), WORKTREES_DIR, sessionId);
+  return join(process.cwd(), WORKTREES_DIR, sessionId);
 }
 function getBranchName(sessionId) {
   return `${BRANCH_PREFIX}/${sessionId}`;
@@ -8954,7 +8767,7 @@ function gitExec(command, cwd) {
 function directoryExists(dirPath) {
   return Effect8.tryPromise({
     try: async () => {
-      await access2(dirPath);
+      await access(dirPath);
       return true;
     },
     catch: () => new Error("Directory does not exist")
@@ -8994,11 +8807,11 @@ function copyUntrackedFiles(worktreeDir) {
       return;
     }
     for (const file of untrackedFiles) {
-      const srcPath = join2(process.cwd(), file);
-      const destPath = join2(worktreeDir, file);
+      const srcPath = join(process.cwd(), file);
+      const destPath = join(worktreeDir, file);
       yield* Effect8.tryPromise({
         try: async () => {
-          await mkdir(dirname2(destPath), { recursive: true });
+          await mkdir(dirname(destPath), { recursive: true });
           await copyFile(srcPath, destPath);
         },
         catch: () => new GitError({
@@ -9009,16 +8822,16 @@ function copyUntrackedFiles(worktreeDir) {
     }
     yield* Effect8.tryPromise({
       try: async () => {
-        const gitFilePath = join2(worktreeDir, ".git");
-        const gitFileContent = await readFile2(gitFilePath, "utf-8");
+        const gitFilePath = join(worktreeDir, ".git");
+        const gitFileContent = await readFile(gitFilePath, "utf-8");
         const gitDirMatch = gitFileContent.match(GITDIR_REGEX);
         const gitDirPath = gitDirMatch?.[1]?.trim();
         if (!gitDirPath) {
           return;
         }
         const gitDir = gitDirPath;
-        const excludePath = join2(gitDir, "info", "exclude");
-        await mkdir(dirname2(excludePath), { recursive: true });
+        const excludePath = join(gitDir, "info", "exclude");
+        await mkdir(dirname(excludePath), { recursive: true });
         const excludeContent = "\n# Untracked files copied from main worktree (auto-generated by ferix)\n" + untrackedFiles.join("\n") + "\n";
         await appendFile(excludePath, excludeContent);
       },
@@ -9033,7 +8846,7 @@ var make = {
   createWorktree: (sessionId, baseBranch) => Effect8.gen(function* () {
     const worktreeDir = getWorktreeDir(sessionId);
     const branchName = getBranchName(sessionId);
-    const worktreesBase = join2(process.cwd(), WORKTREES_DIR);
+    const worktreesBase = join(process.cwd(), WORKTREES_DIR);
     yield* Effect8.tryPromise({
       try: () => mkdir(worktreesBase, { recursive: true }),
       catch: (error) => new GitError({
@@ -9409,8 +9222,8 @@ var MemoryGit = {
 
 // src/layers/guardrails/file-system.ts
 init_esm_shims();
-import { mkdir as mkdir2, readFile as readFile3, writeFile } from "fs/promises";
-import { join as join3 } from "path";
+import { mkdir as mkdir2, readFile as readFile2, writeFile } from "fs/promises";
+import { join as join2 } from "path";
 import { DateTime, Effect as Effect10, Layer as Layer3 } from "effect";
 
 // src/domain/index.ts
@@ -10432,10 +10245,10 @@ function ensureDir(dirPath) {
   }).pipe(Effect10.asVoid);
 }
 function getSessionDir(sessionId) {
-  return join3(process.cwd(), PLANS_DIR, sessionId);
+  return join2(process.cwd(), PLANS_DIR, sessionId);
 }
 function getGuardrailsPath(sessionId) {
-  return join3(getSessionDir(sessionId), "guardrails.json");
+  return join2(getSessionDir(sessionId), "guardrails.json");
 }
 function serializeGuardrails(guardrails) {
   return JSON.stringify(guardrails, null, 2);
@@ -10477,7 +10290,7 @@ var make2 = {
     const existing = yield* Effect10.tryPromise({
       try: async () => {
         try {
-          const content = await readFile3(guardrailsPath, "utf-8");
+          const content = await readFile2(guardrailsPath, "utf-8");
           return content;
         } catch {
           return null;
@@ -10526,7 +10339,7 @@ var make2 = {
     const content = yield* Effect10.tryPromise({
       try: async () => {
         try {
-          return await readFile3(guardrailsPath, "utf-8");
+          return await readFile2(guardrailsPath, "utf-8");
         } catch {
           return null;
         }
@@ -11081,8 +10894,8 @@ function createProviderLayer2(name) {
 
 // src/layers/plan/file-system.ts
 init_esm_shims();
-import { access as access3, mkdir as mkdir3, readdir as readdir2, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
-import { join as join4 } from "path";
+import { access as access2, mkdir as mkdir3, readdir, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { join as join3 } from "path";
 import { Effect as Effect16, Layer as Layer7 } from "effect";
 
 // src/services/plan-store.ts
@@ -11104,10 +10917,10 @@ function ensureDir2(dirPath) {
   }).pipe(Effect16.asVoid);
 }
 function getSessionDir2(sessionId) {
-  return join4(process.cwd(), PLANS_DIR2, sessionId);
+  return join3(process.cwd(), PLANS_DIR2, sessionId);
 }
 function getPlanPath(sessionId, planId) {
-  return join4(getSessionDir2(sessionId), `${planId}.json`);
+  return join3(getSessionDir2(sessionId), `${planId}.json`);
 }
 function generatePlanId(taskNumber) {
   return PlanId(`task-${taskNumber}`);
@@ -11147,7 +10960,7 @@ var make3 = {
     const existingPlans = yield* Effect16.tryPromise({
       try: async () => {
         try {
-          const files = await readdir2(sessionDir);
+          const files = await readdir(sessionDir);
           return files.filter((f) => f.endsWith(".json")).length;
         } catch {
           return 0;
@@ -11175,7 +10988,7 @@ var make3 = {
     if (sessionId) {
       const planPath = getPlanPath(sessionId, planId);
       const content = yield* Effect16.tryPromise({
-        try: () => readFile4(planPath, "utf-8"),
+        try: () => readFile3(planPath, "utf-8"),
         catch: (error) => new PlanStoreError({
           message: `Failed to read plan file: ${planPath}`,
           operation: "load",
@@ -11186,8 +10999,8 @@ var make3 = {
     }
     const sessionDirs = yield* Effect16.tryPromise({
       try: async () => {
-        const plansDir = join4(process.cwd(), PLANS_DIR2);
-        const dirs = await readdir2(plansDir);
+        const plansDir = join3(process.cwd(), PLANS_DIR2);
+        const dirs = await readdir(plansDir);
         return dirs;
       },
       catch: (error) => new PlanStoreError({
@@ -11200,7 +11013,7 @@ var make3 = {
       const planPath = getPlanPath(sid, planId);
       const exists = yield* Effect16.tryPromise({
         try: async () => {
-          await access3(planPath);
+          await access2(planPath);
           return true;
         },
         catch: () => new PlanStoreError({
@@ -11210,7 +11023,7 @@ var make3 = {
       }).pipe(Effect16.orElseSucceed(() => false));
       if (exists) {
         const content = yield* Effect16.tryPromise({
-          try: () => readFile4(planPath, "utf-8"),
+          try: () => readFile3(planPath, "utf-8"),
           catch: (error) => new PlanStoreError({
             message: `Failed to read plan file: ${planPath}`,
             operation: "load",
@@ -11243,7 +11056,7 @@ var make3 = {
     const files = yield* Effect16.tryPromise({
       try: async () => {
         try {
-          return await readdir2(sessionDir);
+          return await readdir(sessionDir);
         } catch {
           return [];
         }
@@ -11351,8 +11164,8 @@ var MemoryPlan = {
 
 // src/layers/progress/file-system.ts
 init_esm_shims();
-import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
-import { join as join5 } from "path";
+import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import { join as join4 } from "path";
 import { DateTime as DateTime3, Effect as Effect18, Layer as Layer9 } from "effect";
 
 // src/services/progress-store.ts
@@ -11374,10 +11187,10 @@ function ensureDir3(dirPath) {
   }).pipe(Effect18.asVoid);
 }
 function getSessionDir3(sessionId) {
-  return join5(process.cwd(), PLANS_DIR3, sessionId);
+  return join4(process.cwd(), PLANS_DIR3, sessionId);
 }
 function getProgressPath(sessionId) {
-  return join5(getSessionDir3(sessionId), "progress.json");
+  return join4(getSessionDir3(sessionId), "progress.json");
 }
 function serializeProgress(progress) {
   return JSON.stringify(progress, null, 2);
@@ -11419,7 +11232,7 @@ var make4 = {
     const existing = yield* Effect18.tryPromise({
       try: async () => {
         try {
-          const content = await readFile5(progressPath, "utf-8");
+          const content = await readFile4(progressPath, "utf-8");
           return content;
         } catch {
           return null;
@@ -11464,7 +11277,7 @@ var make4 = {
     const content = yield* Effect18.tryPromise({
       try: async () => {
         try {
-          return await readFile5(progressPath, "utf-8");
+          return await readFile4(progressPath, "utf-8");
         } catch {
           return null;
         }
@@ -11555,8 +11368,8 @@ var MemoryProgress = {
 
 // src/layers/session/file-system.ts
 init_esm_shims();
-import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
-import { join as join6 } from "path";
+import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { join as join5 } from "path";
 import { DateTime as DateTime5, Effect as Effect20, Layer as Layer11 } from "effect";
 import { humanId } from "human-id";
 
@@ -11583,7 +11396,7 @@ function ensureDir4(dirPath) {
   }).pipe(Effect20.asVoid);
 }
 function getSessionPath(sessionId) {
-  return join6(process.cwd(), SESSIONS_DIR, `${sessionId}.json`);
+  return join5(process.cwd(), SESSIONS_DIR, `${sessionId}.json`);
 }
 function serializeSession(session) {
   return JSON.stringify(session, null, 2);
@@ -11612,7 +11425,7 @@ function deserializeSession(json) {
 }
 var make5 = {
   create: (originalTask) => Effect20.gen(function* () {
-    const sessionsDir = join6(process.cwd(), SESSIONS_DIR);
+    const sessionsDir = join5(process.cwd(), SESSIONS_DIR);
     yield* ensureDir4(sessionsDir);
     const now = yield* DateTime5.now;
     const timestampMs = DateTime5.toEpochMillis(now);
@@ -11638,7 +11451,7 @@ var make5 = {
   get: (sessionId) => Effect20.gen(function* () {
     const sessionPath = getSessionPath(sessionId);
     const content = yield* Effect20.tryPromise({
-      try: () => readFile6(sessionPath, "utf-8"),
+      try: () => readFile5(sessionPath, "utf-8"),
       catch: (error) => new SessionStoreError({
         message: `Failed to read session file: ${sessionPath}`,
         operation: "get",
@@ -12357,8 +12170,8 @@ import { DateTime as DateTime8, Effect as Effect25, pipe, Ref as Ref10, Stream a
 
 // src/layers/plan/task-generation.ts
 init_esm_shims();
-import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
-import { join as join7 } from "path";
+import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import { join as join6 } from "path";
 import { Effect as Effect23 } from "effect";
 var PLANS_DIR4 = ".ferix/plans";
 function ensureDir5(dirPath) {
@@ -12372,10 +12185,10 @@ function ensureDir5(dirPath) {
   }).pipe(Effect23.asVoid);
 }
 function getSessionDir4(sessionId) {
-  return join7(process.cwd(), PLANS_DIR4, sessionId);
+  return join6(process.cwd(), PLANS_DIR4, sessionId);
 }
 function getTasksMdPath(sessionId) {
-  return join7(getSessionDir4(sessionId), "tasks.md");
+  return join6(getSessionDir4(sessionId), "tasks.md");
 }
 function writeTasksMd(sessionId, tasks) {
   return Effect23.gen(function* () {
@@ -13954,55 +13767,291 @@ program.command("run", { isDefault: true }).argument("<task>", "Task description
     process.exit(1);
   }
 });
-program.command("sync").description("Discover and install skills based on your dependencies").option("-p, --path <path>", "Path to package.json", "./package.json").option("-n, --dry-run", "List skills without installing").option("-g, --global", "Install globally instead of project-level").option("-d, --dev", "Use development server instead of production").action(async (options) => {
+var NON_NPM_VERSION_PREFIXES2 = ["workspace:", "file:", "link:", "portal:"];
+var isNonNpmDependency = (version2) => NON_NPM_VERSION_PREFIXES2.some((prefix) => version2.startsWith(prefix));
+var extractDependencies = (pkg) => {
+  const deps = pkg.dependencies ?? {};
+  const devDeps = pkg.devDependencies ?? {};
+  const allDeps = /* @__PURE__ */ new Map();
+  for (const [name, version2] of Object.entries(deps)) {
+    if (!isNonNpmDependency(version2)) {
+      allDeps.set(name, version2);
+    }
+  }
+  for (const [name, version2] of Object.entries(devDeps)) {
+    if (!(allDeps.has(name) || isNonNpmDependency(version2))) {
+      allDeps.set(name, version2);
+    }
+  }
+  return Array.from(allDeps.keys());
+};
+var extractWorkspacePatterns = (pkg) => {
+  const workspaces = pkg.workspaces;
+  if (!workspaces) {
+    return [];
+  }
+  if (Array.isArray(workspaces)) {
+    return workspaces.filter((w) => typeof w === "string");
+  }
+  if (typeof workspaces === "object" && "packages" in workspaces) {
+    const packages = workspaces.packages;
+    if (Array.isArray(packages)) {
+      return packages.filter((w) => typeof w === "string");
+    }
+  }
+  return [];
+};
+var GLOB_SUFFIX_PATTERN = /\/\*+$/;
+var expandGlobPattern = async (rootDir, pattern) => {
+  if (pattern.endsWith("/*") || pattern.endsWith("/**")) {
+    const baseDir = pattern.replace(GLOB_SUFFIX_PATTERN, "");
+    const fullPath2 = join7(rootDir, baseDir);
+    try {
+      const entries = await readdir2(fullPath2, { withFileTypes: true });
+      return entries.filter((entry) => entry.isDirectory()).map((entry) => join7(fullPath2, entry.name));
+    } catch {
+      return [];
+    }
+  }
+  const fullPath = join7(rootDir, pattern);
   try {
-    console.log("\nScanning for package.json files...");
-    const result = await Effect29.runPromise(
-      sync(options.path, {
-        dryRun: options.dryRun ?? false,
-        global: options.global ?? false,
-        dev: options.dev ?? false
-      })
-    );
-    if (options.dev) {
-      console.log(pc17.yellow("Using development server"));
+    await access3(fullPath);
+    return [fullPath];
+  } catch {
+    return [];
+  }
+};
+var readPackageJsonFile = async (filePath) => {
+  const content = await readFile7(filePath, "utf-8");
+  return JSON.parse(content);
+};
+var discoverPackageJsonFiles = async (rootPath, rootPkg) => {
+  const rootDir = dirname2(rootPath);
+  const patterns = extractWorkspacePatterns(rootPkg);
+  if (patterns.length === 0) {
+    return [rootPath];
+  }
+  const packageJsonPaths = [rootPath];
+  for (const pattern of patterns) {
+    const dirs = await expandGlobPattern(rootDir, pattern);
+    for (const dir of dirs) {
+      const pkgPath = join7(dir, "package.json");
+      try {
+        await access3(pkgPath);
+        packageJsonPaths.push(pkgPath);
+      } catch {
+      }
     }
-    const packageMsg = result.packageJsonCount > 1 ? `Found ${pc17.bold(String(result.packageJsonCount))} package.json files (monorepo)` : "Found 1 package.json file";
-    console.log(packageMsg);
-    console.log(
-      `Found ${pc17.bold(String(result.dependencies.length))} dependencies (deduplicated)`
-    );
-    console.log(
-      `Resolved ${pc17.bold(String(result.orgs.length))} unique GitHub organizations`
-    );
-    if (result.skillRepos.length === 0) {
-      console.log(
-        `
-${pc17.yellow("No skill repositories found for your dependencies.")}`
-      );
-      return;
+  }
+  return packageJsonPaths;
+};
+var SYMBOLS = {
+  success: pc17.green("\u2713"),
+  error: pc17.red("\u2717")
+};
+var printHeader = (title, subtitle) => {
+  console.log();
+  console.log(pc17.bold(pc17.cyan(`  ${title}`)));
+  if (subtitle) {
+    console.log(pc17.dim(`  ${subtitle}`));
+  }
+  console.log();
+};
+var printSection = (title) => {
+  console.log();
+  console.log(pc17.bold(`  ${title}`));
+};
+var printRepo = (owner, repo, index) => {
+  const num = pc17.dim(`${String(index + 1).padStart(2, " ")}.`);
+  console.log(`  ${num} ${pc17.cyan(owner)}${pc17.dim("/")}${pc17.white(repo)}`);
+};
+var printSuccess = (message) => {
+  console.log(`  ${SYMBOLS.success} ${pc17.green(message)}`);
+};
+var printError = (message) => {
+  console.log(`  ${SYMBOLS.error} ${pc17.red(message)}`);
+};
+var printHint = (message) => {
+  console.log(pc17.dim(`  ${message}`));
+};
+var createSpinner = (text) => {
+  return ora({
+    text,
+    prefixText: " ",
+    spinner: "dots"
+  });
+};
+var discoverPackages = async (state, packagePath) => {
+  state.spinner = createSpinner("Scanning for package.json files...").start();
+  const absolutePath = resolve(packagePath);
+  await access3(absolutePath);
+  const rootPkg = await readPackageJsonFile(absolutePath);
+  state.packageJsonPaths = await discoverPackageJsonFiles(
+    absolutePath,
+    rootPkg
+  );
+  const isMonorepo = state.packageJsonPaths.length > 1;
+  state.spinner.succeed(
+    isMonorepo ? `Found ${pc17.bold(String(state.packageJsonPaths.length))} package.json files ${pc17.dim("(monorepo)")}` : "Found package.json"
+  );
+  return true;
+};
+var extractAllDependencies = async (state) => {
+  state.spinner = createSpinner("Extracting dependencies...").start();
+  const allDependencies = /* @__PURE__ */ new Set();
+  for (const pkgPath of state.packageJsonPaths) {
+    const pkg = await readPackageJsonFile(pkgPath);
+    for (const dep of extractDependencies(pkg)) {
+      allDependencies.add(dep);
     }
-    console.log(
-      `
-Found ${pc17.bold(String(result.skillRepos.length))} skill repositories:
-`
+  }
+  state.dependencies = Array.from(allDependencies);
+  if (state.dependencies.length === 0) {
+    state.spinner.warn("No dependencies found");
+    return false;
+  }
+  state.spinner.succeed(
+    `Found ${pc17.bold(String(state.dependencies.length))} unique dependencies`
+  );
+  return true;
+};
+var resolveOrganizations = async (state, isDev) => {
+  state.spinner = createSpinner("Resolving GitHub organizations...").start();
+  const packageOrgs = await Effect29.runPromise(
+    resolvePackageOrgs(state.dependencies, isDev)
+  );
+  state.orgs = Array.from(
+    new Set(
+      packageOrgs.map((p) => p.githubOrg).filter((org) => org !== null)
+    )
+  );
+  if (state.orgs.length === 0) {
+    state.spinner.warn("No GitHub organizations found");
+    printHint("Your dependencies don't have linked GitHub organizations.");
+    return false;
+  }
+  state.spinner.succeed(
+    `Resolved ${pc17.bold(String(state.orgs.length))} GitHub organizations`
+  );
+  return true;
+};
+var findRepositories = async (state, isDev) => {
+  state.spinner = createSpinner("Searching for skill repositories...").start();
+  state.skillRepos = await Effect29.runPromise(findSkillRepos(state.orgs, isDev));
+  if (state.skillRepos.length === 0) {
+    state.spinner.warn("No skill repositories found");
+    printHint(
+      "None of your dependency organizations have published skills yet."
     );
-    for (const repo of result.skillRepos) {
-      console.log(`  ${pc17.green("\u2022")} ${repo.owner}/${repo.repo}`);
+    return false;
+  }
+  state.spinner.succeed(
+    `Found ${pc17.bold(String(state.skillRepos.length))} skill ${state.skillRepos.length === 1 ? "repository" : "repositories"}`
+  );
+  return true;
+};
+var displayRepositories = (skillRepos) => {
+  printSection("Repositories");
+  console.log();
+  for (let i = 0; i < skillRepos.length; i++) {
+    const repo = skillRepos[i];
+    if (repo) {
+      printRepo(repo.owner, repo.repo, i);
     }
-    if (options.dryRun) {
-      console.log(
-        `
-${pc17.dim("Run without --dry-run to install these skills.")}`
+  }
+};
+var installRepositories = async (state, isGlobal) => {
+  printSection("Installing");
+  console.log();
+  const installed = [];
+  const failed = [];
+  for (const repo of state.skillRepos) {
+    const repoId = `${repo.owner}/${repo.repo}`;
+    state.spinner = createSpinner(
+      `Installing ${pc17.cyan(repo.owner)}${pc17.dim("/")}${pc17.white(repo.repo)}...`
+    ).start();
+    try {
+      await Effect29.runPromise(
+        installSkills([repo], { dryRun: false, global: isGlobal })
       );
-    } else {
-      console.log(
-        `
-${pc17.green("\u2713")} Installed ${pc17.bold(String(result.installed.length))} skill repositories`
+      state.spinner.succeed(
+        `Installed ${pc17.cyan(repo.owner)}${pc17.dim("/")}${pc17.white(repo.repo)}`
       );
+      installed.push(repoId);
+    } catch {
+      state.spinner.fail(
+        `Failed to install ${pc17.cyan(repo.owner)}${pc17.dim("/")}${pc17.white(repo.repo)}`
+      );
+      failed.push(repoId);
     }
+  }
+  return { installed, failed };
+};
+var displaySummary = (installed, failed, isGlobal) => {
+  printSection("Summary");
+  console.log();
+  if (installed.length > 0) {
+    printSuccess(
+      `${installed.length} skill ${installed.length === 1 ? "repository" : "repositories"} installed successfully`
+    );
+  }
+  if (failed.length > 0) {
+    printError(
+      `${failed.length} ${failed.length === 1 ? "installation" : "installations"} failed`
+    );
+  }
+  const installLocation = isGlobal ? "globally" : "in project";
+  printHint(`Skills installed ${installLocation}.`);
+  console.log();
+};
+var runSyncCommand = async (options) => {
+  const { path: packagePath, dryRun, global: isGlobal, dev: isDev } = options;
+  printHeader(
+    "Ferix Sync",
+    isDev ? pc17.yellow("Development Mode") : "Discovering skills from your dependencies"
+  );
+  const state = {
+    spinner: void 0,
+    packageJsonPaths: [],
+    dependencies: [],
+    orgs: [],
+    skillRepos: []
+  };
+  await discoverPackages(state, packagePath);
+  const hasDeps = await extractAllDependencies(state);
+  if (!hasDeps) {
+    return;
+  }
+  const hasOrgs = await resolveOrganizations(state, isDev);
+  if (!hasOrgs) {
+    return;
+  }
+  const hasRepos = await findRepositories(state, isDev);
+  if (!hasRepos) {
+    return;
+  }
+  displayRepositories(state.skillRepos);
+  if (dryRun) {
+    console.log();
+    printHint(`Run without ${pc17.cyan("--dry-run")} to install these skills.`);
+    console.log();
+    return;
+  }
+  const { installed, failed } = await installRepositories(state, isGlobal);
+  displaySummary(installed, failed, isGlobal);
+};
+program.command("sync").description("Discover and install skills based on your dependencies").option("-p, --path <path>", "Path to package.json", "./package.json").option("-n, --dry-run", "List skills without installing").option("-g, --global", "Install globally instead of project-level").option("-d, --dev", "Use development server instead of production").action(async (options) => {
+  try {
+    await runSyncCommand({
+      path: options.path,
+      dryRun: options.dryRun ?? false,
+      global: options.global ?? false,
+      dev: options.dev ?? false
+    });
   } catch (error) {
-    console.error(pc17.red("Error:"), error);
+    console.log();
+    printError(error instanceof Error ? error.message : String(error));
+    console.log();
     process.exit(1);
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ferix-code",
-  "version": "0.0.2-beta.23",
+  "version": "0.0.2-beta.25",
   "description": "Composable RALPH loops for AI coding agents - v2 with Effect",
   "type": "module",
   "bin": {
@@ -22,6 +22,7 @@
     "commander": "^14.0.0",
     "effect": "^3.19.15",
     "human-id": "^4.1.3",
+    "ora": "^9.1.0",
     "picocolors": "^1.1.1"
   },
   "devDependencies": {