@harness-engineering/cli 1.0.1 → 1.1.0

package/dist/agents/agents/skills/node_modules/zod/v4-mini/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../v4/mini/index.cjs"), exports);

package/dist/agents/agents/skills/node_modules/zod/v4-mini/index.d.cts

@@ -0,0 +1 @@
+export * from "../v4/mini/index.cjs";

package/dist/agents/agents/skills/node_modules/zod/v4-mini/index.d.ts

@@ -0,0 +1 @@
+export * from "../v4/mini/index.js";

package/dist/agents/agents/skills/node_modules/zod/v4-mini/index.js

@@ -0,0 +1 @@
+export * from "../v4/mini/index.js";

package/dist/agents/agents/skills/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@harness-engineering/skills",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Agent skills for harness engineering",
+  "type": "module",
+  "scripts": {
+    "test": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "devDependencies": {
+    "glob": "^10.3.0",
+    "vitest": "^4.0.18",
+    "yaml": "^2.3.0",
+    "zod": "^3.22.0"
+  }
+}

package/dist/agents/agents/skills/tests/references.test.ts

@@ -0,0 +1,85 @@
+// agents/skills/tests/references.test.ts
+import { describe, it, expect } from 'vitest';
+import { glob } from 'glob';
+import { readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { parse } from 'yaml';
+import { SkillMetadataSchema } from './schema';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SKILLS_DIR = resolve(__dirname, '..');
+
+describe('skill.yaml schema validation', () => {
+  const skillFiles = glob.sync('**/skill.yaml', {
+    cwd: SKILLS_DIR,
+    ignore: ['**/node_modules/**', '**/tests/**'],
+  });
+
+  if (skillFiles.length === 0) {
+    it.skip('no skill files found yet', () => {});
+    return;
+  }
+
+  // Only validate skills that match the new schema (skip old-format during migration)
+  const validSkills = skillFiles.filter((file) => {
+    const content = readFileSync(resolve(SKILLS_DIR, file), 'utf-8');
+    const parsed = parse(content);
+    return SkillMetadataSchema.safeParse(parsed).success;
+  });
+
+  if (validSkills.length === 0) {
+    it.skip('no skills matching new schema found yet', () => {});
+  } else {
+    it.each(validSkills)('%s conforms to schema', (file) => {
+      const content = readFileSync(resolve(SKILLS_DIR, file), 'utf-8');
+      const parsed = parse(content);
+      const result = SkillMetadataSchema.safeParse(parsed);
+      expect(
+        result.success,
+        `Schema validation failed for ${file}: ${JSON.stringify(result)}`
+      ).toBe(true);
+    });
+  }
+});
+
+describe('depends_on references', () => {
+  const skillFiles = glob.sync('**/skill.yaml', {
+    cwd: SKILLS_DIR,
+    ignore: ['**/node_modules/**', '**/tests/**'],
+  });
+
+  if (skillFiles.length === 0) {
+    it.skip('no skill files found yet', () => {});
+    return;
+  }
+
+  // Only validate skills matching new schema; collect all names for reference checking
+  const allSkillNames = new Set<string>();
+  for (const file of skillFiles) {
+    const content = readFileSync(resolve(SKILLS_DIR, file), 'utf-8');
+    const parsed = parse(content);
+    if (parsed?.name) allSkillNames.add(parsed.name);
+  }
+
+  const validSkills = skillFiles.filter((file) => {
+    const content = readFileSync(resolve(SKILLS_DIR, file), 'utf-8');
+    const parsed = parse(content);
+    return SkillMetadataSchema.safeParse(parsed).success;
+  });
+
+  if (validSkills.length === 0) {
+    it.skip('no skills matching new schema found yet', () => {});
+  } else {
+    it.each(validSkills)('%s depends_on references existing skills', (file) => {
+      const content = readFileSync(resolve(SKILLS_DIR, file), 'utf-8');
+      const parsed = parse(content);
+      const result = SkillMetadataSchema.safeParse(parsed);
+      if (!result.success) return;
+
+      for (const dep of result.data.depends_on) {
+        expect(allSkillNames.has(dep), `${file} references unknown skill: ${dep}`).toBe(true);
+      }
+    });
+  }
+});

package/dist/agents/agents/skills/tests/schema.test.ts

@@ -0,0 +1,95 @@
+// agents/skills/tests/schema.test.ts
+import { describe, it, expect } from 'vitest';
+import { SkillMetadataSchema } from './schema';
+
+describe('SkillMetadataSchema', () => {
+  const validSkill = {
+    name: 'harness-tdd',
+    version: '1.0.0',
+    description: 'Test-driven development integrated with harness validation',
+    triggers: ['manual', 'on_new_feature', 'on_bug_fix'],
+    platforms: ['claude-code', 'gemini-cli'],
+    tools: ['Bash', 'Read', 'Write', 'Edit'],
+    type: 'rigid',
+  };
+
+  it('validates a complete skill.yaml', () => {
+    const result = SkillMetadataSchema.safeParse(validSkill);
+    expect(result.success).toBe(true);
+  });
+
+  it('validates with all optional fields', () => {
+    const full = {
+      ...validSkill,
+      cli: {
+        command: 'harness skill run harness-tdd',
+        args: [{ name: 'path', description: 'Project root', required: false }],
+      },
+      mcp: { tool: 'run_skill', input: { skill: 'harness-tdd', path: 'string' } },
+      phases: [
+        { name: 'red', description: 'Write failing test' },
+        { name: 'green', description: 'Implement minimal code' },
+      ],
+      state: { persistent: true, files: ['.harness/state.json'] },
+      depends_on: ['harness-verification'],
+    };
+    const result = SkillMetadataSchema.safeParse(full);
+    expect(result.success).toBe(true);
+  });
+
+  it('applies defaults for optional fields', () => {
+    const result = SkillMetadataSchema.parse(validSkill);
+    expect(result.state).toEqual({ persistent: false, files: [] });
+    expect(result.depends_on).toEqual([]);
+  });
+
+  it('rejects invalid name format', () => {
+    const result = SkillMetadataSchema.safeParse({ ...validSkill, name: 'Invalid Name' });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects invalid platform', () => {
+    const result = SkillMetadataSchema.safeParse({ ...validSkill, platforms: ['invalid'] });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects invalid trigger', () => {
+    const result = SkillMetadataSchema.safeParse({ ...validSkill, triggers: ['on_deploy'] });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects invalid type', () => {
+    const result = SkillMetadataSchema.safeParse({ ...validSkill, type: 'optional' });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects invalid version format', () => {
+    const result = SkillMetadataSchema.safeParse({ ...validSkill, version: '1' });
+    expect(result.success).toBe(false);
+  });
+
+  it('validates phase with required field', () => {
+    const withPhases = {
+      ...validSkill,
+      phases: [
+        { name: 'red', description: 'Write failing test', required: true },
+        { name: 'refactor', description: 'Clean up', required: false },
+      ],
+    };
+    const result = SkillMetadataSchema.safeParse(withPhases);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.phases![0].required).toBe(true);
+      expect(result.data.phases![1].required).toBe(false);
+    }
+  });
+
+  it('defaults required to true for phases', () => {
+    const withPhases = {
+      ...validSkill,
+      phases: [{ name: 'red', description: 'Write failing test' }],
+    };
+    const result = SkillMetadataSchema.parse(withPhases);
+    expect(result.phases![0].required).toBe(true);
+  });
+});

