@looplia/looplia-cli 0.6.7 → 0.6.8

package/dist/cli.js

@@ -13,7 +13,7 @@ var getDirname = () => path.dirname(getFilename());
 var __dirname = /* @__PURE__ */ getDirname();
 
 // src/commands/build.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync5 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5 } from "fs";
 import { homedir as homedir5 } from "os";
 import { resolve as resolve2 } from "path";
 
@@ -243,6 +243,12 @@ async function getPluginPaths() {
   return await getProdPluginPaths();
 }
 
+// ../../packages/provider/dist/chunk-4PGJBKLH.js
+import { execSync } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+
 // ../../node_modules/zod-to-json-schema/dist/esm/Options.js
 var ignoreOverride = /* @__PURE__ */ Symbol("Let zodToJsonSchema decide on which parser to use");
 var defaultOptions = {
@@ -27363,9 +27369,9 @@ function query({
   return queryInstance;
 }
 
-// ../../packages/provider/dist/chunk-MM4XVM5O.js
+// ../../packages/provider/dist/chunk-4PGJBKLH.js
 import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { join as join23 } from "path";
 import {
   chmod,
   mkdir as mkdir2,
@@ -27374,11 +27380,52 @@ import {
   rm as rm2,
   writeFile as writeFile2
 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { join as join23 } from "path";
-import { cp as cp2, mkdir as mkdir22, readFile as readFile22, rm as rm22, stat as stat2, writeFile as writeFile22 } from "fs/promises";
 import { homedir as homedir22 } from "os";
-import { isAbsolute, join as join32, normalize, resolve } from "path";
+import { join as join32 } from "path";
+import { cp as cp2, mkdir as mkdir22, readFile as readFile22, rm as rm22, stat as stat2, writeFile as writeFile22 } from "fs/promises";
+import { homedir as homedir32 } from "os";
+import { isAbsolute, join as join42, normalize, resolve } from "path";
+var CLAUDE_CODE_PATHS = [
+  // User's local bin (npm global install location)
+  join4(homedir3(), ".local", "bin", "claude"),
+  // System-wide installations
+  "/usr/local/bin/claude",
+  // macOS Homebrew
+  "/opt/homebrew/bin/claude",
+  // Windows (if applicable)
+  join4(homedir3(), "AppData", "Local", "Programs", "claude", "claude.exe")
+];
+function findClaudeCodePath() {
+  const envPath = process.env.CLAUDE_CODE_PATH;
+  if (envPath && existsSync3(envPath)) {
+    return envPath;
+  }
+  for (const path3 of CLAUDE_CODE_PATHS) {
+    if (existsSync3(path3)) {
+      return path3;
+    }
+  }
+  try {
+    const whichResult = execSync("which claude", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (whichResult && existsSync3(whichResult)) {
+      return whichResult;
+    }
+  } catch {
+  }
+  throw new Error(
+    `Claude Code not found. Looplia requires Claude Code to be installed.
+
+Install Claude Code:
+  npm install -g @anthropic-ai/claude-code
+
+Or set CLAUDE_CODE_PATH environment variable to your Claude installation.
+
+More info: https://docs.anthropic.com/claude-code`
+  );
+}
 var DEFAULT_CONFIG = {
   model: "claude-haiku-4-5-20251001",
   workspace: "~/.looplia",
@@ -27404,10 +27451,10 @@ function createQueryLogger(workspace) {
   let logPath = null;
   return {
     init(sandboxId) {
-      const logsDir = join4(workspace, "sandbox", sandboxId, "logs");
+      const logsDir = join23(workspace, "sandbox", sandboxId, "logs");
       mkdirSync3(logsDir, { recursive: true });
       const filename = generateLogFilename();
-      logPath = join4(logsDir, filename);
+      logPath = join23(logsDir, filename);
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       writeFileSync2(
         logPath,
@@ -27561,10 +27608,10 @@ var PRESETS = {
 };
 var CONFIG_FILE = "looplia.setting.json";
 function getLoopliaHome() {
-  return join23(homedir3(), ".looplia");
+  return join32(homedir22(), ".looplia");
 }
 function getConfigPath() {
-  return join23(getLoopliaHome(), CONFIG_FILE);
+  return join32(getLoopliaHome(), CONFIG_FILE);
 }
 async function readLoopliaSettings() {
   const configPath = getConfigPath();
@@ -27762,11 +27809,11 @@ function extractSandboxIdFromPrompt(prompt) {
 var extractContentIdFromPrompt = extractSandboxIdFromPrompt;
 function expandPath(path3) {
   if (path3.startsWith("~/") || path3 === "~") {
-    const home = homedir22();
+    const home = homedir32();
     if (!home) {
       throw new Error("Unable to determine home directory");
     }
-    const expanded = path3 === "~" ? home : join32(home, path3.slice(2));
+    const expanded = path3 === "~" ? home : join42(home, path3.slice(2));
     return normalize(expanded);
   }
   if (isAbsolute(path3)) {
@@ -27783,23 +27830,23 @@ async function pathExists2(path3) {
   }
 }
 function getPluginPaths2() {
-  const base = join32(process.cwd(), "plugins");
+  const base = join42(process.cwd(), "plugins");
   return {
-    core: join32(base, "looplia-core"),
-    writer: join32(base, "looplia-writer")
+    core: join42(base, "looplia-core"),
+    writer: join42(base, "looplia-writer")
   };
 }
 async function checkRequiredFiles(workspaceDir) {
   const requiredPaths = [
     // Core structure
-    join32(workspaceDir, "CLAUDE.md"),
-    join32(workspaceDir, ".claude", "agents"),
-    join32(workspaceDir, ".claude", "skills"),
-    join32(workspaceDir, "workflows"),
+    join42(workspaceDir, "CLAUDE.md"),
+    join42(workspaceDir, ".claude", "agents"),
+    join42(workspaceDir, ".claude", "skills"),
+    join42(workspaceDir, "workflows"),
     // From looplia-core plugin
-    join32(workspaceDir, ".claude", "commands"),
-    join32(workspaceDir, ".claude", "skills", "workflow-executor"),
-    join32(workspaceDir, ".claude", "skills", "workflow-validator")
+    join42(workspaceDir, ".claude", "commands"),
+    join42(workspaceDir, ".claude", "skills", "workflow-executor"),
+    join42(workspaceDir, ".claude", "skills", "workflow-validator")
   ];
   for (const path3 of requiredPaths) {
     if (!await pathExists2(path3)) {
@@ -27828,33 +27875,33 @@ async function createTestWorkspace(workspaceDir, force) {
     await rm22(workspaceDir, { recursive: true, force: true });
   }
   await mkdir22(workspaceDir, { recursive: true });
-  await mkdir22(join32(workspaceDir, ".claude", "agents"), { recursive: true });
-  await mkdir22(join32(workspaceDir, ".claude", "skills"), { recursive: true });
-  await mkdir22(join32(workspaceDir, "sandbox"), { recursive: true });
+  await mkdir22(join42(workspaceDir, ".claude", "agents"), { recursive: true });
+  await mkdir22(join42(workspaceDir, ".claude", "skills"), { recursive: true });
+  await mkdir22(join42(workspaceDir, "sandbox"), { recursive: true });
   const plugins = getPluginPaths2();
-  const writerWorkflowsDir = join32(plugins.writer, "workflows");
+  const writerWorkflowsDir = join42(plugins.writer, "workflows");
   if (await pathExists2(writerWorkflowsDir)) {
-    await cp2(writerWorkflowsDir, join32(workspaceDir, "workflows"), {
+    await cp2(writerWorkflowsDir, join42(workspaceDir, "workflows"), {
       recursive: true
     });
   } else {
-    await mkdir22(join32(workspaceDir, "workflows"), { recursive: true });
+    await mkdir22(join42(workspaceDir, "workflows"), { recursive: true });
   }
-  const coreValidatorDir = join32(plugins.core, "skills", "workflow-validator");
+  const coreValidatorDir = join42(plugins.core, "skills", "workflow-validator");
   if (await pathExists2(coreValidatorDir)) {
     await cp2(
       coreValidatorDir,
-      join32(workspaceDir, ".claude", "skills", "workflow-validator"),
+      join42(workspaceDir, ".claude", "skills", "workflow-validator"),
       { recursive: true }
     );
   }
   await writeFile22(
-    join32(workspaceDir, "CLAUDE.md"),
+    join42(workspaceDir, "CLAUDE.md"),
     "# Test Workspace\n",
     "utf-8"
   );
   await writeFile22(
-    join32(workspaceDir, "user-profile.json"),
+    join42(workspaceDir, "user-profile.json"),
     JSON.stringify(createDefaultProfile2(), null, 2),
     "utf-8"
   );
@@ -27865,63 +27912,63 @@ async function bootstrapFromPlugins(workspaceDir, plugins) {
     await rm22(workspaceDir, { recursive: true, force: true });
   }
   await mkdir22(workspaceDir, { recursive: true });
-  await mkdir22(join32(workspaceDir, ".claude"), { recursive: true });
-  await mkdir22(join32(workspaceDir, "sandbox"), { recursive: true });
-  const coreCommandsDir = join32(plugins.core, "commands");
+  await mkdir22(join42(workspaceDir, ".claude"), { recursive: true });
+  await mkdir22(join42(workspaceDir, "sandbox"), { recursive: true });
+  const coreCommandsDir = join42(plugins.core, "commands");
   if (await pathExists2(coreCommandsDir)) {
-    await cp2(coreCommandsDir, join32(workspaceDir, ".claude", "commands"), {
+    await cp2(coreCommandsDir, join42(workspaceDir, ".claude", "commands"), {
       recursive: true
     });
   }
-  const coreSkillsDir = join32(plugins.core, "skills");
+  const coreSkillsDir = join42(plugins.core, "skills");
   if (await pathExists2(coreSkillsDir)) {
-    await cp2(coreSkillsDir, join32(workspaceDir, ".claude", "skills"), {
+    await cp2(coreSkillsDir, join42(workspaceDir, ".claude", "skills"), {
       recursive: true
     });
   }
-  const coreHooksDir = join32(plugins.core, "hooks");
+  const coreHooksDir = join42(plugins.core, "hooks");
   if (await pathExists2(coreHooksDir)) {
-    await cp2(coreHooksDir, join32(workspaceDir, ".claude", "hooks"), {
+    await cp2(coreHooksDir, join42(workspaceDir, ".claude", "hooks"), {
       recursive: true
     });
   }
-  const coreAgentsDir = join32(plugins.core, "agents");
+  const coreAgentsDir = join42(plugins.core, "agents");
   if (await pathExists2(coreAgentsDir)) {
-    await mkdir22(join32(workspaceDir, ".claude", "agents"), { recursive: true });
-    await cp2(coreAgentsDir, join32(workspaceDir, ".claude", "agents"), {
+    await mkdir22(join42(workspaceDir, ".claude", "agents"), { recursive: true });
+    await cp2(coreAgentsDir, join42(workspaceDir, ".claude", "agents"), {
       recursive: true
     });
   }
-  const coreScriptsDir = join32(plugins.core, "scripts");
+  const coreScriptsDir = join42(plugins.core, "scripts");
   if (await pathExists2(coreScriptsDir)) {
-    await cp2(coreScriptsDir, join32(workspaceDir, "scripts"), {
+    await cp2(coreScriptsDir, join42(workspaceDir, "scripts"), {
       recursive: true
     });
   }
-  const coreClaudeMd = join32(plugins.core, "CLAUDE.md");
+  const coreClaudeMd = join42(plugins.core, "CLAUDE.md");
   if (await pathExists2(coreClaudeMd)) {
-    await cp2(coreClaudeMd, join32(workspaceDir, "CLAUDE.md"));
+    await cp2(coreClaudeMd, join42(workspaceDir, "CLAUDE.md"));
   }
-  const writerAgentsDir = join32(plugins.writer, "agents");
+  const writerAgentsDir = join42(plugins.writer, "agents");
   if (await pathExists2(writerAgentsDir)) {
-    await cp2(writerAgentsDir, join32(workspaceDir, ".claude", "agents"), {
+    await cp2(writerAgentsDir, join42(workspaceDir, ".claude", "agents"), {
       recursive: true
     });
   }
-  const writerSkillsDir = join32(plugins.writer, "skills");
+  const writerSkillsDir = join42(plugins.writer, "skills");
   if (await pathExists2(writerSkillsDir)) {
-    await cp2(writerSkillsDir, join32(workspaceDir, ".claude", "skills"), {
+    await cp2(writerSkillsDir, join42(workspaceDir, ".claude", "skills"), {
       recursive: true
     });
   }
-  const writerWorkflowsDir = join32(plugins.writer, "workflows");
+  const writerWorkflowsDir = join42(plugins.writer, "workflows");
   if (await pathExists2(writerWorkflowsDir)) {
-    await cp2(writerWorkflowsDir, join32(workspaceDir, "workflows"), {
+    await cp2(writerWorkflowsDir, join42(workspaceDir, "workflows"), {
       recursive: true
     });
   }
   await writeFile22(
-    join32(workspaceDir, "user-profile.json"),
+    join42(workspaceDir, "user-profile.json"),
     JSON.stringify(createDefaultProfile2(), null, 2),
     "utf-8"
   );
@@ -27956,12 +28003,12 @@ async function ensureWorkspace(options) {
   return workspaceDir;
 }
 async function readUserProfile(workspaceDir) {
-  const profilePath = join32(workspaceDir, "user-profile.json");
+  const profilePath = join42(workspaceDir, "user-profile.json");
   const content = await readFile22(profilePath, "utf-8");
   return JSON.parse(content);
 }
 async function writeUserProfile(workspaceDir, profile) {
-  const profilePath = join32(workspaceDir, "user-profile.json");
+  const profilePath = join42(workspaceDir, "user-profile.json");
   await writeFile22(profilePath, JSON.stringify(profile, null, 2), "utf-8");
 }
 var workspaceCache = /* @__PURE__ */ new Map();
@@ -28542,9 +28589,12 @@ YOU MUST CALL THE WRITE TOOL before completing. If you don't write the file, the
         model: executorModel
       }
     };
+    const claudeCodePath = findClaudeCodePath();
     const result = query({
       prompt,
       options: {
+        // v0.6.8: Use system-installed Claude Code
+        pathToClaudeCodeExecutable: claudeCodePath,
         // v0.6.6: Use configured main model
         model: mainModel,
         // v0.6.5: SDK works relative to ~/.looplia (sandbox, workflows, etc.)
@@ -29833,14 +29883,14 @@ import { Box as Box20, Text as Text21, useApp, useInput as useInput6 } from "ink
 import { useCallback as useCallback2, useEffect as useEffect6, useMemo as useMemo2, useState as useState6 } from "react";
 
 // src/utils/agent-logger.ts
-import { appendFileSync as appendFileSync4, existsSync as existsSync3, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
+import { appendFileSync as appendFileSync4, existsSync as existsSync4, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join6 } from "path";
 var isDebugEnabled = () => process.env.LOOPLIA_DEBUG === "1";
 var getLogsDir = (context) => join6(homedir4(), ".looplia", "logs", context);
 function ensureLogsDir(context) {
   const logsDir = getLogsDir(context);
-  if (!existsSync3(logsDir)) {
+  if (!existsSync4(logsDir)) {
     mkdirSync4(logsDir, { recursive: true });
   }
   return logsDir;
@@ -31338,14 +31388,14 @@ function getWorkspacePath2() {
 function ensureWorkspace2(mock) {
   const workspace = getWorkspacePath2();
   const workflowsDir = resolve2(workspace, "workflows");
-  if (!existsSync4(workspace)) {
+  if (!existsSync5(workspace)) {
     if (mock) {
       mkdirSync5(workflowsDir, { recursive: true });
     } else {
       console.error("Workspace not initialized. Run: looplia init");
       process.exit(1);
     }
-  } else if (!existsSync4(workflowsDir)) {
+  } else if (!existsSync5(workflowsDir)) {
     mkdirSync5(workflowsDir, { recursive: true });
   }
   return workspace;
@@ -32711,7 +32761,7 @@ async function runInitCommand(args) {
 import { randomBytes } from "crypto";
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync6,
   readFileSync as readFileSync2,
   writeFileSync as writeFileSync4
@@ -32790,7 +32840,7 @@ function createSandboxWithInputs(workspace, workflowId, inputs) {
         );
       } else {
         const absolutePath = resolve3(parsedInput.value);
-        if (!existsSync5(absolutePath)) {
+        if (!existsSync6(absolutePath)) {
           throw new Error(`Input file not found: ${parsedInput.value}`);
         }
         copyFileSync2(absolutePath, join8(sandboxDir, "inputs", `${name}.md`));
@@ -32958,7 +33008,7 @@ function getWorkspacePath3() {
 }
 function ensureWorkspace3(mock) {
   const workspace = getWorkspacePath3();
-  if (!existsSync5(workspace)) {
+  if (!existsSync6(workspace)) {
     if (mock) {
       mkdirSync6(join8(workspace, "sandbox"), { recursive: true });
     } else {
@@ -32986,7 +33036,7 @@ function buildRunPrompt(workflowId, sandboxId) {
 }
 function checkWorkflowInputless(workspace, workflowId) {
   const workflowPath = join8(workspace, "workflows", `${workflowId}.md`);
-  if (!existsSync5(workflowPath)) {
+  if (!existsSync6(workflowPath)) {
     return false;
   }
   try {
@@ -33055,7 +33105,7 @@ async function executeBatch2(prompt, workspace, workflowId) {
 function resolveSandboxId(workspace, parsed, allowInputless) {
   if (parsed.sandboxId) {
     const sandboxDir = join8(workspace, "sandbox", parsed.sandboxId);
-    if (!existsSync5(sandboxDir)) {
+    if (!existsSync6(sandboxDir)) {
       console.error(`Error: Sandbox not found: ${parsed.sandboxId}`);
       console.error(`Path: ${sandboxDir}`);
       process.exit(1);
@@ -33072,7 +33122,7 @@ function resolveSandboxId(workspace, parsed, allowInputless) {
     return sandboxId;
   }
   if (parsed.file) {
-    if (!existsSync5(parsed.file)) {
+    if (!existsSync6(parsed.file)) {
       console.error(`Error: File not found: ${parsed.file}`);
       process.exit(1);
     }
@@ -33152,7 +33202,7 @@ async function runRunCommand(args) {
 }
 
 // src/index.ts
-var VERSION = "0.6.7";
+var VERSION = "0.6.8";
 function printHelp3() {
   console.log(`
 looplia - Content intelligence CLI (v${VERSION})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@looplia/looplia-cli",
-  "version": "0.6.7",
+  "version": "0.6.8",
   "description": "Looplia CLI - AI-powered workflow automation tool",
   "type": "module",
   "license": "Elastic-2.0",