@skillkit/core 1.7.9 → 1.7.11

package/dist/index.js

@@ -713,8 +713,8 @@ function validateSkill(skillPath) {
   return { valid: errors.length === 0, errors, warnings };
 }
 function isPathInside(child, parent) {
-  const relative4 = child.replace(parent, "");
-  return !relative4.startsWith("..") && !relative4.includes("/..");
+  const relative5 = child.replace(parent, "");
+  return !relative5.startsWith("..") && !relative5.includes("/..");
 }
 
 // src/config.ts
@@ -18516,11 +18516,1316 @@ function getQualityGrade(score) {
 function isHighQuality(score) {
   return score.overall >= 80 && score.warnings.length <= 2;
 }
+
+// src/primer/types.ts
+import { z as z6 } from "zod";
+var PrimerLanguage = z6.enum([
+  "typescript",
+  "javascript",
+  "python",
+  "go",
+  "rust",
+  "java",
+  "kotlin",
+  "swift",
+  "ruby",
+  "php",
+  "csharp",
+  "cpp"
+]);
+var PackageManager = z6.enum([
+  "npm",
+  "pnpm",
+  "yarn",
+  "bun",
+  "pip",
+  "poetry",
+  "uv",
+  "cargo",
+  "go",
+  "maven",
+  "gradle",
+  "composer",
+  "bundler",
+  "cocoapods",
+  "swift-package-manager",
+  "nuget"
+]);
+var CodeConvention = z6.object({
+  namingStyle: z6.enum(["camelCase", "snake_case", "PascalCase", "kebab-case"]).optional(),
+  indentation: z6.enum(["tabs", "spaces-2", "spaces-4"]).optional(),
+  quotes: z6.enum(["single", "double"]).optional(),
+  semicolons: z6.boolean().optional(),
+  trailingCommas: z6.enum(["none", "es5", "all"]).optional(),
+  maxLineLength: z6.number().optional()
+});
+var ProjectStructure = z6.object({
+  type: z6.enum(["flat", "src-based", "monorepo", "packages"]).optional(),
+  srcDir: z6.string().optional(),
+  testDir: z6.string().optional(),
+  docsDir: z6.string().optional(),
+  configDir: z6.string().optional(),
+  hasWorkspaces: z6.boolean().default(false),
+  workspaces: z6.array(z6.string()).optional()
+});
+var CIConfig = z6.object({
+  provider: z6.enum(["github-actions", "gitlab-ci", "circleci", "jenkins", "travis", "azure-pipelines"]).optional(),
+  hasCI: z6.boolean().default(false),
+  hasCD: z6.boolean().default(false),
+  configFile: z6.string().optional()
+});
+var EnvConfig = z6.object({
+  hasEnvFile: z6.boolean().default(false),
+  hasEnvExample: z6.boolean().default(false),
+  envVariables: z6.array(z6.string()).optional()
+});
+var DockerConfig = z6.object({
+  hasDockerfile: z6.boolean().default(false),
+  hasCompose: z6.boolean().default(false),
+  baseImage: z6.string().optional()
+});
+var PrimerAnalysis = z6.object({
+  project: z6.object({
+    name: z6.string(),
+    description: z6.string().optional(),
+    version: z6.string().optional(),
+    type: z6.string().optional(),
+    license: z6.string().optional(),
+    repository: z6.string().optional()
+  }),
+  languages: z6.array(Detection).default([]),
+  packageManagers: z6.array(PackageManager).default([]),
+  stack: ProjectStack,
+  patterns: ProjectPatterns.optional(),
+  structure: ProjectStructure.optional(),
+  conventions: CodeConvention.optional(),
+  ci: CIConfig.optional(),
+  env: EnvConfig.optional(),
+  docker: DockerConfig.optional(),
+  buildCommands: z6.object({
+    install: z6.string().optional(),
+    build: z6.string().optional(),
+    test: z6.string().optional(),
+    lint: z6.string().optional(),
+    format: z6.string().optional(),
+    dev: z6.string().optional(),
+    start: z6.string().optional()
+  }).optional(),
+  importantFiles: z6.array(z6.string()).default([]),
+  codebaseSize: z6.object({
+    files: z6.number().optional(),
+    lines: z6.number().optional(),
+    directories: z6.number().optional()
+  }).optional()
+});
+var AGENT_INSTRUCTION_TEMPLATES = {
+  "claude-code": {
+    agent: "claude-code",
+    filename: "CLAUDE.md",
+    format: "markdown",
+    sectionOrder: ["overview", "stack", "commands", "conventions", "structure", "guidelines"]
+  },
+  "cursor": {
+    agent: "cursor",
+    filename: ".cursorrules",
+    format: "markdown",
+    sectionOrder: ["overview", "stack", "conventions", "guidelines"]
+  },
+  "github-copilot": {
+    agent: "github-copilot",
+    filename: ".github/copilot-instructions.md",
+    format: "markdown",
+    sectionOrder: ["overview", "stack", "commands", "conventions", "structure", "guidelines"]
+  },
+  "codex": {
+    agent: "codex",
+    filename: "AGENTS.md",
+    format: "markdown",
+    sectionOrder: ["overview", "stack", "commands", "conventions", "structure", "guidelines"]
+  },
+  "gemini-cli": {
+    agent: "gemini-cli",
+    filename: "GEMINI.md",
+    format: "markdown",
+    sectionOrder: ["overview", "stack", "commands", "conventions", "structure", "guidelines"]
+  },
+  "windsurf": {
+    agent: "windsurf",
+    filename: ".windsurfrules",
+    format: "markdown",
+    sectionOrder: ["overview", "stack", "conventions", "guidelines"]
+  },
+  "opencode": {
+    agent: "opencode",
+    filename: "AGENTS.md",
+    format: "markdown",
+    sectionOrder: ["overview", "stack", "commands", "conventions", "structure", "guidelines"]
+  },
+  "trae": {
+    agent: "trae",
+    filename: ".trae/rules/project_rules.md",
+    format: "markdown",
+    sectionOrder: ["overview", "stack", "commands", "conventions", "guidelines"]
+  }
+};
+
+// src/primer/analyzer.ts
+import { existsSync as existsSync35, readFileSync as readFileSync27, readdirSync as readdirSync10 } from "fs";
+import { join as join36, basename as basename13, relative as relative4, sep as sep2 } from "path";
+var PACKAGE_MANAGER_FILES = {
+  "package-lock.json": "npm",
+  "pnpm-lock.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "bun.lockb": "bun",
+  "requirements.txt": "pip",
+  "Pipfile.lock": "pip",
+  "poetry.lock": "poetry",
+  "uv.lock": "uv",
+  "Cargo.lock": "cargo",
+  "go.sum": "go",
+  "pom.xml": "maven",
+  "build.gradle": "gradle",
+  "build.gradle.kts": "gradle",
+  "composer.lock": "composer",
+  "Gemfile.lock": "bundler",
+  "Podfile.lock": "cocoapods",
+  "Package.resolved": "swift-package-manager",
+  "packages.lock.json": "nuget"
+};
+var CI_CONFIG_FILES = {
+  ".github/workflows": "github-actions",
+  ".gitlab-ci.yml": "gitlab-ci",
+  ".circleci/config.yml": "circleci",
+  "Jenkinsfile": "jenkins",
+  ".travis.yml": "travis",
+  "azure-pipelines.yml": "azure-pipelines"
+};
+var IMPORTANT_CONFIG_FILES = [
+  "package.json",
+  "tsconfig.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  ".eslintrc.js",
+  ".eslintrc.json",
+  "eslint.config.js",
+  ".prettierrc",
+  "prettier.config.js",
+  "biome.json",
+  "tailwind.config.js",
+  "tailwind.config.ts",
+  "vite.config.ts",
+  "next.config.js",
+  "next.config.mjs",
+  "webpack.config.js",
+  "rollup.config.js",
+  "turbo.json",
+  "nx.json",
+  "jest.config.js",
+  "vitest.config.ts",
+  "playwright.config.ts",
+  ".env.example",
+  "docker-compose.yml",
+  "Dockerfile"
+];
+var PrimerAnalyzer = class {
+  projectPath;
+  packageJson = null;
+  files = /* @__PURE__ */ new Set();
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  analyze() {
+    this.loadPackageJson();
+    this.scanFiles();
+    const detector = new ProjectDetector(this.projectPath);
+    const stack = detector.analyze();
+    const patterns = detector.detectPatterns();
+    const analysis = {
+      project: this.getProjectInfo(),
+      languages: this.detectLanguages(),
+      packageManagers: this.detectPackageManagers(),
+      stack,
+      patterns,
+      structure: this.detectProjectStructure(),
+      conventions: this.detectCodeConventions(),
+      ci: this.detectCIConfig(),
+      env: this.detectEnvConfig(),
+      docker: this.detectDockerConfig(),
+      buildCommands: this.extractBuildCommands(),
+      importantFiles: this.findImportantFiles(),
+      codebaseSize: this.estimateCodebaseSize()
+    };
+    return analysis;
+  }
+  loadPackageJson() {
+    const packageJsonPath = join36(this.projectPath, "package.json");
+    if (existsSync35(packageJsonPath)) {
+      try {
+        const content = readFileSync27(packageJsonPath, "utf-8");
+        this.packageJson = JSON.parse(content);
+      } catch {
+        this.packageJson = null;
+      }
+    }
+  }
+  scanFiles(maxDepth = 3) {
+    const scan = (dir, depth) => {
+      if (depth > maxDepth) return;
+      try {
+        const entries = readdirSync10(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = join36(dir, entry.name);
+          const relativePath = relative4(this.projectPath, fullPath);
+          if (entry.name.startsWith(".") && entry.name !== ".github" && entry.name !== ".env.example") {
+            if (!entry.isDirectory()) {
+              this.files.add(relativePath);
+            }
+            continue;
+          }
+          if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".git") {
+            continue;
+          }
+          this.files.add(relativePath);
+          if (entry.isDirectory()) {
+            scan(fullPath, depth + 1);
+          }
+        }
+      } catch {
+      }
+    };
+    scan(this.projectPath, 0);
+  }
+  getProjectInfo() {
+    const info = {
+      name: basename13(this.projectPath)
+    };
+    if (this.packageJson) {
+      if (typeof this.packageJson.name === "string") {
+        info.name = this.packageJson.name;
+      }
+      if (typeof this.packageJson.description === "string") {
+        info.description = this.packageJson.description;
+      }
+      if (typeof this.packageJson.version === "string") {
+        info.version = this.packageJson.version;
+      }
+      if (typeof this.packageJson.license === "string") {
+        info.license = this.packageJson.license;
+      }
+      const repo = this.packageJson.repository;
+      if (typeof repo === "string") {
+        info.repository = repo;
+      } else if (repo && typeof repo === "object" && "url" in repo) {
+        info.repository = String(repo.url);
+      }
+    }
+    const pyprojectPath = join36(this.projectPath, "pyproject.toml");
+    if (!this.packageJson && existsSync35(pyprojectPath)) {
+      try {
+        const content = readFileSync27(pyprojectPath, "utf-8");
+        const nameMatch = content.match(/name\s*=\s*["']([^"']+)["']/);
+        const versionMatch = content.match(/version\s*=\s*["']([^"']+)["']/);
+        const descMatch = content.match(/description\s*=\s*["']([^"']+)["']/);
+        if (nameMatch) info.name = nameMatch[1];
+        if (versionMatch) info.version = versionMatch[1];
+        if (descMatch) info.description = descMatch[1];
+      } catch {
+      }
+    }
+    const cargoPath = join36(this.projectPath, "Cargo.toml");
+    if (!this.packageJson && existsSync35(cargoPath)) {
+      try {
+        const content = readFileSync27(cargoPath, "utf-8");
+        const nameMatch = content.match(/name\s*=\s*["']([^"']+)["']/);
+        const versionMatch = content.match(/version\s*=\s*["']([^"']+)["']/);
+        const descMatch = content.match(/description\s*=\s*["']([^"']+)["']/);
+        if (nameMatch) info.name = nameMatch[1];
+        if (versionMatch) info.version = versionMatch[1];
+        if (descMatch) info.description = descMatch[1];
+      } catch {
+      }
+    }
+    const detector = new ProjectDetector(this.projectPath);
+    info.type = detector.detectProjectType();
+    return info;
+  }
+  detectLanguages() {
+    const languages = [];
+    if (this.hasFile("tsconfig.json")) {
+      const version = this.getDepVersion("typescript");
+      languages.push({
+        name: "typescript",
+        version,
+        confidence: 100,
+        source: "tsconfig.json"
+      });
+    }
+    if (this.packageJson && !this.hasFile("tsconfig.json")) {
+      languages.push({
+        name: "javascript",
+        confidence: 90,
+        source: "package.json"
+      });
+    }
+    if (this.hasFile("pyproject.toml") || this.hasFile("requirements.txt") || this.hasFile("setup.py")) {
+      const source = this.hasFile("pyproject.toml") ? "pyproject.toml" : this.hasFile("requirements.txt") ? "requirements.txt" : "setup.py";
+      languages.push({
+        name: "python",
+        confidence: 100,
+        source
+      });
+    }
+    if (this.hasFile("go.mod")) {
+      languages.push({
+        name: "go",
+        confidence: 100,
+        source: "go.mod"
+      });
+    }
+    if (this.hasFile("Cargo.toml")) {
+      languages.push({
+        name: "rust",
+        confidence: 100,
+        source: "Cargo.toml"
+      });
+    }
+    if (this.hasFile("pom.xml") || this.hasFile("build.gradle") || this.hasFile("build.gradle.kts")) {
+      languages.push({
+        name: "java",
+        confidence: 100,
+        source: "pom.xml"
+      });
+    }
+    if (this.hasFile("Package.swift")) {
+      languages.push({
+        name: "swift",
+        confidence: 100,
+        source: "Package.swift"
+      });
+    }
+    if (this.hasFile("Gemfile")) {
+      languages.push({
+        name: "ruby",
+        confidence: 100,
+        source: "Gemfile"
+      });
+    }
+    if (this.hasFile("composer.json")) {
+      languages.push({
+        name: "php",
+        confidence: 100,
+        source: "composer.json"
+      });
+    }
+    return languages;
+  }
+  detectPackageManagers() {
+    const managers = /* @__PURE__ */ new Set();
+    for (const [file, manager] of Object.entries(PACKAGE_MANAGER_FILES)) {
+      if (this.hasFile(file)) {
+        managers.add(manager);
+      }
+    }
+    if (this.packageJson) {
+      const packageManager = this.packageJson.packageManager;
+      if (typeof packageManager === "string") {
+        const match = packageManager.match(/^(npm|pnpm|yarn|bun)@/);
+        if (match && ["npm", "pnpm", "yarn", "bun"].includes(match[1])) {
+          managers.add(match[1]);
+        }
+      }
+    }
+    return Array.from(managers);
+  }
+  detectProjectStructure() {
+    const structure = {
+      hasWorkspaces: false
+    };
+    if (this.hasFile("packages") || this.hasFile("apps")) {
+      structure.type = "monorepo";
+    } else if (this.hasFile("src")) {
+      structure.type = "src-based";
+      structure.srcDir = "src";
+    } else if (this.hasFile("lib")) {
+      structure.type = "src-based";
+      structure.srcDir = "lib";
+    } else {
+      structure.type = "flat";
+    }
+    if (this.hasFile("tests") || this.hasFile("test") || this.hasFile("__tests__")) {
+      structure.testDir = this.hasFile("tests") ? "tests" : this.hasFile("test") ? "test" : "__tests__";
+    }
+    if (this.hasFile("docs") || this.hasFile("documentation")) {
+      structure.docsDir = this.hasFile("docs") ? "docs" : "documentation";
+    }
+    if (this.packageJson) {
+      const workspaces = this.packageJson.workspaces;
+      if (Array.isArray(workspaces)) {
+        structure.hasWorkspaces = true;
+        structure.workspaces = workspaces.filter((w) => typeof w === "string");
+        structure.type = "monorepo";
+      } else if (workspaces && typeof workspaces === "object" && "packages" in workspaces) {
+        structure.hasWorkspaces = true;
+        structure.workspaces = workspaces.packages || [];
+        structure.type = "monorepo";
+      }
+    }
+    if (this.hasFile("pnpm-workspace.yaml")) {
+      structure.hasWorkspaces = true;
+      structure.type = "monorepo";
+    }
+    if (this.hasFile("turbo.json") || this.hasFile("nx.json")) {
+      structure.type = "monorepo";
+    }
+    return structure;
+  }
+  detectCodeConventions() {
+    const conventions = {};
+    const prettierConfig = this.readConfigFile([
+      ".prettierrc",
+      ".prettierrc.json",
+      "prettier.config.js"
+    ]);
+    const biomeConfig = this.readConfigFile(["biome.json"]);
+    if (prettierConfig) {
+      try {
+        const config = typeof prettierConfig === "string" ? JSON.parse(prettierConfig) : prettierConfig;
+        if ("semi" in config) conventions.semicolons = config.semi;
+        if ("singleQuote" in config) conventions.quotes = config.singleQuote ? "single" : "double";
+        if ("tabWidth" in config) {
+          conventions.indentation = config.useTabs ? "tabs" : `spaces-${config.tabWidth}`;
+        }
+        if ("trailingComma" in config) conventions.trailingCommas = config.trailingComma;
+        if ("printWidth" in config) conventions.maxLineLength = config.printWidth;
+      } catch {
+      }
+    }
+    if (biomeConfig) {
+      try {
+        const config = typeof biomeConfig === "string" ? JSON.parse(biomeConfig) : biomeConfig;
+        const formatter = config.formatter || {};
+        const js = config.javascript?.formatter || {};
+        if (formatter.indentStyle) conventions.indentation = formatter.indentStyle === "tab" ? "tabs" : "spaces-2";
+        if (formatter.lineWidth) conventions.maxLineLength = formatter.lineWidth;
+        if (js.quoteStyle) conventions.quotes = js.quoteStyle;
+        if (js.semicolons) conventions.semicolons = js.semicolons !== "asNeeded";
+        if (js.trailingCommas) conventions.trailingCommas = js.trailingCommas;
+      } catch {
+      }
+    }
+    if (this.hasFile("tsconfig.json")) {
+      try {
+        const tsconfigPath = join36(this.projectPath, "tsconfig.json");
+        const content = readFileSync27(tsconfigPath, "utf-8");
+        const tsconfig = JSON.parse(content.replace(/\/\/.*$/gm, "").replace(/,\s*}/g, "}"));
+        const paths = tsconfig.compilerOptions?.paths;
+        if (paths && Object.keys(paths).some((k) => k.startsWith("@"))) {
+          conventions.namingStyle = "camelCase";
+        }
+      } catch {
+      }
+    }
+    return conventions;
+  }
+  detectCIConfig() {
+    const ci = {
+      hasCI: false,
+      hasCD: false
+    };
+    for (const [file, provider] of Object.entries(CI_CONFIG_FILES)) {
+      if (this.hasFile(file)) {
+        ci.hasCI = true;
+        ci.provider = provider;
+        ci.configFile = file;
+        break;
+      }
+    }
+    if (this.hasFile(".github/workflows")) {
+      ci.hasCI = true;
+      ci.provider = "github-actions";
+      ci.configFile = ".github/workflows";
+      try {
+        const workflowsDir = join36(this.projectPath, ".github/workflows");
+        const workflows = readdirSync10(workflowsDir);
+        const deployWorkflows = workflows.filter(
+          (f) => f.includes("deploy") || f.includes("release") || f.includes("publish")
+        );
+        if (deployWorkflows.length > 0) {
+          ci.hasCD = true;
+        }
+      } catch {
+      }
+    }
+    return ci;
+  }
+  detectEnvConfig() {
+    const env = {
+      hasEnvFile: false,
+      hasEnvExample: false
+    };
+    env.hasEnvFile = this.hasFile(".env");
+    env.hasEnvExample = this.hasFile(".env.example") || this.hasFile(".env.template") || this.hasFile(".env.sample");
+    if (env.hasEnvExample) {
+      const envExamplePath = join36(
+        this.projectPath,
+        this.hasFile(".env.example") ? ".env.example" : this.hasFile(".env.template") ? ".env.template" : ".env.sample"
+      );
+      try {
+        const content = readFileSync27(envExamplePath, "utf-8");
+        const variables = content.split("\n").filter((line) => line.trim() && !line.startsWith("#")).map((line) => line.split("=")[0].trim()).filter((v) => v);
+        env.envVariables = variables;
+      } catch {
+      }
+    }
+    return env;
+  }
+  detectDockerConfig() {
+    const docker = {
+      hasDockerfile: false,
+      hasCompose: false
+    };
+    docker.hasDockerfile = this.hasFile("Dockerfile");
+    docker.hasCompose = this.hasFile("docker-compose.yml") || this.hasFile("docker-compose.yaml") || this.hasFile("compose.yml");
+    if (docker.hasDockerfile) {
+      try {
+        const dockerfilePath = join36(this.projectPath, "Dockerfile");
+        const content = readFileSync27(dockerfilePath, "utf-8");
+        const fromMatch = content.match(/^FROM\s+(\S+)/m);
+        if (fromMatch) {
+          docker.baseImage = fromMatch[1];
+        }
+      } catch {
+      }
+    }
+    return docker;
+  }
+  extractBuildCommands() {
+    const commands = {};
+    if (this.packageJson && this.packageJson.scripts) {
+      const scripts = this.packageJson.scripts;
+      if (scripts.build) commands.build = this.getRunCommand("build");
+      if (scripts.test) commands.test = this.getRunCommand("test");
+      if (scripts.lint) commands.lint = this.getRunCommand("lint");
+      if (scripts.format) commands.format = this.getRunCommand("format");
+      if (scripts.dev) commands.dev = this.getRunCommand("dev");
+      if (scripts.start) commands.start = this.getRunCommand("start");
+    }
+    const packageManagers = this.detectPackageManagers();
+    if (!commands.install) {
+      if (packageManagers.includes("pnpm")) {
+        commands.install = "pnpm install";
+      } else if (packageManagers.includes("yarn")) {
+        commands.install = "yarn install";
+      } else if (packageManagers.includes("bun")) {
+        commands.install = "bun install";
+      } else if (packageManagers.includes("npm")) {
+        commands.install = "npm install";
+      } else if (packageManagers.includes("pip") || packageManagers.includes("poetry") || packageManagers.includes("uv")) {
+        if (packageManagers.includes("poetry")) {
+          commands.install = "poetry install";
+        } else if (packageManagers.includes("uv")) {
+          commands.install = "uv sync";
+        } else {
+          commands.install = "pip install -r requirements.txt";
+        }
+      } else if (packageManagers.includes("cargo")) {
+        commands.install = "cargo build";
+      } else if (packageManagers.includes("go")) {
+        commands.install = "go mod download";
+      }
+    }
+    return commands;
+  }
+  findImportantFiles() {
+    const important = [];
+    for (const file of IMPORTANT_CONFIG_FILES) {
+      if (this.hasFile(file)) {
+        important.push(file);
+      }
+    }
+    if (this.hasFile("README.md")) {
+      important.push("README.md");
+    }
+    if (this.hasFile("CONTRIBUTING.md")) {
+      important.push("CONTRIBUTING.md");
+    }
+    if (this.hasFile("LICENSE") || this.hasFile("LICENSE.md")) {
+      important.push(this.hasFile("LICENSE") ? "LICENSE" : "LICENSE.md");
+    }
+    return important;
+  }
+  estimateCodebaseSize() {
+    let files = 0;
+    let directories = 0;
+    for (const file of this.files) {
+      if (file.includes(sep2)) {
+        directories++;
+      }
+      files++;
+    }
+    return {
+      files,
+      directories: Math.floor(directories / 3)
+    };
+  }
+  hasFile(name) {
+    if (name.includes("*")) {
+      const regex = new RegExp(
+        name.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")
+      );
+      for (const file of this.files) {
+        if (regex.test(file)) return true;
+      }
+      return false;
+    }
+    return this.files.has(name) || existsSync35(join36(this.projectPath, name));
+  }
+  getDepVersion(dep) {
+    if (!this.packageJson) return void 0;
+    const deps = this.packageJson.dependencies;
+    const devDeps = this.packageJson.devDependencies;
+    const version = deps?.[dep] || devDeps?.[dep];
+    return version?.replace(/^[\^~>=<]+/, "");
+  }
+  getRunCommand(script) {
+    const packageManagers = this.detectPackageManagers();
+    if (packageManagers.includes("pnpm")) {
+      return `pnpm ${script}`;
+    } else if (packageManagers.includes("yarn")) {
+      return `yarn ${script}`;
+    } else if (packageManagers.includes("bun")) {
+      return `bun run ${script}`;
+    }
+    return `npm run ${script}`;
+  }
+  readConfigFile(files) {
+    for (const file of files) {
+      const filePath = join36(this.projectPath, file);
+      if (existsSync35(filePath)) {
+        try {
+          const content = readFileSync27(filePath, "utf-8");
+          if (file.endsWith(".json")) {
+            return JSON.parse(content);
+          }
+          return content;
+        } catch {
+        }
+      }
+    }
+    return null;
+  }
+};
+function analyzePrimer(projectPath) {
+  const analyzer = new PrimerAnalyzer(projectPath);
+  return analyzer.analyze();
+}
+
+// src/primer/generator.ts
+import { existsSync as existsSync36, mkdirSync as mkdirSync19, writeFileSync as writeFileSync19 } from "fs";
+import { join as join37, dirname as dirname13 } from "path";
+var ALL_AGENTS = Object.keys(AGENT_CONFIG);
+var markdownRenderer = {
+  h1: (text) => `# ${text}`,
+  h2: (text) => `## ${text}`,
+  h3: (text) => `### ${text}`,
+  bold: (text) => `**${text}**`,
+  code: (text) => `\`${text}\``,
+  codeBlock: (code, lang = "") => `\`\`\`${lang}
+${code}
+\`\`\``,
+  list: (items) => items.map((item) => `- ${item}`).join("\n"),
+  keyValue: (key, value) => `**${key}:** ${value}`,
+  paragraph: (text) => text,
+  separator: () => "",
+  wrap: (content) => content
+};
+var mdcRenderer = {
+  h1: (text) => `# ${text}`,
+  h2: (text) => `## ${text}`,
+  h3: (text) => `### ${text}`,
+  bold: (text) => `**${text}**`,
+  code: (text) => `\`${text}\``,
+  codeBlock: (code, lang = "") => `\`\`\`${lang}
+${code}
+\`\`\``,
+  list: (items) => items.map((item) => `- ${item}`).join("\n"),
+  keyValue: (key, value) => `**${key}:** ${value}`,
+  paragraph: (text) => text,
+  separator: () => "",
+  wrap: (content, metadata) => {
+    if (metadata && Object.keys(metadata).length > 0) {
+      const yaml = Object.entries(metadata).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join("\n");
+      return `---
+${yaml}
+---
+
+${content}`;
+    }
+    return content;
+  }
+};
+var jsonRenderer = {
+  h1: (text) => text,
+  h2: (text) => text,
+  h3: (text) => text,
+  bold: (text) => text,
+  code: (text) => text,
+  codeBlock: (code) => code,
+  list: (items) => items.join(", "),
+  keyValue: (key, value) => `${key}: ${value}`,
+  paragraph: (text) => text,
+  separator: () => "",
+  wrap: (content, metadata) => {
+    try {
+      const data = { ...metadata, content };
+      return JSON.stringify(data, null, 2);
+    } catch {
+      return content;
+    }
+  }
+};
+var xmlRenderer = {
+  h1: (text) => `<h1>${escapeXml2(text)}</h1>`,
+  h2: (text) => `<h2>${escapeXml2(text)}</h2>`,
+  h3: (text) => `<h3>${escapeXml2(text)}</h3>`,
+  bold: (text) => `<strong>${escapeXml2(text)}</strong>`,
+  code: (text) => `<code>${escapeXml2(text)}</code>`,
+  codeBlock: (code, lang = "") => `<pre${lang ? ` lang="${lang}"` : ""}><code>${escapeXml2(code)}</code></pre>`,
+  list: (items) => `<ul>
+${items.map((item) => `  <li>${escapeXml2(item)}</li>`).join("\n")}
+</ul>`,
+  keyValue: (key, value) => `<dt>${escapeXml2(key)}</dt><dd>${escapeXml2(value)}</dd>`,
+  paragraph: (text) => `<p>${escapeXml2(text)}</p>`,
+  separator: () => "",
+  wrap: (content, metadata) => {
+    const attrs = metadata ? Object.entries(metadata).map(([k, v]) => `${k}="${escapeXml2(String(v))}"`).join(" ") : "";
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<instructions${attrs ? " " + attrs : ""}>
+${content}
+</instructions>`;
+  }
+};
+function escapeXml2(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function getRenderer(format) {
+  switch (format) {
+    case "mdc":
+      return mdcRenderer;
+    case "json":
+      return jsonRenderer;
+    case "xml":
+      return xmlRenderer;
+    default:
+      return markdownRenderer;
+  }
+}
+var PrimerGenerator = class {
+  projectPath;
+  options;
+  analysis = null;
+  constructor(projectPath, options = {}) {
+    this.projectPath = projectPath;
+    this.options = options;
+  }
+  generate() {
+    const warnings = [];
+    const errors = [];
+    const generated = [];
+    const seenPaths = /* @__PURE__ */ new Map();
+    this.analysis = analyzePrimer(this.projectPath);
+    if (this.options.analyzeOnly) {
+      return {
+        success: true,
+        analysis: this.analysis,
+        generated: [],
+        warnings,
+        errors
+      };
+    }
+    const targetAgents = this.getTargetAgents();
+    for (const agent of targetAgents) {
+      try {
+        const instruction = this.generateForAgent(agent);
+        if (instruction) {
+          const existingAgent = seenPaths.get(instruction.filepath);
+          if (existingAgent) {
+            warnings.push(
+              `Skipping ${agent}: output path "${instruction.filename}" already used by ${existingAgent}`
+            );
+            continue;
+          }
+          seenPaths.set(instruction.filepath, agent);
+          if (!this.options.dryRun) {
+            this.writeInstruction(instruction);
+          }
+          generated.push(instruction);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        errors.push(`Failed to generate for ${agent}: ${message}`);
+      }
+    }
+    return {
+      success: errors.length === 0,
+      analysis: this.analysis,
+      generated,
+      warnings,
+      errors
+    };
+  }
+  getTargetAgents() {
+    if (this.options.allAgents) {
+      return ALL_AGENTS;
+    }
+    if (this.options.agents && this.options.agents.length > 0) {
+      return this.options.agents;
+    }
+    return this.detectInstalledAgents();
+  }
+  detectInstalledAgents() {
+    const detected = [];
+    for (const [agent, config] of Object.entries(AGENT_CONFIG)) {
+      const configPath = join37(this.projectPath, config.configFile);
+      const skillsPath = join37(this.projectPath, config.skillsDir);
+      if (existsSync36(configPath) || existsSync36(skillsPath)) {
+        detected.push(agent);
+      }
+      if (config.altSkillsDirs) {
+        for (const altDir of config.altSkillsDirs) {
+          if (existsSync36(join37(this.projectPath, altDir))) {
+            if (!detected.includes(agent)) {
+              detected.push(agent);
+            }
+            break;
+          }
+        }
+      }
+    }
+    if (detected.length === 0) {
+      detected.push("claude-code", "cursor", "github-copilot");
+    }
+    return detected;
+  }
+  generateForAgent(agent) {
+    if (!this.analysis) return null;
+    const config = AGENT_CONFIG[agent];
+    const template = AGENT_INSTRUCTION_TEMPLATES[agent] || this.getDefaultTemplate(agent, config);
+    const content = this.generateContent(template);
+    const outputDir = this.options.outputDir || this.projectPath;
+    const filepath = join37(outputDir, template.filename);
+    return {
+      agent,
+      filename: template.filename,
+      filepath,
+      content,
+      format: template.format
+    };
+  }
+  getDefaultTemplate(agent, config) {
+    const formatMap = {
+      ".md": "markdown",
+      ".json": "json",
+      ".mdc": "mdc",
+      ".xml": "xml"
+    };
+    const ext = config.configFile.includes(".") ? "." + config.configFile.split(".").pop() : ".md";
+    const format = formatMap[ext] || "markdown";
+    return {
+      agent,
+      filename: config.configFile,
+      format,
+      sectionOrder: ["overview", "stack", "commands", "conventions", "structure", "guidelines"]
+    };
+  }
+  generateContent(template) {
+    if (!this.analysis) return "";
+    const format = template.format;
+    const renderer = getRenderer(format);
+    if (format === "json") {
+      return this.generateJsonContent(template);
+    }
+    const sections = [];
+    for (const section of template.sectionOrder) {
+      const content = this.generateSection(section, template, renderer);
+      if (content) {
+        sections.push(content);
+      }
+    }
+    let result = sections.join("\n\n");
+    if (template.header) {
+      result = template.header + "\n\n" + result;
+    }
+    if (template.footer) {
+      result = result + "\n\n" + template.footer;
+    }
+    if (this.options.customInstructions) {
+      result += "\n\n" + renderer.h2("Custom Instructions") + "\n\n" + this.options.customInstructions;
+    }
+    const metadata = format === "mdc" ? {
+      title: this.analysis.project.name,
+      type: this.analysis.project.type,
+      generated: (/* @__PURE__ */ new Date()).toISOString()
+    } : void 0;
+    return renderer.wrap(result, metadata);
+  }
+  generateJsonContent(template) {
+    if (!this.analysis) return "{}";
+    const data = {
+      project: this.analysis.project,
+      languages: this.analysis.languages.map((l) => l.name),
+      packageManagers: this.analysis.packageManagers,
+      stack: {
+        frameworks: this.analysis.stack.frameworks.map((f) => ({ name: f.name, version: f.version })),
+        libraries: this.analysis.stack.libraries.map((l) => ({ name: l.name, version: l.version })),
+        styling: this.analysis.stack.styling.map((s) => s.name),
+        testing: this.analysis.stack.testing.map((t) => t.name),
+        databases: this.analysis.stack.databases.map((d) => d.name)
+      },
+      commands: this.analysis.buildCommands,
+      conventions: this.analysis.conventions,
+      structure: this.analysis.structure,
+      importantFiles: this.analysis.importantFiles,
+      generated: {
+        agent: template.agent,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+    if (this.options.customInstructions) {
+      data.customInstructions = this.options.customInstructions;
+    }
+    return JSON.stringify(data, null, 2);
+  }
+  generateSection(section, template, renderer) {
+    if (!this.analysis) return "";
+    switch (section) {
+      case "overview":
+        return this.generateOverviewSection(renderer);
+      case "stack":
+        return this.generateStackSection(renderer);
+      case "commands":
+        return this.generateCommandsSection(renderer);
+      case "conventions":
+        return this.generateConventionsSection(renderer);
+      case "structure":
+        return this.generateStructureSection(renderer);
+      case "guidelines":
+        return this.generateGuidelinesSection(template.agent, renderer);
+      default:
+        return "";
+    }
+  }
+  generateOverviewSection(renderer) {
+    if (!this.analysis) return "";
+    const { project, languages } = this.analysis;
+    const lines = [];
+    lines.push(renderer.h1(project.name));
+    lines.push("");
+    if (project.description) {
+      lines.push(renderer.paragraph(project.description));
+      lines.push("");
+    }
+    if (project.type) {
+      lines.push(renderer.keyValue("Project Type", this.formatProjectType(project.type)));
+    }
+    if (languages.length > 0) {
+      const langNames = languages.map((l) => this.capitalize(l.name)).join(", ");
+      lines.push(renderer.keyValue("Languages", langNames));
+    }
+    if (project.version) {
+      lines.push(renderer.keyValue("Version", project.version));
+    }
+    return lines.join("\n");
+  }
+  generateStackSection(renderer) {
+    if (!this.analysis) return "";
+    const { stack, packageManagers } = this.analysis;
+    const lines = [];
+    lines.push(renderer.h2("Technology Stack"));
+    lines.push("");
+    if (stack.frameworks.length > 0) {
+      lines.push(renderer.h3("Frameworks"));
+      const items = stack.frameworks.map((fw) => {
+        const version = fw.version ? ` (${fw.version})` : "";
+        return `${this.capitalize(fw.name)}${version}`;
+      });
+      lines.push(renderer.list(items));
+      lines.push("");
+    }
+    if (stack.libraries.length > 0) {
+      lines.push(renderer.h3("Libraries"));
+      const items = stack.libraries.map((lib) => {
+        const version = lib.version ? ` (${lib.version})` : "";
+        return `${this.capitalize(lib.name)}${version}`;
+      });
+      lines.push(renderer.list(items));
+      lines.push("");
+    }
+    if (stack.styling.length > 0) {
+      lines.push(renderer.h3("Styling"));
+      lines.push(renderer.list(stack.styling.map((s) => this.capitalize(s.name))));
+      lines.push("");
+    }
+    if (stack.testing.length > 0) {
+      lines.push(renderer.h3("Testing"));
+      lines.push(renderer.list(stack.testing.map((t) => this.capitalize(t.name))));
+      lines.push("");
+    }
+    if (stack.databases.length > 0) {
+      lines.push(renderer.h3("Databases"));
+      lines.push(renderer.list(stack.databases.map((d) => this.capitalize(d.name))));
+      lines.push("");
+    }
+    if (packageManagers.length > 0) {
+      lines.push(renderer.h3("Package Manager"));
+      lines.push(renderer.list([packageManagers.map((pm) => this.capitalize(pm)).join(", ")]));
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  generateCommandsSection(renderer) {
+    if (!this.analysis || !this.analysis.buildCommands) return "";
+    const { buildCommands } = this.analysis;
+    const lines = [];
+    const commands = [];
+    lines.push(renderer.h2("Development Commands"));
+    lines.push("");
+    if (buildCommands.install) {
+      commands.push(`# Install dependencies`);
+      commands.push(buildCommands.install);
+      commands.push("");
+    }
+    if (buildCommands.dev) {
+      commands.push(`# Start development server`);
+      commands.push(buildCommands.dev);
+      commands.push("");
+    }
+    if (buildCommands.build) {
+      commands.push(`# Build for production`);
+      commands.push(buildCommands.build);
+      commands.push("");
+    }
+    if (buildCommands.test) {
+      commands.push(`# Run tests`);
+      commands.push(buildCommands.test);
+      commands.push("");
+    }
+    if (buildCommands.lint) {
+      commands.push(`# Run linter`);
+      commands.push(buildCommands.lint);
+      commands.push("");
+    }
+    if (buildCommands.format) {
+      commands.push(`# Format code`);
+      commands.push(buildCommands.format);
+    }
+    lines.push(renderer.codeBlock(commands.join("\n"), "bash"));
+    return lines.join("\n");
+  }
+  generateConventionsSection(renderer) {
+    if (!this.analysis) return "";
+    const { conventions, patterns } = this.analysis;
+    const lines = [];
+    lines.push(renderer.h2("Code Conventions"));
+    lines.push("");
+    if (conventions) {
+      const items = [];
+      if (conventions.indentation) {
+        items.push(`${renderer.bold("Indentation:")} ${conventions.indentation}`);
+      }
+      if (conventions.quotes) {
+        items.push(`${renderer.bold("Quotes:")} ${conventions.quotes}`);
+      }
+      if (conventions.semicolons !== void 0) {
+        items.push(`${renderer.bold("Semicolons:")} ${conventions.semicolons ? "required" : "omitted"}`);
+      }
+      if (conventions.trailingCommas) {
+        items.push(`${renderer.bold("Trailing Commas:")} ${conventions.trailingCommas}`);
+      }
+      if (conventions.maxLineLength) {
+        items.push(`${renderer.bold("Max Line Length:")} ${conventions.maxLineLength}`);
+      }
+      if (items.length > 0) {
+        lines.push(renderer.list(items));
+      }
+    }
+    if (patterns) {
+      lines.push("");
+      lines.push(renderer.h3("Patterns"));
+      const items = [];
+      if (patterns.components) {
+        items.push(`${renderer.bold("Components:")} ${patterns.components}`);
+      }
+      if (patterns.stateManagement) {
+        items.push(`${renderer.bold("State Management:")} ${patterns.stateManagement}`);
+      }
+      if (patterns.apiStyle) {
+        items.push(`${renderer.bold("API Style:")} ${patterns.apiStyle}`);
+      }
+      if (patterns.styling) {
+        items.push(`${renderer.bold("Styling:")} ${patterns.styling}`);
+      }
+      if (patterns.testing) {
+        items.push(`${renderer.bold("Testing:")} ${patterns.testing}`);
+      }
+      if (patterns.linting) {
+        items.push(`${renderer.bold("Linting:")} ${patterns.linting}`);
+      }
+      if (patterns.formatting) {
+        items.push(`${renderer.bold("Formatting:")} ${patterns.formatting}`);
+      }
+      if (items.length > 0) {
+        lines.push(renderer.list(items));
+      }
+    }
+    return lines.join("\n");
+  }
+  generateStructureSection(renderer) {
+    if (!this.analysis) return "";
+    const { structure, importantFiles } = this.analysis;
+    const lines = [];
+    lines.push(renderer.h2("Project Structure"));
+    lines.push("");
+    if (structure) {
+      if (structure.type) {
+        lines.push(renderer.keyValue("Structure Type", structure.type));
+      }
+      if (structure.srcDir) {
+        lines.push(renderer.keyValue("Source Directory", renderer.code(`${structure.srcDir}/`)));
+      }
+      if (structure.testDir) {
+        lines.push(renderer.keyValue("Test Directory", renderer.code(`${structure.testDir}/`)));
+      }
+      if (structure.hasWorkspaces && structure.workspaces) {
+        lines.push(renderer.keyValue("Workspaces", structure.workspaces.join(", ")));
+      }
+      lines.push("");
+    }
+    if (importantFiles.length > 0) {
+      lines.push(renderer.h3("Important Files"));
+      lines.push(renderer.list(importantFiles.slice(0, 15).map((f) => renderer.code(f))));
+    }
+    return lines.join("\n");
+  }
+  generateGuidelinesSection(_agent, renderer) {
+    if (!this.analysis) return "";
+    const { stack, patterns } = this.analysis;
+    const lines = [];
+    lines.push(renderer.h2("Development Guidelines"));
+    lines.push("");
+    const hasReact = stack.frameworks.some((f) => f.name === "react" || f.name === "nextjs");
+    const hasVue = stack.frameworks.some((f) => f.name === "vue" || f.name === "nuxt");
+    const hasTypeScript = this.analysis.languages.some((l) => l.name === "typescript");
+    const hasTailwind = stack.styling.some((s) => s.name === "tailwindcss");
+    const hasPrisma = stack.databases.some((d) => d.name === "prisma");
+    const hasZod = stack.libraries.some((l) => l.name === "zod");
+    if (hasTypeScript) {
+      lines.push(renderer.h3("TypeScript"));
+      lines.push(renderer.list([
+        "Use strict TypeScript with proper type annotations",
+        "Prefer `interface` for object types, `type` for unions/intersections",
+        "Avoid `any` - use `unknown` when type is uncertain"
+      ]));
+      lines.push("");
+    }
+    if (hasReact) {
+      lines.push(renderer.h3("React"));
+      const reactItems = [
+        "Use functional components with hooks",
+        "Prefer composition over inheritance",
+        "Keep components small and focused"
+      ];
+      if (patterns?.stateManagement) {
+        reactItems.push(`Use ${patterns.stateManagement} for state management`);
+      }
+      lines.push(renderer.list(reactItems));
+      lines.push("");
+    }
+    if (hasVue) {
+      lines.push(renderer.h3("Vue"));
+      lines.push(renderer.list([
+        "Use Composition API with `<script setup>`",
+        "Keep components small and focused"
+      ]));
+      lines.push("");
+    }
+    if (hasTailwind) {
+      lines.push(renderer.h3("Styling"));
+      lines.push(renderer.list([
+        "Use Tailwind CSS utility classes",
+        "Follow mobile-first responsive design",
+        "Extract repeated patterns to components"
+      ]));
+      lines.push("");
+    }
+    if (hasPrisma) {
+      lines.push(renderer.h3("Database"));
+      lines.push(renderer.list([
+        "Use Prisma for database operations",
+        "Keep database queries in dedicated service files",
+        "Use transactions for related operations"
+      ]));
+      lines.push("");
+    }
+    if (hasZod) {
+      lines.push(renderer.h3("Validation"));
+      lines.push(renderer.list([
+        "Use Zod for runtime validation",
+        "Define schemas alongside types"
+      ]));
+      lines.push("");
+    }
+    lines.push(renderer.h3("General"));
+    lines.push(renderer.list([
+      "Follow existing code patterns and conventions",
+      "Write clear, self-documenting code",
+      "Keep functions small and focused",
+      "Add tests for new functionality"
+    ]));
+    return lines.join("\n");
+  }
+  writeInstruction(instruction) {
+    const dir = dirname13(instruction.filepath);
+    if (!existsSync36(dir)) {
+      mkdirSync19(dir, { recursive: true });
+    }
+    writeFileSync19(instruction.filepath, instruction.content, "utf-8");
+  }
+  formatProjectType(type) {
+    const typeMap = {
+      "web-app": "Web Application",
+      "api": "API / Backend",
+      "cli": "CLI Tool",
+      "library": "Library / Package",
+      "mobile": "Mobile Application",
+      "desktop": "Desktop Application",
+      "unknown": "Project"
+    };
+    return typeMap[type] || type;
+  }
+  capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+};
+function generatePrimer(projectPath, options = {}) {
+  const generator = new PrimerGenerator(projectPath, options);
+  return generator.generate();
+}
+function generatePrimerForAgent(projectPath, agent, options = {}) {
+  return generatePrimer(projectPath, { ...options, agents: [agent] });
+}
+function analyzeForPrimer(projectPath) {
+  const generator = new PrimerGenerator(projectPath, { analyzeOnly: true });
+  const result = generator.generate();
+  return result.analysis;
+}
 export {
   AGENT_CLI_CONFIGS,
   AGENT_CONFIG,
   AGENT_DISCOVERY_PATHS,
   AGENT_FORMAT_MAP,
+  AGENT_INSTRUCTION_TEMPLATES,
   AGENT_SKILL_FORMATS,
   AIManager,
   AISearch,
@@ -18584,6 +19889,8 @@ export {
   PlanValidator,
   PluginLoader,
   PluginManager,
+  PrimerAnalyzer,
+  PrimerGenerator,
   ProjectDetector,
   RecommendationEngine,
   RuleBasedCompressor,
@@ -18613,6 +19920,8 @@ export {
   WorkflowOrchestrator,
   addToManifest,
   agentExists,
+  analyzeForPrimer,
+  analyzePrimer,
   analyzeProject,
   benchmarkSkill,
   buildSkillIndex,
@@ -18685,6 +19994,8 @@ export {
   fromCanonicalAgent,
   generateComparisonNotes,
   generateManifestFromInstalled,
+  generatePrimer,
+  generatePrimerForAgent,
   generateRecommendations,
   generateSkillsConfig,
   getAgentCLIConfig,