package/dist/agents/agents/skills/tests/schema.ts

@@ -0,0 +1,66 @@
+// agents/skills/tests/schema.ts
+import { z } from 'zod';
+
+const SkillPhaseSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  required: z.boolean().default(true),
+});
+
+const SkillCliSchema = z.object({
+  command: z.string(),
+  args: z
+    .array(
+      z.object({
+        name: z.string(),
+        description: z.string(),
+        required: z.boolean().default(false),
+      })
+    )
+    .default([]),
+});
+
+const SkillMcpSchema = z.object({
+  tool: z.string(),
+  input: z.record(z.string()),
+});
+
+const SkillStateSchema = z.object({
+  persistent: z.boolean().default(false),
+  files: z.array(z.string()).default([]),
+});
+
+const ALLOWED_TRIGGERS = [
+  'manual',
+  'on_pr',
+  'on_commit',
+  'on_new_feature',
+  'on_bug_fix',
+  'on_refactor',
+  'on_project_init',
+  'on_review',
+] as const;
+
+const ALLOWED_PLATFORMS = ['claude-code', 'gemini-cli'] as const;
+
+export const SkillMetadataSchema = z.object({
+  name: z.string().regex(/^[a-z][a-z0-9-]*$/, 'Name must be lowercase with hyphens'),
+  version: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver format'),
+  description: z.string(),
+  triggers: z.array(z.enum(ALLOWED_TRIGGERS)),
+  platforms: z.array(z.enum(ALLOWED_PLATFORMS)),
+  tools: z.array(z.string()),
+  cli: SkillCliSchema.optional(),
+  mcp: SkillMcpSchema.optional(),
+  type: z.enum(['rigid', 'flexible']),
+  phases: z.array(SkillPhaseSchema).optional(),
+  state: SkillStateSchema.default({}),
+  depends_on: z.array(z.string()).default([]),
+});
+
+export type SkillMetadata = z.infer<typeof SkillMetadataSchema>;
+export type SkillPhase = z.infer<typeof SkillPhaseSchema>;
+export type SkillCli = z.infer<typeof SkillCliSchema>;
+export type SkillState = z.infer<typeof SkillStateSchema>;
+
+export { ALLOWED_TRIGGERS, ALLOWED_PLATFORMS };

