@3lineas/grooveskills 1.1.2 → 1.4.0

package/dist/chunk-FN4OEDVV.js

@@ -0,0 +1,949 @@
+// src/domains/detector/project-detector.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } 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 detected = /* @__PURE__ */ new Set();
+  let hasManifest = false;
+  const packageJsonPath = join(targetPath, "package.json");
+  if (existsSync(packageJsonPath)) {
+    hasManifest = true;
+    try {
+      const raw = readFileSync(packageJsonPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      for (const dep of Object.keys(parsed.dependencies ?? {})) {
+        detected.add(dep);
+      }
+      for (const dep of Object.keys(parsed.devDependencies ?? {})) {
+        detected.add(dep);
+      }
+    } catch {
+    }
+  }
+  const cargoPath = join(targetPath, "Cargo.toml");
+  if (existsSync(cargoPath)) {
+    hasManifest = true;
+    detected.add("rust");
+  }
+  const pyprojectPath = join(targetPath, "pyproject.toml");
+  const requirementsPath = join(targetPath, "requirements.txt");
+  if (existsSync(pyprojectPath) || existsSync(requirementsPath)) {
+    hasManifest = true;
+    detected.add("python");
+  }
+  return {
+    dependencies: Array.from(detected),
+    exists: hasManifest
+  };
+}
+
+// src/domains/registry/skill-catalog.ts
+var SKILL_CATALOG = [
+  {
+    id: "groove-harness",
+    name: "GrooveSkills Harness",
+    description: "Lightweight project harness, context memory, and ODD 3-lane task execution (Answer, Task, Spec) for AI coding agents",
+    dependencies: [],
+    directoryName: "groove-harness"
+  },
+  {
+    id: "odd-ai",
+    name: "Organic & Outcome-Driven Development (ODD)",
+    description: "7-step ODD protocol for AI agents: authorize, explore, classify, outcome hypotheses, and verifiable evidence receipts",
+    dependencies: [],
+    directoryName: "odd-ai"
+  },
+  {
+    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: "ux-writing",
+    name: "UX Writing & Microcopy Standards",
+    description: "Persuasive, empathetic, professional bilingual microcopy (ES/EN) for error messages, forms, CTAs, toasts, and empty states",
+    dependencies: [],
+    directoryName: "ux-writing"
+  },
+  {
+    id: "typescript-clean",
+    name: "TypeScript Clean Code (TS 5.5+)",
+    description: "Advanced strict TypeScript, discriminated unions, satisfies, const generics, unknown over any, and zero unsafe casts",
+    dependencies: ["typescript"],
+    directoryName: "typescript-clean"
+  },
+  {
+    id: "rust-clean",
+    name: "Rust Clean Code (Rust 2024)",
+    description: "Idiomatic Rust clean code: let-else guard clauses, no unwrap in production, thiserror typed errors, Newtypes, zero barrel files, <200 lines",
+    dependencies: ["rust"],
+    directoryName: "rust-clean"
+  },
+  {
+    id: "python-clean",
+    name: "Python Clean Code (Python 3.12+)",
+    description: "Modern Python standards: guard clauses (no nested ifs), strict typing (zero Any), uv, Ruff, Pyright, Pydantic v2 boundaries, <200 lines",
+    dependencies: ["python"],
+    directoryName: "python-clean"
+  },
+  {
+    id: "error-handling-logging",
+    name: "Error Handling & Structured Logging",
+    description: "Deterministic error management with AppError, Result/ActionResponse contracts, and structured context logging",
+    dependencies: [],
+    directoryName: "error-handling-logging"
+  },
+  {
+    id: "valibot-validation",
+    name: "Valibot Schema Validation",
+    description: "Boundary schema validation with Valibot (* as v from 'valibot'), strict type inference, and friendly error messages",
+    dependencies: ["valibot"],
+    directoryName: "valibot-validation"
+  },
+  {
+    id: "clean-architecture-ddd",
+    name: "Clean Architecture & DDD",
+    description: "Domain-driven design, isolated single-purpose Actions, pure functions, immutability, zero barrel files, <200 lines per file",
+    dependencies: [],
+    directoryName: "clean-architecture-ddd"
+  },
+  {
+    id: "testing-vitest",
+    name: "Vitest Testing Standards",
+    description: "Clean unit and integration testing with Vitest: AAA pattern, behavioral testing over mocks, and boundary edge cases",
+    dependencies: ["vitest"],
+    directoryName: "testing-vitest"
+  },
+  {
+    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 readConfiguredLanguage(targetPath) {
+  const configPath = join2(targetPath, ".grooveskills", "config.json");
+  if (!existsSync2(configPath)) {
+    return void 0;
+  }
+  try {
+    const raw = readFileSync2(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.language === "string" ? parsed.language : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function detectProjectContext(targetPath) {
+  const detectedAgents = detectAgents(targetPath);
+  const { dependencies, exists } = detectDependencies(targetPath);
+  const suggestedSkillIds = [
+    "odd-ai",
+    "best-practices",
+    "ux-writing",
+    "error-handling-logging",
+    "clean-architecture-ddd"
+  ];
+  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"));
+  const configuredLanguage = readConfiguredLanguage(targetPath);
+  return {
+    targetPath,
+    detectedDependencies: dependencies,
+    suggestedSkillIds,
+    detectedAgents,
+    packageJsonExists: exists,
+    harnessExists,
+    configuredLanguage
+  };
+}
+
+// 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-language.ts
+import * as p3 from "@clack/prompts";
+async function promptLanguage(defaultLanguage = "es") {
+  const options = [
+    { value: "es", label: "Espa\xF1ol (Spanish)", hint: "Recomendado para proyectos en espa\xF1ol" },
+    { value: "en", label: "English", hint: "Standard international English" },
+    { value: "pt", label: "Portugu\xEAs (Portuguese)", hint: "Portugu\xEAs para o Brasil e Portugal" },
+    { value: "it", label: "Italiano (Italian)", hint: "Comunicazione in lingua italiana" },
+    { value: "fr", label: "Fran\xE7ais (French)", hint: "Communication en langue fran\xE7aise" }
+  ];
+  const selected = await p3.select({
+    message: "Which language should AI agents use for user-facing copy and communication?",
+    options,
+    initialValue: defaultLanguage
+  });
+  return selected;
+}
+
+// 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 join10 } from "path";
+
+// src/domains/adapters/skill-reference-builder.ts
+import { existsSync as existsSync3, lstatSync as lstatSync2, mkdirSync, readFileSync as readFileSync3, rmSync, unlinkSync, writeFileSync } 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 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/skill-reference-builder.ts
+function removeExistingPathSafely(path) {
+  const fileExists = existsSync3(path);
+  if (!fileExists) {
+    try {
+      const lstat = lstatSync2(path);
+      if (lstat.isSymbolicLink()) {
+        unlinkSync(path);
+      }
+    } catch {
+    }
+    return;
+  }
+  try {
+    const lstat = lstatSync2(path);
+    if (lstat.isSymbolicLink()) {
+      unlinkSync(path);
+      return;
+    }
+    if (lstat.isDirectory()) {
+      rmSync(path, { recursive: true, force: true });
+      return;
+    }
+    unlinkSync(path);
+  } catch {
+  }
+}
+function extractSkillDescription(canonicalSkillMdPath, fallback) {
+  if (!existsSync3(canonicalSkillMdPath)) {
+    return fallback;
+  }
+  try {
+    const content = readFileSync3(canonicalSkillMdPath, "utf-8");
+    const match = content.match(/^description:\s*(.+)$/m);
+    const hasMatchedDesc = Boolean(match && match[1]);
+    if (hasMatchedDesc && match?.[1]) {
+      return match[1].trim();
+    }
+  } catch {
+  }
+  return fallback;
+}
+function writeAgentSkillReference(targetPath, agentRelativeSkillsDir, skill) {
+  const agentSkillFolder = join5(targetPath, agentRelativeSkillsDir, skill.directoryName);
+  removeExistingPathSafely(agentSkillFolder);
+  mkdirSync(agentSkillFolder, { recursive: true });
+  const canonicalSkillMd = join5(getProjectSkillsDir(targetPath), skill.directoryName, "SKILL.md");
+  const description = extractSkillDescription(canonicalSkillMd, skill.description);
+  const referenceContent = `---
+name: ${skill.id}
+description: ${description}
+---
+
+# ${skill.name} \u2014 Skill Reference
+
+Canonical skill specification stored in \`.grooveskills/\`.
+
+- **Specification**: [\`.grooveskills/skills/${skill.directoryName}/SKILL.md\`](../../../.grooveskills/skills/${skill.directoryName}/SKILL.md)
+- **References & Templates**: \`.grooveskills/skills/${skill.directoryName}/\`
+
+> **Instruction**: Read \`.grooveskills/skills/${skill.directoryName}/SKILL.md\` before executing tasks matching this skill.
+`;
+  const targetFile = join5(agentSkillFolder, "SKILL.md");
+  writeFileSync(targetFile, referenceContent, "utf-8");
+  return targetFile;
+}
+function writeCursorRuleReference(targetPath, cursorRelativeRulesDir, skill) {
+  const rulesDir = join5(targetPath, cursorRelativeRulesDir);
+  if (!existsSync3(rulesDir)) {
+    mkdirSync(rulesDir, { recursive: true });
+  }
+  const targetFile = join5(rulesDir, `${skill.id}.mdc`);
+  removeExistingPathSafely(targetFile);
+  const canonicalSkillMd = join5(getProjectSkillsDir(targetPath), skill.directoryName, "SKILL.md");
+  const description = extractSkillDescription(canonicalSkillMd, skill.description);
+  const referenceContent = `---
+description: ${description}
+globs: ["**/*"]
+alwaysApply: false
+---
+
+# ${skill.name} \u2014 Rule Reference
+
+Canonical rule specification stored in \`.grooveskills/\`.
+
+- **Specification**: \`.grooveskills/skills/${skill.directoryName}/SKILL.md\`
+- **References & Templates**: \`.grooveskills/skills/${skill.directoryName}/\`
+
+> **Instruction**: Read \`.grooveskills/skills/${skill.directoryName}/SKILL.md\` before executing tasks matching this rule.
+`;
+  writeFileSync(targetFile, referenceContent, "utf-8");
+  return targetFile;
+}
+
+// src/domains/adapters/antigravity.adapter.ts
+var AntigravityAdapter = class {
+  id = "antigravity";
+  name = "Antigravity";
+  targetRelativeDir = ".agents/skills";
+  async installSkill(targetPath, skill, _skillSourceDir) {
+    const file = writeAgentSkillReference(targetPath, this.targetRelativeDir, skill);
+    return [file];
+  }
+};
+
+// src/domains/adapters/claude.adapter.ts
+var ClaudeAdapter = class {
+  id = "claude";
+  name = "Claude Code";
+  targetRelativeDir = ".claude/skills";
+  async installSkill(targetPath, skill, _skillSourceDir) {
+    const file = writeAgentSkillReference(targetPath, this.targetRelativeDir, skill);
+    return [file];
+  }
+};
+
+// src/domains/adapters/cursor.adapter.ts
+var CursorAdapter = class {
+  id = "cursor";
+  name = "Cursor";
+  targetRelativeDir = ".cursor/rules";
+  async installSkill(targetPath, skill, _skillSourceDir) {
+    const file = writeCursorRuleReference(targetPath, this.targetRelativeDir, skill);
+    return [file];
+  }
+};
+
+// src/domains/adapters/gemini.adapter.ts
+var GeminiAdapter = class {
+  id = "gemini";
+  name = "Gemini Code Assist";
+  targetRelativeDir = ".gemini/skills";
+  async installSkill(targetPath, skill, _skillSourceDir) {
+    const file = writeAgentSkillReference(targetPath, this.targetRelativeDir, skill);
+    return [file];
+  }
+};
+
+// src/domains/project-store/sync-project-store.ts
+import { cpSync, existsSync as existsSync5, mkdirSync as mkdirSync2, rmSync as rmSync2 } from "fs";
+import { join as join7 } from "path";
+
+// src/domains/installer/resolve-skills-source.ts
+import { fileURLToPath } from "url";
+import { dirname, resolve, join as join6 } from "path";
+import { existsSync as existsSync4 } from "fs";
+function resolveSkillsSourceRoot() {
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const currentDir = dirname(currentFilePath);
+  const candidateFromDist = resolve(currentDir, "../skills");
+  if (existsSync4(candidateFromDist)) {
+    return candidateFromDist;
+  }
+  const candidateFromSrc = resolve(currentDir, "../../../skills");
+  if (existsSync4(candidateFromSrc)) {
+    return candidateFromSrc;
+  }
+  let searchDir = currentDir;
+  for (let i = 0; i < 5; i++) {
+    const candidate = join6(searchDir, "skills");
+    if (existsSync4(candidate)) {
+      return candidate;
+    }
+    const parent = dirname(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);
+  if (!existsSync5(projectSkillsDir)) {
+    mkdirSync2(projectSkillsDir, { recursive: true });
+  }
+  const legacyCursorRules = join7(targetPath, ".grooveskills", "cursor-rules");
+  if (existsSync5(legacyCursorRules)) {
+    try {
+      rmSync2(legacyCursorRules, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  for (const skillId of selectedSkillIds) {
+    const skill = SKILL_CATALOG.find((item) => item.id === skillId);
+    if (!skill) {
+      continue;
+    }
+    const sourceSkillDir = join7(bundledSkillsDir, skill.directoryName);
+    const destSkillDir = join7(projectSkillsDir, skill.directoryName);
+    if (existsSync5(sourceSkillDir)) {
+      cpSync(sourceSkillDir, destSkillDir, { recursive: true });
+    }
+  }
+}
+
+// src/domains/harness/install-harness.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join9 } from "path";
+
+// src/domains/harness/harness-languages.ts
+var SUPPORTED_LANGUAGES = {
+  es: {
+    code: "es",
+    name: "Spanish",
+    nativeName: "Espa\xF1ol",
+    instruction: "Todos los mensajes, validaciones, errores, CTAs y comunicaciones con el usuario deben redactarse estrictamente en Espa\xF1ol. El tono debe ser emp\xE1tico, amable, persuasivo y profesional."
+  },
+  en: {
+    code: "en",
+    name: "English",
+    nativeName: "English",
+    instruction: "All user-facing messages, form validations, errors, CTAs, and notifications must be written strictly in English. Tone must be empathetic, friendly, persuasive, and professional."
+  },
+  pt: {
+    code: "pt",
+    name: "Portuguese",
+    nativeName: "Portugu\xEAs",
+    instruction: "Todas as mensagens, valida\xE7\xF5es, erros, CTAs e comunica\xE7\xF5es voltadas para o usu\xE1rio devem ser redigidas estritamente em Portugu\xEAs. O tom deve ser emp\xE1tico, amig\xE1vel, persuasivo e profissional."
+  },
+  it: {
+    code: "it",
+    name: "Italian",
+    nativeName: "Italiano",
+    instruction: "Tutti i messaggi, le convalide, gli errori, i pulsanti/CTA e le comunicazioni rivolte all'utente devono essere scritti rigorosamente in Italiano. Il tono deve essere empatico, cordiale, persuasivo e professionale."
+  },
+  fr: {
+    code: "fr",
+    name: "French",
+    nativeName: "Fran\xE7ais",
+    instruction: "Tous les messages, validations, erreurs, boutons d'appel \xE0 l'action (CTA) et notifications destin\xE9s \xE0 l'utilisateur doivent \xEAtre r\xE9dig\xE9s strictement en Fran\xE7ais. Le ton doit \xEAtre empathique, courtois, persuasif et professionnel."
+  }
+};
+
+// src/domains/harness/harness-templates.ts
+function buildContextTemplate(detectedDependencies, language = "es") {
+  const depsFormatted = detectedDependencies.length > 0 ? detectedDependencies.map((d) => `- \`${d}\``).join("\n") : "- (No external dependencies detected)";
+  const langConfig = SUPPORTED_LANGUAGES[language];
+  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. Communication & User Copy Language
+- **Configured Language**: ${langConfig.nativeName} (\`${language}\`).
+- **Policy**: ${langConfig.instruction}
+
+## 4. Essential Commands
+- Build: Refer to \`package.json\` scripts.
+- Typecheck: Refer to TypeScript configuration.
+- Tests: Refer to test runner configuration.
+`;
+}
+function buildDecisionsTemplate(language = "es") {
+  const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const langConfig = SUPPORTED_LANGUAGES[language];
+  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 with ODD | Clean, encapsulated agent memory, 3-lane ODD flow, and ${langConfig.nativeName} copy standard |
+`;
+}
+function buildTaskTemplate() {
+  return `---
+status: in-progress
+createdAt: \${CURRENT_DATE}
+---
+
+# Feature / Task Title
+
+## Outcome Hypothesis
+Describe the expected behavioral outcome:
+By [Output / Technical Change], [Outcome / Verifiable Behavior] will occur, proven by [Evidence / Test / Build Command].
+
+## 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(language = "es") {
+  const langConfig = SUPPORTED_LANGUAGES[language];
+  return `<!-- grooveskills:harness:start -->
+# GrooveSkills Harness \u2014 Agent Rules & Memory
+
+This project uses the **GrooveSkills Harness** located in \`.grooveskills/\`.
+
+## 1. Three-Lane ODD Protocol
+- **Authorize & Explore**: Follow the 7-step ODD protocol (Authorize, Explore, Resolve, Classify, Track & Hypothesize, Execute, Verify).
+- **Lane 1 (Answer)**: Explanations, audits, or questions. Read-only; write zero code.
+- **Lane 2 (Task)**: Direct implementation. Declare Outcome Hypothesis and checklist in \`.grooveskills/memory/tasks/<slug>.md\`. Only check off tasks with observed evidence under \`Evidence\`.
+- **Lane 3 (Spec)**: Ambiguous or high-impact architecture. Clarify and validate the spec in \`.grooveskills/memory/tasks/<slug>.md\` before writing code.
+
+## 2. User Communication Language (${langConfig.nativeName})
+- **Language**: \`${language}\` (${langConfig.nativeName}).
+- **Requirement**: ${langConfig.instruction}
+
+## 3. 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 existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { join as join8 } from "path";
+var START_MARKER = "<!-- grooveskills:harness:start -->";
+var END_MARKER = "<!-- grooveskills:harness:end -->";
+function applyHarnessBlock(filePath, language = "es") {
+  const block = buildAgentHarnessBlock(language);
+  if (!existsSync6(filePath)) {
+    writeFileSync2(filePath, `${block}
+`, "utf-8");
+    return;
+  }
+  const existingContent = readFileSync4(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, language = "es") {
+  const updatedFiles = [];
+  const agentsMdPath = join8(targetPath, "AGENTS.md");
+  applyHarnessBlock(agentsMdPath, language);
+  updatedFiles.push(agentsMdPath);
+  if (selectedAgents.includes("claude")) {
+    const claudeMdPath = join8(targetPath, "CLAUDE.md");
+    applyHarnessBlock(claudeMdPath, language);
+    updatedFiles.push(claudeMdPath);
+  }
+  return updatedFiles;
+}
+
+// src/domains/harness/install-harness.ts
+function installHarness(options) {
+  const memoryDir = getProjectMemoryDir(options.targetPath);
+  const tasksDir = getProjectTasksDir(options.targetPath);
+  const language = options.language ?? "es";
+  if (!existsSync7(tasksDir)) {
+    mkdirSync3(tasksDir, { recursive: true });
+  }
+  const createdFiles = [];
+  const contextPath = join9(memoryDir, "context.md");
+  if (!existsSync7(contextPath)) {
+    writeFileSync3(contextPath, buildContextTemplate(options.detectedDependencies, language), "utf-8");
+    createdFiles.push(contextPath);
+  }
+  const decisionsPath = join9(memoryDir, "decisions.md");
+  if (!existsSync7(decisionsPath)) {
+    writeFileSync3(decisionsPath, buildDecisionsTemplate(language), "utf-8");
+    createdFiles.push(decisionsPath);
+  }
+  const templateTaskPath = join9(tasksDir, "_template.md");
+  if (!existsSync7(templateTaskPath)) {
+    writeFileSync3(templateTaskPath, buildTaskTemplate(), "utf-8");
+    createdFiles.push(templateTaskPath);
+  }
+  const instructions = upsertAgentInstructions(options.targetPath, options.selectedAgents, language);
+  createdFiles.push(...instructions);
+  return createdFiles;
+}
+
+// src/domains/harness/write-project-config.ts
+import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+function readExistingConfig(configPath) {
+  const fallback = {
+    skills: [],
+    agents: [],
+    harness: false
+  };
+  if (!existsSync8(configPath)) {
+    return fallback;
+  }
+  try {
+    const raw = readFileSync5(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return {
+      skills: Array.isArray(parsed.skills) ? parsed.skills : [],
+      agents: Array.isArray(parsed.agents) ? parsed.agents : [],
+      harness: typeof parsed.harness === "boolean" ? parsed.harness : false,
+      language: typeof parsed.language === "string" ? parsed.language : void 0
+    };
+  } catch {
+    return fallback;
+  }
+}
+function writeProjectConfig(targetPath, newSkills, newAgents, harnessEnabled, language) {
+  const configPath = getProjectConfigPath(targetPath);
+  const existing = readExistingConfig(configPath);
+  const mergedSkills = Array.from(/* @__PURE__ */ new Set([...existing.skills, ...newSkills]));
+  const mergedAgents = Array.from(/* @__PURE__ */ new Set([...existing.agents, ...newAgents]));
+  const resolvedLanguage = language ?? existing.language ?? "es";
+  const isHarnessActive = existing.harness || harnessEnabled;
+  const config = {
+    version: 1,
+    harness: isHarnessActive,
+    ...isHarnessActive ? { language: resolvedLanguage } : {},
+    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 (!skillsToInstall.includes("groove-harness")) {
+    skillsToInstall.push("groove-harness");
+  }
+  if (!skillsToInstall.includes("odd-ai")) {
+    skillsToInstall.push("odd-ai");
+  }
+  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 = join10(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);
+    }
+  }
+  const harnessFiles = installHarness({
+    targetPath: options.targetPath,
+    selectedAgents: options.selectedAgents,
+    selectedSkillIds: skillsToInstall,
+    detectedDependencies: options.detectedDependencies || [],
+    language: options.language
+  });
+  createdFiles.push(...harnessFiles);
+  const configPath = writeProjectConfig(
+    options.targetPath,
+    skillsToInstall,
+    options.selectedAgents,
+    true,
+    options.language
+  );
+  createdFiles.push(configPath);
+  return {
+    installedSkills: skillsToInstall,
+    configuredAgents: options.selectedAgents,
+    createdFiles,
+    harnessInitialized: true,
+    language: options.language
+  };
+}
+
+// src/domains/ui/ui-orchestrator.ts
+async function resolveLanguageSelection(harnessExists, configuredLanguage) {
+  if (harnessExists) {
+    return configuredLanguage ?? "es";
+  }
+  const langChoice = await promptLanguage(configuredLanguage ?? "es");
+  if (p5.isCancel(langChoice)) {
+    p5.cancel("Installation cancelled. Have a wonderful day!");
+    process.exit(0);
+  }
+  return langChoice;
+}
+async function resolveOverwriteConfirmation(targetPath, selectedSkills, selectedAgents) {
+  const anyExists = selectedSkills.some((skillId) => {
+    const meta = SKILL_CATALOG.find((s) => s.id === skillId);
+    return meta ? verifySkillExists(targetPath, meta.directoryName, selectedAgents) : false;
+  });
+  if (!anyExists) {
+    return true;
+  }
+  const confirm2 = await promptConfirmOverwrite();
+  if (p5.isCancel(confirm2) || !confirm2) {
+    p5.cancel("Installation stopped to protect existing skills.");
+    process.exit(0);
+  }
+  return Boolean(confirm2);
+}
+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) {
+    const harnessInfo = context.harnessExists ? pc2.green(`Active (.grooveskills/memory, lang: ${context.configuredLanguage ?? "es"})`) : pc2.cyan("Will be initialized");
+    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)"}
+GrooveSkills Harness: ${harnessInfo}`,
+      "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 selectedLanguage = await resolveLanguageSelection(
+    context.harnessExists,
+    context.configuredLanguage
+  );
+  const forceOverwrite = await resolveOverwriteConfirmation(
+    context.targetPath,
+    selectedSkills,
+    selectedAgents
+  );
+  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: true,
+    detectedDependencies: context.detectedDependencies,
+    language: selectedLanguage
+  });
+  s.stop(pc2.green("All skills and harness have been successfully configured!"));
+  const harnessStatus = result.harnessInitialized ? pc2.green(`Initialized in .grooveskills/ (Language: ${selectedLanguage})`) : pc2.cyan(`Preserved in .grooveskills/ (Language: ${selectedLanguage})`);
+  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) {
+    const language = options.language ?? context.configuredLanguage ?? "es";
+    await installSkills({
+      targetPath,
+      selectedSkillIds: options.skills || [],
+      selectedAgents: options.agents || [],
+      forceOverwrite: Boolean(options.yes),
+      enableHarness: true,
+      detectedDependencies: context.detectedDependencies,
+      language
+    });
+    return;
+  }
+  await runInteractiveUi(context);
+}
+
+export {
+  runGrooveSkills
+};
+//# sourceMappingURL=chunk-FN4OEDVV.js.map