@pipeline-studio/local-agent 0.1.0

package/bin/psa.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../dist/cli.js')

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli.js

@@ -0,0 +1,665 @@
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/connect.ts
+import { randomUUID } from "crypto";
+
+// src/config.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var CONFIG_DIR = path.join(os.homedir(), ".pipeline-studio");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+var PID_FILE = path.join(CONFIG_DIR, "agent.pid");
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+function loadConfig() {
+  if (!fs.existsSync(CONFIG_FILE)) return null;
+  try {
+    const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.chmodSync(CONFIG_DIR, 448);
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+  fs.chmodSync(CONFIG_FILE, 384);
+}
+function savePid(pid) {
+  fs.writeFileSync(PID_FILE, String(pid));
+}
+function readPid() {
+  if (!fs.existsSync(PID_FILE)) return null;
+  try {
+    return parseInt(fs.readFileSync(PID_FILE, "utf-8").trim(), 10);
+  } catch {
+    return null;
+  }
+}
+function clearPid() {
+  if (fs.existsSync(PID_FILE)) fs.unlinkSync(PID_FILE);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/connect.ts
+async function connectCommand(cloudUrl) {
+  const chalk = (await import("chalk")).default;
+  const ora = (await import("ora")).default;
+  const open = (await import("open")).default;
+  const url = cloudUrl.replace(/\/$/, "");
+  const deviceCode = randomUUID().slice(0, 8);
+  console.log(chalk.bold("\nPipeline Studio Agent \u2014 Connect\n"));
+  console.log(chalk.dim(`Cloud URL: ${url}`));
+  console.log(chalk.dim(`Device code: ${deviceCode}
+`));
+  const authUrl = `${url}/agent/authorize?code=${deviceCode}`;
+  console.log(chalk.cyan(`Opening browser: ${authUrl}
+`));
+  const spinner = ora("Waiting for authorization...").start();
+  try {
+    await open(authUrl);
+  } catch {
+    spinner.warn("Could not open browser automatically");
+    console.log(chalk.yellow(`Open this URL manually: ${authUrl}
+`));
+  }
+  const maxAttempts = 60;
+  const pollInterval = 3e3;
+  for (let i = 0; i < maxAttempts; i++) {
+    await new Promise((r) => setTimeout(r, pollInterval));
+    try {
+      const res = await fetch(`${url}/api/agent/register`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ deviceCode })
+      });
+      if (res.ok) {
+        const data = await res.json();
+        const config = {
+          cloudUrl: url,
+          token: data.token,
+          agentId: data.agentId,
+          projects: []
+        };
+        saveConfig(config);
+        spinner.succeed(chalk.green("Connected successfully!"));
+        console.log(chalk.dim(`
+Config saved to: ${getConfigPath()}`));
+        console.log(chalk.dim(`Agent ID: ${data.agentId}`));
+        console.log(chalk.bold("\nNext step: run ") + chalk.cyan("psa start"));
+        return;
+      }
+      if (res.status === 202) {
+        continue;
+      }
+      if (res.status >= 400) {
+        spinner.fail(chalk.red(`Authorization failed: ${res.status}`));
+        return;
+      }
+    } catch {
+    }
+  }
+  spinner.fail(chalk.red("Authorization timed out. Please try again."));
+}
+
+// src/client/cloud-client.ts
+var CloudClient = class {
+  baseUrl;
+  token;
+  agentId;
+  constructor(config) {
+    this.baseUrl = config.cloudUrl.replace(/\/$/, "");
+    this.token = config.token;
+    this.agentId = config.agentId;
+  }
+  async request(path3, options = {}) {
+    const url = `${this.baseUrl}${path3}`;
+    const res = await fetch(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.token}`,
+        "X-Agent-Id": this.agentId,
+        ...options.headers
+      }
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`API ${res.status}: ${body}`);
+    }
+    return res.json();
+  }
+  async heartbeat(runningPipelines) {
+    await this.request("/api/agent/heartbeat", {
+      method: "POST",
+      body: JSON.stringify({
+        agentId: this.agentId,
+        runningPipelines,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    });
+  }
+  async pollCommands() {
+    return this.request("/api/agent/commands");
+  }
+  async ackCommand(commandId) {
+    await this.request(`/api/agent/commands/${commandId}/ack`, {
+      method: "POST"
+    });
+  }
+  async sendEvents(events) {
+    if (events.length === 0) return;
+    await this.request("/api/agent/events", {
+      method: "POST",
+      body: JSON.stringify({ events })
+    });
+  }
+  async sendEvent(event) {
+    await this.sendEvents([event]);
+  }
+  async register(projects) {
+    return this.request("/api/agent/register", {
+      method: "POST",
+      body: JSON.stringify({ projects })
+    });
+  }
+};
+
+// src/client/polling.ts
+var CommandPoller = class {
+  client;
+  handler;
+  interval = null;
+  heartbeatInterval = null;
+  running = false;
+  getRunningPipelines;
+  constructor(client, handler, getRunningPipelines) {
+    this.client = client;
+    this.handler = handler;
+    this.getRunningPipelines = getRunningPipelines;
+  }
+  start(pollMs = 5e3, heartbeatMs = 3e4) {
+    if (this.running) return;
+    this.running = true;
+    this.poll();
+    this.interval = setInterval(() => this.poll(), pollMs);
+    this.sendHeartbeat();
+    this.heartbeatInterval = setInterval(() => this.sendHeartbeat(), heartbeatMs);
+  }
+  stop() {
+    this.running = false;
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+  async poll() {
+    if (!this.running) return;
+    try {
+      const commands = await this.client.pollCommands();
+      for (const cmd of commands) {
+        await this.client.ackCommand(cmd.id);
+        await this.handler(cmd);
+      }
+    } catch {
+    }
+  }
+  async sendHeartbeat() {
+    if (!this.running) return;
+    try {
+      await this.client.heartbeat(this.getRunningPipelines());
+    } catch {
+    }
+  }
+};
+
+// src/runner/pipeline-runner.ts
+import { spawn } from "child_process";
+import { EventEmitter } from "events";
+var MAX_TOKENS_BY_MODEL = {
+  "claude-opus-4-6": 2e5,
+  "claude-sonnet-4-6": 2e5,
+  "claude-sonnet-4-5-20250929": 2e5,
+  "claude-haiku-4-5-20251001": 2e5
+};
+var CONTEXT_WARN_THRESHOLD = 0.6;
+var PipelineRunner = class extends EventEmitter {
+  processes = /* @__PURE__ */ new Map();
+  run(options) {
+    const { projectPath, ticketKey, model = "claude-sonnet-4-6", maxTurns, manualTicketContext } = options;
+    if (this.processes.has(ticketKey)) {
+      const existing = this.processes.get(ticketKey);
+      if (this.isAlive(existing)) {
+        throw new Error(`Pipeline already running for ${ticketKey}`);
+      }
+      this.processes.delete(ticketKey);
+    }
+    const env = this.buildEnv(model);
+    const args = this.buildArgs(model, ticketKey, maxTurns, manualTicketContext);
+    const proc = spawn("claude", args, {
+      cwd: projectPath,
+      env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    this.processes.set(ticketKey, proc);
+    proc.stdout?.on("data", (chunk) => {
+      const lines = chunk.toString().split("\n").filter(Boolean);
+      for (const line of lines) {
+        this.emit(ticketKey, { type: "log", data: line });
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed.type === "result") {
+            this.emit(ticketKey, {
+              type: "result",
+              resultSubtype: parsed.subtype ?? null,
+              totalCostUsd: parsed.total_cost_usd ?? 0,
+              durationMs: parsed.duration_ms ?? 0,
+              durationApiMs: parsed.duration_api_ms ?? 0,
+              numTurns: parsed.num_turns ?? 0,
+              inputTokens: parsed.usage?.input_tokens ?? 0,
+              outputTokens: parsed.usage?.output_tokens ?? 0,
+              cacheCreationTokens: parsed.usage?.cache_creation_input_tokens ?? 0,
+              cacheReadTokens: parsed.usage?.cache_read_input_tokens ?? 0
+            });
+          }
+        } catch {
+        }
+        const tokenMatch = line.match(/"input_tokens":\s*(\d+)/);
+        if (tokenMatch) {
+          const inputTokens = parseInt(tokenMatch[1]);
+          const maxTokens = MAX_TOKENS_BY_MODEL[model] ?? 2e5;
+          const percent = inputTokens / maxTokens;
+          if (percent > CONTEXT_WARN_THRESHOLD) {
+            this.emit(ticketKey, {
+              type: "context_warning",
+              contextPercent: percent,
+              inputTokens,
+              maxTokens
+            });
+          }
+        }
+      }
+    });
+    proc.stderr?.on("data", (chunk) => {
+      this.emit(ticketKey, { type: "log", data: `[stderr] ${chunk.toString()}` });
+    });
+    proc.on("exit", (code) => {
+      this.processes.delete(ticketKey);
+      this.emit(ticketKey, { type: "exit", exitCode: code ?? 1 });
+    });
+  }
+  stop(ticketKey) {
+    const proc = this.processes.get(ticketKey);
+    if (proc) {
+      proc.kill("SIGTERM");
+      this.processes.delete(ticketKey);
+    }
+  }
+  isRunning(ticketKey) {
+    const proc = this.processes.get(ticketKey);
+    if (!proc) return false;
+    if (!this.isAlive(proc)) {
+      this.processes.delete(ticketKey);
+      return false;
+    }
+    return true;
+  }
+  runningKeys() {
+    for (const [key, proc] of this.processes) {
+      if (!this.isAlive(proc)) this.processes.delete(key);
+    }
+    return [...this.processes.keys()];
+  }
+  isAlive(proc) {
+    if (proc.exitCode !== null || proc.killed) return false;
+    if (!proc.pid) return false;
+    try {
+      process.kill(proc.pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  buildEnv(model) {
+    const env = { ...process.env };
+    delete env["ANTHROPIC_API_KEY"];
+    delete env["CLAUDECODE"];
+    for (const key of Object.keys(env)) {
+      if (key.startsWith("CLAUDE_CODE_")) delete env[key];
+    }
+    env["CLAUDE_USE_SUBSCRIPTION"] = "true";
+    env["ARENA_MODEL"] = model;
+    return env;
+  }
+  buildArgs(model, ticketKey, maxTurns, manualTicketContext) {
+    const safeTurns = maxTurns && maxTurns > 0 ? maxTurns : 200;
+    const parts = [
+      `Execute o skill /pipeline para a task ${ticketKey}. Use a configuracao em .claude/pipeline-config.json para ordem de fases, agentes por fase e configuracao de gates. Rode todas as fases do pipeline ate a conclusao completa. Todos os reports devem ser escritos em .claude/reports/${ticketKey}/ dentro do diretorio de trabalho.`
+    ];
+    if (manualTicketContext) {
+      parts.push("", manualTicketContext);
+    }
+    return [
+      "--print",
+      "--dangerously-skip-permissions",
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--model",
+      model,
+      "--max-turns",
+      String(safeTurns),
+      parts.join("\n")
+    ];
+  }
+};
+
+// src/runner/file-watcher.ts
+import chokidar from "chokidar";
+import fs2 from "fs";
+import path2 from "path";
+import { EventEmitter as EventEmitter2 } from "events";
+var DEFAULT_PHASE_MAP = {
+  "ticket.json": "1-READ",
+  "architecture-report.md": "2-PLAN",
+  "implementation-manifest.md": "3-IMPLEMENT",
+  "validation-report.md": "4-VALIDATE",
+  "test-report.md": "5-TEST",
+  "e2e-report.md": "6-E2E",
+  "review-report.md": "7-REVIEW",
+  "pr-report.md": "9-PR",
+  "ci-report.md": "10-CI",
+  "deploy-report.md": "11-DEPLOY"
+};
+var PhaseWatcher = class extends EventEmitter2 {
+  watchers = /* @__PURE__ */ new Map();
+  emittedPhases = /* @__PURE__ */ new Map();
+  watch(projectPath, ticketId) {
+    if (this.watchers.has(ticketId)) this.unwatch(ticketId);
+    const reportsDir = path2.join(projectPath, ".claude", "reports", ticketId);
+    if (!fs2.existsSync(reportsDir)) {
+      fs2.mkdirSync(reportsDir, { recursive: true });
+    }
+    this.emittedPhases.set(ticketId, /* @__PURE__ */ new Set());
+    const watcher = chokidar.watch(reportsDir, {
+      persistent: true,
+      ignoreInitial: false,
+      awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 }
+    });
+    watcher.on("add", (filepath) => this.handleFile(filepath, ticketId));
+    watcher.on("change", (filepath) => this.handleFile(filepath, ticketId));
+    this.watchers.set(ticketId, watcher);
+  }
+  unwatch(ticketId) {
+    const watcher = this.watchers.get(ticketId);
+    if (watcher) {
+      watcher.close();
+      this.watchers.delete(ticketId);
+    }
+    this.emittedPhases.delete(ticketId);
+  }
+  unwatchAll() {
+    for (const ticketId of this.watchers.keys()) {
+      this.unwatch(ticketId);
+    }
+  }
+  handleFile(filepath, ticketId) {
+    const filename = path2.basename(filepath);
+    const phase = DEFAULT_PHASE_MAP[filename];
+    if (phase) {
+      const emitted = this.emittedPhases.get(ticketId);
+      if (emitted?.has(phase)) return;
+      emitted?.add(phase);
+      this.emit("event", {
+        type: "phase_complete",
+        ticketId,
+        phase,
+        reportPath: filepath
+      });
+      return;
+    }
+    if (/^human-task-\d+\.json$/.test(filename)) {
+      try {
+        const raw = fs2.readFileSync(filepath, "utf-8");
+        const task = JSON.parse(raw);
+        this.emit("event", {
+          type: "human_task_created",
+          ticketId,
+          humanTask: task
+        });
+      } catch {
+      }
+    }
+  }
+};
+
+// src/runner/event-reporter.ts
+var EventReporter = class {
+  client;
+  buffer = [];
+  flushTimer = null;
+  constructor(client, flushIntervalMs = 2e3) {
+    this.client = client;
+    this.flushTimer = setInterval(() => this.flush(), flushIntervalMs);
+  }
+  reportPipelineEvent(ticketKey, runId, event) {
+    this.buffer.push({
+      type: event.type,
+      ticketKey,
+      runId,
+      data: event.data,
+      phase: event.phase,
+      exitCode: event.exitCode,
+      resultSubtype: event.resultSubtype,
+      totalCostUsd: event.totalCostUsd,
+      durationMs: event.durationMs,
+      numTurns: event.numTurns,
+      inputTokens: event.inputTokens,
+      outputTokens: event.outputTokens,
+      cacheCreationTokens: event.cacheCreationTokens,
+      cacheReadTokens: event.cacheReadTokens,
+      contextPercent: event.contextPercent
+    });
+  }
+  reportPhaseEvent(ticketKey, runId, event) {
+    if (event.type === "phase_complete") {
+      this.buffer.push({
+        type: "phase_detected",
+        ticketKey,
+        runId,
+        phase: event.phase,
+        data: event.reportPath
+      });
+    } else if (event.type === "human_task_created") {
+      this.buffer.push({
+        type: "human_task",
+        ticketKey,
+        runId,
+        data: JSON.stringify(event.humanTask)
+      });
+    }
+  }
+  async flush() {
+    if (this.buffer.length === 0) return;
+    const events = [...this.buffer];
+    this.buffer = [];
+    try {
+      await this.client.sendEvents(events);
+    } catch {
+      this.buffer.unshift(...events);
+    }
+  }
+  stop() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+};
+
+// src/commands/start.ts
+import { randomUUID as randomUUID2 } from "crypto";
+async function startCommand(foreground) {
+  const chalk = (await import("chalk")).default;
+  const config = loadConfig();
+  if (!config) {
+    console.log(chalk.red("Not connected. Run: psa connect <cloud-url>"));
+    process.exit(1);
+  }
+  console.log(chalk.bold("\nPipeline Studio Agent\n"));
+  console.log(chalk.dim(`Cloud: ${config.cloudUrl}`));
+  console.log(chalk.dim(`Agent: ${config.agentId}`));
+  console.log(chalk.dim(`Mode: ${foreground ? "foreground" : "daemon"}
+`));
+  savePid(process.pid);
+  const client = new CloudClient(config);
+  const runner = new PipelineRunner();
+  const watcher = new PhaseWatcher();
+  const reporter = new EventReporter(client);
+  const runIds = /* @__PURE__ */ new Map();
+  async function handleCommand(cmd) {
+    if (cmd.type === "start_pipeline") {
+      const runId = randomUUID2();
+      runIds.set(cmd.ticketKey, runId);
+      console.log(chalk.cyan(`[${cmd.ticketKey}] Starting pipeline...`));
+      runner.on(cmd.ticketKey, (event) => {
+        reporter.reportPipelineEvent(cmd.ticketKey, runId, event);
+        if (event.type === "exit") {
+          console.log(chalk.dim(`[${cmd.ticketKey}] Pipeline exited (code ${event.exitCode})`));
+          watcher.unwatch(cmd.ticketKey);
+          runIds.delete(cmd.ticketKey);
+          reporter.flush();
+        }
+      });
+      watcher.on("event", (event) => {
+        if (event.ticketId === cmd.ticketKey) {
+          reporter.reportPhaseEvent(cmd.ticketKey, runId, event);
+          if (event.phase) {
+            console.log(chalk.green(`[${cmd.ticketKey}] Phase: ${event.phase}`));
+          }
+        }
+      });
+      watcher.watch(cmd.projectPath, cmd.ticketKey);
+      runner.run({
+        projectPath: cmd.projectPath,
+        ticketKey: cmd.ticketKey,
+        model: cmd.model,
+        maxTurns: cmd.maxTurns,
+        manualTicketContext: cmd.manualTicketContext
+      });
+    } else if (cmd.type === "stop_pipeline") {
+      console.log(chalk.yellow(`[${cmd.ticketKey}] Stopping pipeline...`));
+      runner.stop(cmd.ticketKey);
+      watcher.unwatch(cmd.ticketKey);
+      runIds.delete(cmd.ticketKey);
+    }
+  }
+  const poller = new CommandPoller(
+    client,
+    handleCommand,
+    () => runner.runningKeys()
+  );
+  poller.start();
+  console.log(chalk.green("Agent started. Listening for commands...\n"));
+  const shutdown = () => {
+    console.log(chalk.yellow("\nShutting down..."));
+    poller.stop();
+    reporter.stop();
+    watcher.unwatchAll();
+    for (const key of runner.runningKeys()) {
+      runner.stop(key);
+    }
+    clearPid();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  if (foreground) {
+    await new Promise(() => {
+    });
+  }
+}
+
+// src/commands/stop.ts
+async function stopCommand() {
+  const chalk = (await import("chalk")).default;
+  const pid = readPid();
+  if (!pid) {
+    console.log(chalk.yellow("No agent process found."));
+    return;
+  }
+  if (!isProcessAlive(pid)) {
+    console.log(chalk.yellow("Agent process is not running. Cleaning up..."));
+    clearPid();
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    console.log(chalk.green(`Agent stopped (PID: ${pid})`));
+    clearPid();
+  } catch {
+    console.log(chalk.red("Failed to stop agent process."));
+  }
+}
+
+// src/commands/status.ts
+async function statusCommand() {
+  const chalk = (await import("chalk")).default;
+  const config = loadConfig();
+  if (!config) {
+    console.log(chalk.red("Not connected. Run: psa connect <cloud-url>"));
+    return;
+  }
+  console.log(chalk.bold("\nPipeline Studio Agent Status\n"));
+  console.log(`  Cloud URL:  ${chalk.cyan(config.cloudUrl)}`);
+  console.log(`  Agent ID:   ${chalk.dim(config.agentId)}`);
+  console.log(`  Config:     ${chalk.dim(getConfigPath())}`);
+  const pid = readPid();
+  if (pid && isProcessAlive(pid)) {
+    console.log(`  Status:     ${chalk.green("Online")} (PID: ${pid})`);
+  } else {
+    console.log(`  Status:     ${chalk.yellow("Offline")}`);
+  }
+  if (config.projects.length > 0) {
+    console.log(`
+  Projects:`);
+    for (const p of config.projects) {
+      console.log(`    ${chalk.dim("-")} ${p}`);
+    }
+  }
+  console.log("");
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("psa").description("Pipeline Studio Agent \u2014 Run AI engineering pipelines locally, connected to the cloud dashboard").version("0.1.0");
+program.command("connect <cloud-url>").description("Connect this machine to a Pipeline Studio cloud instance").action(async (cloudUrl) => {
+  await connectCommand(cloudUrl);
+});
+program.command("start").description("Start the agent daemon \u2014 listens for pipeline commands from the cloud").option("-f, --foreground", "Run in foreground instead of as daemon", false).action(async (opts) => {
+  await startCommand(opts.foreground);
+});
+program.command("stop").description("Stop the running agent daemon").action(async () => {
+  await stopCommand();
+});
+program.command("status").description("Show agent connection status").action(async () => {
+  await statusCommand();
+});
+program.parse();

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@pipeline-studio/local-agent",
+  "version": "0.1.0",
+  "description": "Local agent for Pipeline Studio — runs Claude CLI pipelines and syncs with cloud dashboard",
+  "type": "module",
+  "main": "./dist/cli.js",
+  "types": "./dist/cli.d.ts",
+  "bin": {
+    "psa": "./bin/psa.js"
+  },
+  "scripts": {
+    "build": "tsup src/cli.ts --format esm --dts --outDir dist",
+    "dev": "tsup src/cli.ts --format esm --watch",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/felipemlanna1/pipeline-studio.git",
+    "directory": "packages/local-agent"
+  },
+  "homepage": "https://github.com/felipemlanna1/pipeline-studio#readme",
+  "author": "Felipe Moreira Lanna <felipemlanna@gmail.com>",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "chokidar": "^4.0.3",
+    "commander": "^12.1.0",
+    "open": "^10.1.0",
+    "ora": "^8.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "keywords": [
+    "pipeline-studio",
+    "claude",
+    "ai",
+    "agent",
+    "cli",
+    "pipeline",
+    "automation"
+  ],
+  "license": "MIT"
+}