package/dist/agents/agents/skills/tests/structure.test.ts

@@ -0,0 +1,82 @@
+// agents/skills/tests/structure.test.ts
+import { describe, it, expect } from 'vitest';
+import { glob } from 'glob';
+import { readFileSync, existsSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { parse } from 'yaml';
+import { SkillMetadataSchema } from './schema';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SKILLS_DIR = resolve(__dirname, '..');
+
+const REQUIRED_SECTIONS = [
+  '## When to Use',
+  '## Process',
+  '## Harness Integration',
+  '## Success Criteria',
+  '## Examples',
+];
+const RIGID_SECTIONS = ['## Gates', '## Escalation'];
+
+describe('SKILL.md structure', () => {
+  const skillMdFiles = glob.sync('**/SKILL.md', {
+    cwd: SKILLS_DIR,
+    ignore: ['**/node_modules/**', '**/tests/**'],
+  });
+
+  if (skillMdFiles.length === 0) {
+    it.skip('no SKILL.md files found yet', () => {});
+    return;
+  }
+
+  it.each(skillMdFiles)('%s has required sections', (file) => {
+    const content = readFileSync(resolve(SKILLS_DIR, file), 'utf-8');
+    for (const section of REQUIRED_SECTIONS) {
+      expect(content, `Missing section: ${section} in ${file}`).toContain(section);
+    }
+  });
+
+  it.each(skillMdFiles)('%s starts with h1 heading', (file) => {
+    const content = readFileSync(resolve(SKILLS_DIR, file), 'utf-8');
+    expect(content.trim()).toMatch(/^# /);
+  });
+
+  it.each(skillMdFiles)('%s has corresponding skill.yaml', (file) => {
+    const dir = resolve(SKILLS_DIR, file, '..');
+    expect(existsSync(resolve(dir, 'skill.yaml')), `Missing skill.yaml for ${file}`).toBe(true);
+  });
+});
+
+describe('rigid skills have Gates and Escalation sections', () => {
+  const skillYamlFiles = glob.sync('**/skill.yaml', {
+    cwd: SKILLS_DIR,
+    ignore: ['**/node_modules/**', '**/tests/**'],
+  });
+
+  if (skillYamlFiles.length === 0) {
+    it.skip('no skill.yaml files found yet', () => {});
+    return;
+  }
+
+  const rigidSkills = skillYamlFiles.filter((file) => {
+    const content = readFileSync(resolve(SKILLS_DIR, file), 'utf-8');
+    const parsed = parse(content);
+    return parsed?.type === 'rigid';
+  });
+
+  if (rigidSkills.length === 0) {
+    it.skip('no rigid skills found yet', () => {});
+    return;
+  }
+
+  it.each(rigidSkills)('%s (rigid) has Gates and Escalation sections', (file) => {
+    const dir = resolve(SKILLS_DIR, file, '..');
+    const skillMdPath = resolve(dir, 'SKILL.md');
+    if (!existsSync(skillMdPath)) return; // skip if SKILL.md doesn't exist yet
+    const content = readFileSync(skillMdPath, 'utf-8');
+    for (const section of RIGID_SECTIONS) {
+      expect(content, `Rigid skill missing section: ${section}`).toContain(section);
+    }
+  });
+});

package/dist/agents/agents/skills/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "types": ["node"]
+  },
+  "include": ["tests/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/agents/agents/skills/vitest.config.mts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+  },
+});

package/dist/agents/personas/architecture-enforcer.yaml

