@3lineas/grooveskills 1.0.3 → 1.1.2

package/dist/chunk-5Q6O3BRA.js

@@ -0,0 +1,737 @@
+// src/domains/detector/project-detector.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/domains/detector/detect-agents.ts
+import { readdirSync } from "fs";
+function detectAgents(targetPath) {
+  const detected = [];
+  try {
+    const entries = new Set(readdirSync(targetPath));
+    if (entries.has(".agents")) {
+      detected.push("antigravity");
+    }
+    if (entries.has(".claude")) {
+      detected.push("claude");
+    }
+    if (entries.has(".cursor")) {
+      detected.push("cursor");
+    }
+    if (entries.has(".gemini")) {
+      detected.push("gemini");
+    }
+  } catch {
+  }
+  return detected;
+}
+
+// src/domains/detector/detect-dependencies.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+function detectDependencies(targetPath) {
+  const packageJsonPath = join(targetPath, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return { dependencies: [], exists: false };
+  }
+  try {
+    const raw = readFileSync(packageJsonPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const direct = Object.keys(parsed.dependencies ?? {});
+    const dev = Object.keys(parsed.devDependencies ?? {});
+    const all = Array.from(/* @__PURE__ */ new Set([...direct, ...dev]));
+    return { dependencies: all, exists: true };
+  } catch {
+    return { dependencies: [], exists: true };
+  }
+}
+
+// src/domains/registry/skill-catalog.ts
+var SKILL_CATALOG = [
+  {
+    id: "groove-harness",
+    name: "GrooveSkills Harness",
+    description: "Lightweight project harness, context memory, and 3-lane task execution (Answer, Task, Spec) for AI coding agents",
+    dependencies: [],
+    directoryName: "groove-harness"
+  },
+  {
+    id: "best-practices",
+    name: "Universal Best Practices",
+    description: "Multi-language clean code standards, early returns, no barrel files, strict typing, <200 lines",
+    dependencies: [],
+    directoryName: "best-practices"
+  },
+  {
+    id: "hono",
+    name: "Hono Architecture (Valibot)",
+    description: "Enterprise Hono API standard with Valibot validation, isolated Actions layer, and RPC bindings",
+    dependencies: ["hono", "@hono/valibot-validator", "@hono/standard-validator"],
+    directoryName: "hono"
+  },
+  {
+    id: "react-core",
+    name: "React Core Fundamentals",
+    description: "Opinionated React fundamentals: function components, JSX, immutable state, core hooks, lists, and controlled inputs",
+    dependencies: ["react", "react-dom"],
+    directoryName: "react-core"
+  },
+  {
+    id: "react-advanced",
+    name: "React 19 Advanced & Compiler Architecture",
+    description: "Modern React 19 platform features: React Compiler auto-memoization, concurrent rendering, use(), Actions, virtualization, and RSC boundaries",
+    dependencies: ["react", "react-dom"],
+    directoryName: "react-advanced"
+  },
+  {
+    id: "react-create-page",
+    name: "React Page & View Architecture",
+    description: "Clean architecture for React pages: declarative page coordinators, domain hooks, isolated API actions, Valibot + Formisch forms, and atomic co-location",
+    dependencies: ["react", "react-dom"],
+    directoryName: "react-create-page"
+  }
+];
+
+// src/domains/detector/project-detector.ts
+function detectProjectContext(targetPath) {
+  const detectedAgents = detectAgents(targetPath);
+  const { dependencies, exists } = detectDependencies(targetPath);
+  const suggestedSkillIds = ["best-practices"];
+  for (const skill of SKILL_CATALOG) {
+    if (skill.dependencies.length === 0) {
+      continue;
+    }
+    const hasMatch = skill.dependencies.some((dep) => dependencies.includes(dep));
+    if (hasMatch && !suggestedSkillIds.includes(skill.id)) {
+      suggestedSkillIds.push(skill.id);
+    }
+  }
+  const harnessExists = existsSync2(join2(targetPath, ".grooveskills", "memory", "context.md"));
+  return {
+    targetPath,
+    detectedDependencies: dependencies,
+    suggestedSkillIds,
+    detectedAgents,
+    packageJsonExists: exists,
+    harnessExists
+  };
+}
+
+// src/domains/ui/ui-orchestrator.ts
+import * as p5 from "@clack/prompts";
+import pc2 from "picocolors";
+
+// src/domains/ui/banners.ts
+import pc from "picocolors";
+function renderBanner() {
+  const title = pc.bold(pc.white(" GROOVE SKILLS "));
+  const badge = pc.bgMagenta(pc.black(title));
+  const subtitle = pc.dim("Multi-Agent AI Skills & Architectural Standards");
+  return `${badge}  ${subtitle}
+`;
+}
+
+// src/domains/ui/prompt-skills.ts
+import * as p from "@clack/prompts";
+async function promptSkills(suggestedSkillIds) {
+  const options = SKILL_CATALOG.map((skill) => {
+    const isSuggested = suggestedSkillIds.includes(skill.id);
+    return {
+      value: skill.id,
+      label: skill.name,
+      hint: isSuggested ? "Suggested based on your project stack" : skill.description
+    };
+  });
+  const selected = await p.multiselect({
+    message: "Which skills would you like to install in this project?",
+    options,
+    initialValues: suggestedSkillIds,
+    required: true
+  });
+  return selected;
+}
+
+// src/domains/ui/prompt-agents.ts
+import * as p2 from "@clack/prompts";
+async function promptAgents(detectedAgents) {
+  const options = [
+    { value: "antigravity", label: "Antigravity", hint: ".agents/skills (Google Agentic IDE)" },
+    { value: "claude", label: "Claude Code", hint: ".claude/skills (Anthropic Claude Code)" },
+    { value: "cursor", label: "Cursor", hint: ".cursor/rules/*.mdc (Cursor IDE Rules)" },
+    { value: "gemini", label: "Gemini Code Assist", hint: ".gemini/skills (Google Gemini)" }
+  ];
+  const initialValues = detectedAgents.length > 0 ? detectedAgents : ["antigravity"];
+  const selected = await p2.multiselect({
+    message: "Which AI agents should be configured?",
+    options,
+    initialValues,
+    required: true
+  });
+  return selected;
+}
+
+// src/domains/ui/prompt-harness.ts
+import * as p3 from "@clack/prompts";
+async function promptHarness(harnessExists) {
+  const message = harnessExists ? "GrooveSkills Harness is already initialized. Would you like to update agent rules and memory templates?" : "Would you like to initialize the GrooveSkills Harness in .grooveskills/ (project memory, ADR, and 3-lane task execution)?";
+  const confirm3 = await p3.confirm({
+    message,
+    initialValue: true
+  });
+  return confirm3;
+}
+
+// src/domains/ui/prompt-confirm-overwrite.ts
+import * as p4 from "@clack/prompts";
+async function promptConfirmOverwrite() {
+  return await p4.confirm({
+    message: "Some skills already exist in this project. Would you like to overwrite them with the latest version?",
+    initialValue: true
+  });
+}
+
+// src/domains/installer/verify-skill-exists.ts
+import { lstatSync } from "fs";
+import { join as join3 } from "path";
+var AGENT_DESTINATION_MAP = {
+  antigravity: (dir) => join3(".agents", "skills", dir),
+  claude: (dir) => join3(".claude", "skills", dir),
+  cursor: (dir) => join3(".cursor", "rules", `${dir}.mdc`),
+  gemini: (dir) => join3(".gemini", "skills", dir)
+};
+function verifySkillExists(targetPath, skillDirectoryName, agents) {
+  for (const agent of agents) {
+    const relativePathResolver = AGENT_DESTINATION_MAP[agent];
+    const destination = join3(targetPath, relativePathResolver(skillDirectoryName));
+    try {
+      lstatSync(destination);
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+
+// src/domains/installer/install-orchestrator.ts
+import { join as join13 } from "path";
+
+// src/domains/adapters/antigravity.adapter.ts
+import { mkdirSync, existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
+
+// src/domains/project-store/project-paths.ts
+import { join as join4 } from "path";
+function getProjectStoreDir(targetPath) {
+  return join4(targetPath, ".grooveskills");
+}
+function getProjectSkillsDir(targetPath) {
+  return join4(getProjectStoreDir(targetPath), "skills");
+}
+function getProjectCursorRulesDir(targetPath) {
+  return join4(getProjectStoreDir(targetPath), "cursor-rules");
+}
+function getProjectMemoryDir(targetPath) {
+  return join4(getProjectStoreDir(targetPath), "memory");
+}
+function getProjectTasksDir(targetPath) {
+  return join4(getProjectMemoryDir(targetPath), "tasks");
+}
+function getProjectConfigPath(targetPath) {
+  return join4(getProjectStoreDir(targetPath), "config.json");
+}
+
+// src/domains/adapters/link-helper.ts
+import { lstatSync as lstatSync2, unlinkSync, rmSync, symlinkSync } from "fs";
+import { dirname, relative } from "path";
+function removeExistingLinkPath(path) {
+  try {
+    const lstat = lstatSync2(path);
+    if (lstat.isDirectory() && !lstat.isSymbolicLink()) {
+      rmSync(path, { recursive: true, force: true });
+      return;
+    }
+    unlinkSync(path);
+  } catch {
+  }
+}
+function createOrReplaceSymlink(target, linkPath, type) {
+  removeExistingLinkPath(linkPath);
+  const linkDir = dirname(linkPath);
+  const relativeTarget = relative(linkDir, target);
+  symlinkSync(relativeTarget, linkPath, type);
+}
+
+// src/domains/adapters/antigravity.adapter.ts
+var AntigravityAdapter = class {
+  id = "antigravity";
+  name = "Antigravity";
+  targetRelativeDir = ".agents/skills";
+  async installSkill(targetPath, skill, _skillSourceDir) {
+    const parentDir = join5(targetPath, this.targetRelativeDir);
+    if (!existsSync3(parentDir)) {
+      mkdirSync(parentDir, { recursive: true });
+    }
+    const destination = join5(parentDir, skill.directoryName);
+    const projectSkillDir = join5(getProjectSkillsDir(targetPath), skill.directoryName);
+    createOrReplaceSymlink(projectSkillDir, destination, "dir");
+    return [destination];
+  }
+};
+
+// src/domains/adapters/claude.adapter.ts
+import { mkdirSync as mkdirSync2, existsSync as existsSync4 } from "fs";
+import { join as join6 } from "path";
+var ClaudeAdapter = class {
+  id = "claude";
+  name = "Claude Code";
+  targetRelativeDir = ".claude/skills";
+  async installSkill(targetPath, skill, _skillSourceDir) {
+    const parentDir = join6(targetPath, this.targetRelativeDir);
+    if (!existsSync4(parentDir)) {
+      mkdirSync2(parentDir, { recursive: true });
+    }
+    const destination = join6(parentDir, skill.directoryName);
+    const projectSkillDir = join6(getProjectSkillsDir(targetPath), skill.directoryName);
+    createOrReplaceSymlink(projectSkillDir, destination, "dir");
+    return [destination];
+  }
+};
+
+// src/domains/adapters/cursor.adapter.ts
+import { mkdirSync as mkdirSync3, existsSync as existsSync5 } from "fs";
+import { join as join7 } from "path";
+var CursorAdapter = class {
+  id = "cursor";
+  name = "Cursor";
+  targetRelativeDir = ".cursor/rules";
+  async installSkill(targetPath, skill, _skillSourceDir) {
+    const rulesDir = join7(targetPath, this.targetRelativeDir);
+    if (!existsSync5(rulesDir)) {
+      mkdirSync3(rulesDir, { recursive: true });
+    }
+    const filename = `${skill.id}.mdc`;
+    const destination = join7(rulesDir, filename);
+    const projectRuleFile = join7(getProjectCursorRulesDir(targetPath), filename);
+    createOrReplaceSymlink(projectRuleFile, destination, "file");
+    return [destination];
+  }
+};
+
+// src/domains/adapters/gemini.adapter.ts
+import { mkdirSync as mkdirSync4, existsSync as existsSync6 } from "fs";
+import { join as join8 } from "path";
+var GeminiAdapter = class {
+  id = "gemini";
+  name = "Gemini Code Assist";
+  targetRelativeDir = ".gemini/skills";
+  async installSkill(targetPath, skill, _skillSourceDir) {
+    const parentDir = join8(targetPath, this.targetRelativeDir);
+    if (!existsSync6(parentDir)) {
+      mkdirSync4(parentDir, { recursive: true });
+    }
+    const destination = join8(parentDir, skill.directoryName);
+    const projectSkillDir = join8(getProjectSkillsDir(targetPath), skill.directoryName);
+    createOrReplaceSymlink(projectSkillDir, destination, "dir");
+    return [destination];
+  }
+};
+
+// src/domains/project-store/sync-project-store.ts
+import { cpSync, mkdirSync as mkdirSync5, existsSync as existsSync8, writeFileSync, readFileSync as readFileSync2 } from "fs";
+import { join as join10 } from "path";
+
+// src/domains/installer/resolve-skills-source.ts
+import { fileURLToPath } from "url";
+import { dirname as dirname2, resolve, join as join9 } from "path";
+import { existsSync as existsSync7 } from "fs";
+function resolveSkillsSourceRoot() {
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const currentDir = dirname2(currentFilePath);
+  const candidateFromDist = resolve(currentDir, "../skills");
+  if (existsSync7(candidateFromDist)) {
+    return candidateFromDist;
+  }
+  const candidateFromSrc = resolve(currentDir, "../../../skills");
+  if (existsSync7(candidateFromSrc)) {
+    return candidateFromSrc;
+  }
+  let searchDir = currentDir;
+  for (let i = 0; i < 5; i++) {
+    const candidate = join9(searchDir, "skills");
+    if (existsSync7(candidate)) {
+      return candidate;
+    }
+    const parent = dirname2(searchDir);
+    if (parent === searchDir) {
+      break;
+    }
+    searchDir = parent;
+  }
+  throw new Error(
+    `GrooveSkills internal error: Unable to locate bundled skills directory from ${currentDir}`
+  );
+}
+
+// src/domains/project-store/sync-project-store.ts
+function syncProjectStore(targetPath, selectedSkillIds, selectedAgents) {
+  const bundledSkillsDir = resolveSkillsSourceRoot();
+  const projectSkillsDir = getProjectSkillsDir(targetPath);
+  const projectCursorRulesDir = getProjectCursorRulesDir(targetPath);
+  if (!existsSync8(projectSkillsDir)) {
+    mkdirSync5(projectSkillsDir, { recursive: true });
+  }
+  const needsCursorRules = selectedAgents.includes("cursor");
+  if (needsCursorRules && !existsSync8(projectCursorRulesDir)) {
+    mkdirSync5(projectCursorRulesDir, { recursive: true });
+  }
+  for (const skillId of selectedSkillIds) {
+    const skill = SKILL_CATALOG.find((item) => item.id === skillId);
+    if (!skill) {
+      continue;
+    }
+    const sourceSkillDir = join10(bundledSkillsDir, skill.directoryName);
+    const destSkillDir = join10(projectSkillsDir, skill.directoryName);
+    if (existsSync8(sourceSkillDir)) {
+      cpSync(sourceSkillDir, destSkillDir, { recursive: true });
+    }
+    if (!needsCursorRules) {
+      continue;
+    }
+    const skillMdPath = join10(destSkillDir, "SKILL.md");
+    if (!existsSync8(skillMdPath)) {
+      continue;
+    }
+    const content = readFileSync2(skillMdPath, "utf-8");
+    const mdcHeader = `---
+description: ${skill.description}
+globs: ["**/*"]
+alwaysApply: false
+---
+
+`;
+    const cleanedBody = content.replace(/^---[\s\S]*?---\s*/, "");
+    const targetMdc = join10(projectCursorRulesDir, `${skill.id}.mdc`);
+    writeFileSync(targetMdc, `${mdcHeader}${cleanedBody}`, "utf-8");
+  }
+}
+
+// src/domains/harness/install-harness.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync6, writeFileSync as writeFileSync3 } from "fs";
+import { join as join12 } from "path";
+
+// src/domains/harness/harness-templates.ts
+function buildContextTemplate(detectedDependencies) {
+  const depsFormatted = detectedDependencies.length > 0 ? detectedDependencies.map((d) => `- \`${d}\``).join("\n") : "- (No external dependencies detected)";
+  return `# Project Context & Architecture
+
+This file provides AI agents with instant architectural orientation for this project.
+
+## 1. Stack & Dependencies
+${depsFormatted}
+
+## 2. Directory Structure Conventions
+- Follow single-responsibility per file (<200 lines).
+- Maintain direct imports with path aliases; avoid barrel files.
+- Keep domain boundaries explicit and clean.
+
+## 3. Essential Commands
+- Build: Refer to \`package.json\` scripts.
+- Typecheck: Refer to TypeScript configuration.
+- Tests: Refer to test runner configuration.
+`;
+}
+function buildDecisionsTemplate() {
+  const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return `# Architecture Decision Records (ADR)
+
+An append-only log of significant technical and architectural choices.
+
+| Date | Title | Decision | Reason & Consequences |
+| :--- | :--- | :--- | :--- |
+| ${now} | Adopt GrooveSkills Harness | Initialized \`.grooveskills/\` control plane | Clean, encapsulated agent memory and 3-lane execution flow |
+`;
+}
+function buildTaskTemplate() {
+  return `---
+status: in-progress
+createdAt: \${CURRENT_DATE}
+---
+
+# Feature / Task Title
+
+## Intent
+Describe what changes are being made and why they are necessary.
+
+## Scope
+- In scope:
+- Out of scope:
+
+## Checklist
+- [ ] Task 1: (Define expected observed proof)
+- [ ] Task 2: (Define expected observed proof)
+
+## Evidence
+- Observed test/typecheck/build commands or runtime outputs proving completion.
+
+## Next
+- Next concrete step if interrupted.
+`;
+}
+function buildAgentHarnessBlock() {
+  return `<!-- grooveskills:harness:start -->
+# GrooveSkills Harness \u2014 Agent Rules & Memory
+
+This project uses the **GrooveSkills Harness** located in \`.grooveskills/\`.
+
+## 1. Three-Lane Rule
+- **Answer**: Explanations, audits, or questions. Read-only; write zero code.
+- **Task**: Direct implementation. Record intent, scope, and checklist in \`.grooveskills/memory/tasks/<slug>.md\`. Only check off tasks with observed evidence under \`Evidence\`.
+- **Spec**: Ambiguous or high-impact architecture. Clarify and validate the spec in \`.grooveskills/memory/tasks/<slug>.md\` before writing code.
+
+## 2. Memory Locations
+- Architecture context: \`.grooveskills/memory/context.md\`
+- Technical decisions (ADR): \`.grooveskills/memory/decisions.md\`
+- Active tasks & evidence: \`.grooveskills/memory/tasks/\`
+<!-- grooveskills:harness:end -->`;
+}
+
+// src/domains/harness/upsert-agent-instructions.ts
+import { existsSync as existsSync9, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join11 } from "path";
+var START_MARKER = "<!-- grooveskills:harness:start -->";
+var END_MARKER = "<!-- grooveskills:harness:end -->";
+function applyHarnessBlock(filePath) {
+  const block = buildAgentHarnessBlock();
+  if (!existsSync9(filePath)) {
+    writeFileSync2(filePath, `${block}
+`, "utf-8");
+    return;
+  }
+  const existingContent = readFileSync3(filePath, "utf-8");
+  if (existingContent.includes(START_MARKER) && existingContent.includes(END_MARKER)) {
+    const regex = new RegExp(`${START_MARKER}[\\s\\S]*?${END_MARKER}`, "g");
+    const updated = existingContent.replace(regex, block);
+    writeFileSync2(filePath, updated, "utf-8");
+    return;
+  }
+  const separator = existingContent.endsWith("\n") ? "\n" : "\n\n";
+  writeFileSync2(filePath, `${existingContent}${separator}${block}
+`, "utf-8");
+}
+function upsertAgentInstructions(targetPath, selectedAgents) {
+  const updatedFiles = [];
+  const agentsMdPath = join11(targetPath, "AGENTS.md");
+  applyHarnessBlock(agentsMdPath);
+  updatedFiles.push(agentsMdPath);
+  if (selectedAgents.includes("claude")) {
+    const claudeMdPath = join11(targetPath, "CLAUDE.md");
+    applyHarnessBlock(claudeMdPath);
+    updatedFiles.push(claudeMdPath);
+  }
+  return updatedFiles;
+}
+
+// src/domains/harness/install-harness.ts
+function installHarness(options) {
+  const memoryDir = getProjectMemoryDir(options.targetPath);
+  const tasksDir = getProjectTasksDir(options.targetPath);
+  if (!existsSync10(tasksDir)) {
+    mkdirSync6(tasksDir, { recursive: true });
+  }
+  const createdFiles = [];
+  const contextPath = join12(memoryDir, "context.md");
+  if (!existsSync10(contextPath)) {
+    writeFileSync3(contextPath, buildContextTemplate(options.detectedDependencies), "utf-8");
+    createdFiles.push(contextPath);
+  }
+  const decisionsPath = join12(memoryDir, "decisions.md");
+  if (!existsSync10(decisionsPath)) {
+    writeFileSync3(decisionsPath, buildDecisionsTemplate(), "utf-8");
+    createdFiles.push(decisionsPath);
+  }
+  const templateTaskPath = join12(tasksDir, "_template.md");
+  if (!existsSync10(templateTaskPath)) {
+    writeFileSync3(templateTaskPath, buildTaskTemplate(), "utf-8");
+    createdFiles.push(templateTaskPath);
+  }
+  const instructions = upsertAgentInstructions(options.targetPath, options.selectedAgents);
+  createdFiles.push(...instructions);
+  return createdFiles;
+}
+
+// src/domains/harness/write-project-config.ts
+import { existsSync as existsSync11, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+function writeProjectConfig(targetPath, newSkills, newAgents, harnessEnabled) {
+  const configPath = getProjectConfigPath(targetPath);
+  let existingSkills = [];
+  let existingAgents = [];
+  let existingHarness = false;
+  if (existsSync11(configPath)) {
+    try {
+      const parsed = JSON.parse(readFileSync4(configPath, "utf-8"));
+      if (Array.isArray(parsed.skills)) {
+        existingSkills = parsed.skills;
+      }
+      if (Array.isArray(parsed.agents)) {
+        existingAgents = parsed.agents;
+      }
+      if (typeof parsed.harness === "boolean") {
+        existingHarness = parsed.harness;
+      }
+    } catch {
+    }
+  }
+  const mergedSkills = Array.from(/* @__PURE__ */ new Set([...existingSkills, ...newSkills]));
+  const mergedAgents = Array.from(/* @__PURE__ */ new Set([...existingAgents, ...newAgents]));
+  const config = {
+    version: 1,
+    harness: existingHarness || harnessEnabled,
+    agents: mergedAgents,
+    skills: mergedSkills,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync4(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf-8");
+  return configPath;
+}
+
+// src/domains/installer/install-orchestrator.ts
+var ADAPTER_REGISTRY = {
+  antigravity: new AntigravityAdapter(),
+  claude: new ClaudeAdapter(),
+  cursor: new CursorAdapter(),
+  gemini: new GeminiAdapter()
+};
+async function installSkills(options) {
+  const skillsToInstall = [...options.selectedSkillIds];
+  if (options.enableHarness && !skillsToInstall.includes("groove-harness")) {
+    skillsToInstall.push("groove-harness");
+  }
+  syncProjectStore(options.targetPath, skillsToInstall, options.selectedAgents);
+  const projectSkillsDir = getProjectSkillsDir(options.targetPath);
+  const createdFiles = [];
+  for (const skillId of skillsToInstall) {
+    const skill = SKILL_CATALOG.find((item) => item.id === skillId);
+    if (!skill) {
+      continue;
+    }
+    const skillSourceDir = join13(projectSkillsDir, skill.directoryName);
+    for (const agentId of options.selectedAgents) {
+      const adapter = ADAPTER_REGISTRY[agentId];
+      if (!adapter) {
+        continue;
+      }
+      const files = await adapter.installSkill(options.targetPath, skill, skillSourceDir);
+      createdFiles.push(...files);
+    }
+  }
+  let harnessInitialized = false;
+  if (options.enableHarness) {
+    const harnessFiles = installHarness({
+      targetPath: options.targetPath,
+      selectedAgents: options.selectedAgents,
+      selectedSkillIds: skillsToInstall,
+      detectedDependencies: options.detectedDependencies || []
+    });
+    createdFiles.push(...harnessFiles);
+    harnessInitialized = true;
+  }
+  const configPath = writeProjectConfig(
+    options.targetPath,
+    skillsToInstall,
+    options.selectedAgents,
+    Boolean(options.enableHarness)
+  );
+  createdFiles.push(configPath);
+  return {
+    installedSkills: skillsToInstall,
+    configuredAgents: options.selectedAgents,
+    createdFiles,
+    harnessInitialized
+  };
+}
+
+// src/domains/ui/ui-orchestrator.ts
+async function runInteractiveUi(context) {
+  console.log(renderBanner());
+  p5.intro(pc2.magenta("Welcome to GrooveSkills! Let's tailor your AI agents with clean architectural standards."));
+  if (context.detectedDependencies.length > 0) {
+    p5.note(
+      `Detected dependencies: ${context.detectedDependencies.map((d) => pc2.bold(d)).join(", ")}
+Active AI folders: ${context.detectedAgents.map((a) => pc2.green(a)).join(", ") || "None (will be created)"}`,
+      "Project Environment"
+    );
+  }
+  const selectedSkills = await promptSkills(context.suggestedSkillIds);
+  if (p5.isCancel(selectedSkills)) {
+    p5.cancel("Installation cancelled. Have a wonderful day!");
+    process.exit(0);
+  }
+  const selectedAgents = await promptAgents(context.detectedAgents);
+  if (p5.isCancel(selectedAgents)) {
+    p5.cancel("Installation cancelled. Have a wonderful day!");
+    process.exit(0);
+  }
+  const harnessChoice = await promptHarness(context.harnessExists);
+  if (p5.isCancel(harnessChoice)) {
+    p5.cancel("Installation cancelled. Have a wonderful day!");
+    process.exit(0);
+  }
+  let forceOverwrite = true;
+  const anyExists = selectedSkills.some((skillId) => {
+    const meta = SKILL_CATALOG.find((s2) => s2.id === skillId);
+    return meta ? verifySkillExists(context.targetPath, meta.directoryName, selectedAgents) : false;
+  });
+  if (anyExists) {
+    const confirm3 = await promptConfirmOverwrite();
+    if (p5.isCancel(confirm3) || !confirm3) {
+      p5.cancel("Installation stopped to protect existing skills.");
+      process.exit(0);
+    }
+    forceOverwrite = Boolean(confirm3);
+  }
+  const s = p5.spinner();
+  s.start("Installing and adapting skills across your configured AI agents...");
+  const result = await installSkills({
+    targetPath: context.targetPath,
+    selectedSkillIds: selectedSkills,
+    selectedAgents,
+    forceOverwrite,
+    enableHarness: Boolean(harnessChoice),
+    detectedDependencies: context.detectedDependencies
+  });
+  s.stop(pc2.green("All skills and harness have been successfully configured!"));
+  const harnessStatus = result.harnessInitialized ? pc2.green("Initialized in .grooveskills/") : pc2.dim("Skipped");
+  p5.note(
+    `Configured skills: ${result.installedSkills.map((s2) => pc2.bold(s2)).join(", ")}
+Target agents: ${result.configuredAgents.map((a) => pc2.cyan(a)).join(", ")}
+GrooveSkills Harness: ${harnessStatus}`,
+    "Installation Summary"
+  );
+  p5.outro(pc2.green("Your AI programming pair is now empowered with your team's architectural habits! \u{1F680}"));
+}
+
+// src/main.ts
+async function runGrooveSkills(options = {}) {
+  const targetPath = process.cwd();
+  const context = detectProjectContext(targetPath);
+  const hasSkills = options.skills && options.skills.length > 0;
+  const hasAgents = options.agents && options.agents.length > 0;
+  const isDirectHarness = Boolean(options.harness) && hasAgents;
+  if (hasSkills && hasAgents || isDirectHarness) {
+    await installSkills({
+      targetPath,
+      selectedSkillIds: options.skills || [],
+      selectedAgents: options.agents || [],
+      forceOverwrite: Boolean(options.yes),
+      enableHarness: options.harness,
+      detectedDependencies: context.detectedDependencies
+    });
+    return;
+  }
+  await runInteractiveUi(context);
+}
+
+export {
+  runGrooveSkills
+};
+//# sourceMappingURL=chunk-5Q6O3BRA.js.map