@@ -0,0 +1,27 @@
+version: 1
+name: Architecture Enforcer
+description: Validates architectural constraints and dependency rules
+role: Enforce layer boundaries, detect circular dependencies, block forbidden imports
+skills:
+  - enforce-architecture
+  - check-mechanical-constraints
+commands:
+  - check-deps
+  - validate
+triggers:
+  - event: on_pr
+    conditions:
+      paths: ["src/**"]
+  - event: on_commit
+    conditions:
+      branches: ["main", "develop"]
+  - event: scheduled
+    cron: "0 6 * * 1"
+config:
+  severity: error
+  autoFix: false
+  timeout: 300000
+outputs:
+  agents-md: true
+  ci-workflow: true
+  runtime-config: true

package/dist/agents/personas/documentation-maintainer.yaml

@@ -0,0 +1,25 @@
+version: 1
+name: Documentation Maintainer
+description: Keeps documentation in sync with source code
+role: Detect documentation drift, validate doc coverage, align docs with code changes
+skills:
+  - detect-doc-drift
+  - align-documentation
+commands:
+  - check-docs
+  - validate
+triggers:
+  - event: on_pr
+    conditions:
+      paths: ["src/**", "docs/**"]
+  - event: on_commit
+    conditions:
+      branches: ["main"]
+config:
+  severity: warning
+  autoFix: false
+  timeout: 300000
+outputs:
+  agents-md: true
+  ci-workflow: true
+  runtime-config: true

package/dist/agents/personas/entropy-cleaner.yaml

@@ -0,0 +1,21 @@
+version: 1
+name: Entropy Cleaner
+description: Detects and fixes codebase entropy (drift, dead code, pattern violations)
+role: Run scheduled cleanup, detect documentation drift, fix pattern violations
+skills:
+  - cleanup-dead-code
+  - detect-doc-drift
+commands:
+  - cleanup
+  - fix-drift
+triggers:
+  - event: scheduled
+    cron: "0 6 * * 1"
+config:
+  severity: warning
+  autoFix: false
+  timeout: 600000
+outputs:
+  agents-md: true
+  ci-workflow: true
+  runtime-config: true

package/dist/agents/skills/.turbo/turbo-test.log

@@ -0,0 +1,16 @@
+
+> @harness-engineering/skills@1.0.0 test /Users/cwarner/Projects/harness-engineering/agents/skills
+> vitest
+
+
+ RUN  v4.0.18 /Users/cwarner/Projects/harness-engineering/agents/skills
+
+ ✓ tests/schema.test.ts (10 tests) 5ms
+ ✓ tests/structure.test.ts (91 tests) 10ms
+ ✓ tests/references.test.ts (48 tests) 41ms
+
+ Test Files  3 passed (3)
+      Tests  149 passed (149)
+   Start at  12:08:55
+   Duration  572ms (transform 58ms, setup 0ms, import 443ms, tests 56ms, environment 0ms)
+

package/dist/agents/skills/README.md

@@ -0,0 +1,64 @@
+# Harness Engineering Agent Skills
+
+Agent skills for Claude Code and Gemini CLI that implement harness engineering practices.
+
+## Structure
+
+```
+agents/skills/
+├── shared/           # Shared prompt fragments
+├── claude-code/      # Claude Code skills
+├── gemini-cli/       # Gemini CLI skills
+└── tests/            # Validation tests
+```
+
+## Available Skills
+
+### Enforcement
+
+- `validate-context-engineering` - Validate AGENTS.md, doc coverage, knowledge map
+- `enforce-architecture` - Check layer boundaries and circular deps
+- `check-mechanical-constraints` - Run all mechanical checks
+
+### Workflow
+
+- `harness-tdd` - Test-driven development guidance
+- `harness-code-review` - Structured code review
+- `harness-refactoring` - Safe refactoring process
+
+### Entropy
+
+- `detect-doc-drift` - Find stale documentation
+- `cleanup-dead-code` - Find unused code
+- `align-documentation` - Auto-fix doc drift
+
+### Setup
+
+- `initialize-harness-project` - Scaffold new project
+- `add-harness-component` - Add components
+
+## Usage
+
+### Claude Code
+
+```
+/validate-context-engineering
+```
+
+### Gemini CLI
+
+```
+@validate-context-engineering
+```
+
+## Testing
+
+```bash
+pnpm test
+```
+
+## Adding New Skills
+
+1. Create directory under `claude-code/` and `gemini-cli/`
+2. Add `skill.yaml`, `prompt.md`, `README.md`
+3. Run tests to validate