@forwardimpact/libharness 0.1.22 → 1.0.0

package/src/fixture/index.js

@@ -1,9 +0,0 @@
-export {
-  assertThrowsMessage,
-  assertRejectsMessage,
-  createDeferred,
-} from "./assertions.js";
-export * from "./services.js";
-export * from "./pathway.js";
-export * from "./eval.js";
-export { memoizeAsync, memoizeOnSubject } from "./cache.js";

package/src/fixture/pathway.js

@@ -1,451 +0,0 @@
-/**
- * Pathway test fixtures for creating realistic test data
- * Provides mock disciplines, levels, tracks, skills, and behaviours
- */
-
-/**
- * Creates a mock level definition
- * @param {object} overrides - Properties to override
- * @returns {object} Mock level
- */
-export function createTestLevel(overrides = {}) {
-  return {
-    id: "mid",
-    name: "Mid-Level",
-    ordinalRank: 3,
-    professionalTitle: "Level III",
-    managementTitle: "Manager",
-    baseSkillProficiencies: {
-      core: "working",
-      supporting: "foundational",
-      broad: "awareness",
-    },
-    baseBehaviourMaturity: "developing",
-    expectations: {},
-    ...overrides,
-  };
-}
-
-/**
- * Creates a set of mock levels spanning junior to senior
- * @returns {object[]} Array of mock levels
- */
-export function createTestLevels() {
-  return [
-    createTestLevel({
-      id: "junior",
-      name: "Junior",
-      ordinalRank: 1,
-      professionalTitle: "Level I",
-      managementTitle: "Team Lead",
-      baseSkillProficiencies: {
-        core: "foundational",
-        supporting: "awareness",
-        broad: "awareness",
-      },
-      baseBehaviourMaturity: "emerging",
-    }),
-    createTestLevel({
-      id: "mid",
-      name: "Mid-Level",
-      ordinalRank: 3,
-      professionalTitle: "Level III",
-      managementTitle: "Manager",
-      baseSkillProficiencies: {
-        core: "working",
-        supporting: "foundational",
-        broad: "awareness",
-      },
-      baseBehaviourMaturity: "developing",
-    }),
-    createTestLevel({
-      id: "senior",
-      name: "Senior",
-      ordinalRank: 5,
-      professionalTitle: "Senior",
-      managementTitle: "Senior Manager",
-      baseSkillProficiencies: {
-        core: "practitioner",
-        supporting: "working",
-        broad: "foundational",
-      },
-      baseBehaviourMaturity: "practicing",
-    }),
-    createTestLevel({
-      id: "staff",
-      name: "Staff",
-      ordinalRank: 7,
-      professionalTitle: "Staff",
-      managementTitle: "Director",
-      baseSkillProficiencies: {
-        core: "expert",
-        supporting: "practitioner",
-        broad: "working",
-      },
-      baseBehaviourMaturity: "role_modeling",
-    }),
-  ];
-}
-
-/**
- * Creates a mock skill definition
- * @param {object} overrides - Properties to override
- * @returns {object} Mock skill
- */
-export function createTestSkill(overrides = {}) {
-  return {
-    id: "test_skill",
-    name: "Test Skill",
-    capability: "delivery",
-    isHumanOnly: false,
-    proficiencyDescriptions: {
-      awareness: "Basic awareness",
-      foundational: "Foundational understanding",
-      working: "Working proficiency",
-      practitioner: "Practitioner level",
-      expert: "Expert level",
-    },
-    ...overrides,
-  };
-}
-
-/**
- * Creates a set of mock skills across capabilities
- * @returns {object[]} Array of mock skills
- */
-export function createTestSkills() {
-  return [
-    createTestSkill({
-      id: "coding",
-      name: "Coding",
-      capability: "delivery",
-    }),
-    createTestSkill({
-      id: "testing",
-      name: "Testing",
-      capability: "delivery",
-    }),
-    createTestSkill({
-      id: "architecture",
-      name: "Architecture",
-      capability: "scale",
-    }),
-    createTestSkill({
-      id: "observability",
-      name: "Observability",
-      capability: "scale",
-    }),
-    createTestSkill({
-      id: "ai_tools",
-      name: "AI Tools",
-      capability: "ai",
-    }),
-    createTestSkill({
-      id: "mentoring",
-      name: "Mentoring",
-      capability: "delivery",
-      isHumanOnly: true,
-    }),
-  ];
-}
-
-/**
- * Creates a mock discipline definition
- * @param {object} overrides - Properties to override
- * @returns {object} Mock discipline
- */
-export function createTestDiscipline(overrides = {}) {
-  return {
-    id: "software_engineering",
-    name: "Software Engineering",
-    roleTitle: "Software Engineer",
-    isProfessional: true,
-    isManagement: false,
-    coreSkills: ["coding", "testing"],
-    supportingSkills: ["architecture"],
-    broadSkills: ["observability"],
-    behaviourModifiers: {},
-    validTracks: [],
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock track definition
- * @param {object} overrides - Properties to override
- * @returns {object} Mock track
- */
-export function createTestTrack(overrides = {}) {
-  return {
-    id: "platform",
-    name: "Platform",
-    skillModifiers: { scale: 1, delivery: -1 },
-    behaviourModifiers: {},
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock behaviour definition
- * @param {object} overrides - Properties to override
- * @returns {object} Mock behaviour
- */
-export function createTestBehaviour(overrides = {}) {
-  return {
-    id: "collaboration",
-    name: "Collaboration",
-    maturityDescriptions: {
-      emerging: "Beginning to collaborate",
-      developing: "Developing collaboration",
-      practicing: "Practicing collaboration",
-      role_modeling: "Role modeling collaboration",
-      exemplifying: "Exemplifying collaboration",
-    },
-    ...overrides,
-  };
-}
-
-/**
- * Creates a set of mock behaviours
- * @returns {object[]} Array of mock behaviours
- */
-export function createTestBehaviours() {
-  return [
-    createTestBehaviour({ id: "collaboration", name: "Collaboration" }),
-    createTestBehaviour({ id: "communication", name: "Communication" }),
-    createTestBehaviour({ id: "leadership", name: "Leadership" }),
-  ];
-}
-
-/**
- * Creates a mock capability definition
- * @param {object} overrides - Properties to override
- * @returns {object} Mock capability
- */
-export function createTestCapability(overrides = {}) {
-  return {
-    id: "delivery",
-    name: "Delivery",
-    emojiIcon: "🚀",
-    ordinalRank: 1,
-    professionalResponsibilities: {
-      foundational: "Delivers assigned tasks",
-      working: "Delivers features independently",
-      practitioner: "Leads delivery across team",
-      expert: "Defines delivery strategy",
-    },
-    managementResponsibilities: {
-      foundational: "Manages delivery timelines",
-      working: "Owns team delivery",
-      practitioner: "Leads multi-team delivery",
-      expert: "Shapes delivery culture",
-    },
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock driver definition
- * @param {object} overrides - Properties to override
- * @returns {object} Mock driver
- */
-export function createTestDriver(overrides = {}) {
-  return {
-    id: "velocity",
-    name: "Velocity",
-    contributingSkills: ["coding", "testing"],
-    contributingBehaviours: ["collaboration"],
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock skill matrix entry
- * @param {object} overrides - Properties to override
- * @returns {object} Mock skill matrix entry
- */
-export function createTestSkillEntry(overrides = {}) {
-  return {
-    skillId: "coding",
-    skillName: "Coding",
-    capability: "delivery",
-    isHumanOnly: false,
-    type: "core",
-    proficiency: "working",
-    proficiencyDescription: "Working proficiency",
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock behaviour profile entry
- * @param {object} overrides - Properties to override
- * @returns {object} Mock behaviour profile entry
- */
-export function createTestBehaviourEntry(overrides = {}) {
-  return {
-    behaviourId: "collaboration",
-    behaviourName: "Collaboration",
-    maturity: "developing",
-    maturityDescription: "Developing collaboration",
-    ...overrides,
-  };
-}
-
-/**
- * Creates a set of mock drivers
- * @returns {object[]}
- */
-export function createTestDrivers() {
-  return [
-    createTestDriver({
-      id: "velocity",
-      name: "Velocity",
-      contributingSkills: ["coding", "testing"],
-      contributingBehaviours: ["collaboration"],
-    }),
-    createTestDriver({
-      id: "quality",
-      name: "Quality",
-      contributingSkills: ["testing", "architecture"],
-      contributingBehaviours: ["communication"],
-    }),
-  ];
-}
-
-/**
- * Creates a set of mock capabilities spanning delivery / scale / ai.
- * @returns {object[]}
- */
-export function createTestCapabilities() {
-  return [
-    createTestCapability({ id: "delivery", name: "Delivery", ordinalRank: 1 }),
-    createTestCapability({ id: "scale", name: "Scale", ordinalRank: 2 }),
-    createTestCapability({ id: "ai", name: "AI", ordinalRank: 3 }),
-  ];
-}
-
-/**
- * Creates a set of mock tracks.
- * @returns {object[]}
- */
-export function createTestTracks() {
-  return [
-    createTestTrack({
-      id: "platform",
-      name: "Platform",
-      skillModifiers: { scale: 1, delivery: -1 },
-    }),
-    createTestTrack({
-      id: "forward_deployed",
-      name: "Forward Deployed",
-      skillModifiers: { delivery: 1, scale: -1 },
-    }),
-  ];
-}
-
-/**
- * Creates a set of mock disciplines.
- * @returns {object[]}
- */
-export function createTestDisciplines() {
-  return [
-    createTestDiscipline({
-      id: "software_engineering",
-      name: "Software Engineering",
-      roleTitle: "Software Engineer",
-    }),
-  ];
-}
-
-/**
- * Builds a complete mock standard (capabilities, skills, disciplines, tracks,
- * drivers, behaviours, levels) with sensible defaults. Per-slice overrides
- * replace the default for that slice entirely.
- *
- * @param {object} [overrides]
- * @param {object[]} [overrides.capabilities]
- * @param {object[]} [overrides.skills]
- * @param {object[]} [overrides.disciplines]
- * @param {object[]} [overrides.tracks]
- * @param {object[]} [overrides.drivers]
- * @param {object[]} [overrides.behaviours]
- * @param {object[]} [overrides.levels]
- * @returns {object} Agent-aligned engineering standard with all slices populated.
- */
-export function createTestStandard(overrides = {}) {
-  return {
-    capabilities: overrides.capabilities ?? createTestCapabilities(),
-    skills: overrides.skills ?? createTestSkills(),
-    disciplines: overrides.disciplines ?? createTestDisciplines(),
-    tracks: overrides.tracks ?? createTestTracks(),
-    drivers: overrides.drivers ?? createTestDrivers(),
-    behaviours: overrides.behaviours ?? createTestBehaviours(),
-    levels: overrides.levels ?? createTestLevels(),
-  };
-}
-
-/**
- * Creates a mock person (activity layer / people roster entry).
- * @param {object} [overrides]
- * @returns {object}
- */
-export function createTestPerson(overrides = {}) {
-  return {
-    id: "p-alice",
-    name: "Alice",
-    email: "alice@example.com",
-    level: "mid",
-    discipline: "software_engineering",
-    track: "platform",
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock roster (team snapshot).
- * @param {object} [overrides]
- * @returns {object}
- */
-export function createTestRoster(overrides = {}) {
-  return {
-    team: "t-alpha",
-    members: [createTestPerson()],
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock evidence row shared across map and landmark tests.
- * @param {object} [overrides]
- * @returns {object}
- */
-export function createTestEvidenceRow(overrides = {}) {
-  return {
-    skill_id: "coding",
-    level_id: "mid",
-    matched: true,
-    artifact_id: "art-1",
-    created_at: "2026-01-01T00:00:00Z",
-    github_artifacts: [],
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock skill augmented with per-level markers (human + agent arrays).
- * @param {object} [overrides]
- * @returns {object}
- */
-export function createTestSkillWithMarkers(overrides = {}) {
-  return {
-    ...createTestSkill(),
-    markers: {
-      foundational: { human: ["writes simple code"], agent: [] },
-      working: { human: ["owns features"], agent: ["reviews PRs"] },
-      practitioner: { human: ["mentors peers"], agent: [] },
-      expert: { human: ["shapes strategy"], agent: [] },
-    },
-    ...overrides,
-  };
-}

package/src/fixture/services.js

@@ -1,56 +0,0 @@
-/**
- * Test fixture utilities for creating dynamic test data
- */
-
-/**
- * Creates sample request data for testing
- * @param {object} overrides - Properties to override
- * @returns {object} Test request object
- */
-export function createTestRequest(overrides = {}) {
-  return {
-    query: "test query",
-    userId: "test-user-123",
-    sessionId: "test-session-456",
-    ...overrides,
-  };
-}
-
-/**
- * Creates sample vector data for testing
- * @param {number} count - Number of vectors to create
- * @returns {Array} Array of test vectors
- */
-export function createTestVectors(count = 3) {
-  return Array.from({ length: count }, (_, i) => ({
-    id: `vector-${i}`,
-    embedding: Array.from({ length: 384 }, () => Math.random()),
-    score: Math.random(),
-  }));
-}
-
-/**
- * Creates sample message data for testing
- * @param {number} count - Number of messages to create
- * @returns {Array} Array of test messages
- */
-export function createTestMessages(count = 3) {
-  const roles = ["system", "user", "assistant"];
-  return Array.from({ length: count }, (_, i) => ({
-    role: roles[i % 3],
-    content: `Test message ${i + 1}`,
-  }));
-}
-
-/**
- * Creates sample chunk data for testing
- * @param {number} count - Number of chunks to create
- * @returns {Array} Array of test chunks
- */
-export function createTestChunks(count = 3) {
-  return Array.from({ length: count }, (_, i) => ({
-    id: `chunk-${i}`,
-    text: `This is test chunk ${i + 1} with sample content.`,
-    tokens: Math.floor(Math.random() * 100) + 10,
-  }));
-}

package/src/mock/clients.js

@@ -1,135 +0,0 @@
-import { spy } from "./spy.js";
-import { common } from "@forwardimpact/libtype";
-
-/**
- * Creates a mock memory client
- * @param {object} overrides - Method overrides
- * @returns {object} Mock memory client
- */
-export function createMockMemoryClient(overrides = {}) {
-  return {
-    GetWindow: spy(() =>
-      Promise.resolve({
-        messages: [{ role: "system", content: "You are an assistant" }],
-        tools: [],
-      }),
-    ),
-    AppendMemory: spy(() => Promise.resolve({ accepted: "test-id" })),
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock LLM client
- * @param {object} overrides - Method overrides
- * @returns {object} Mock LLM client
- */
-export function createMockLlmClient(overrides = {}) {
-  return {
-    CreateCompletions: spy(() =>
-      Promise.resolve({
-        id: "test-completion",
-        choices: [
-          {
-            message: common.Message.fromObject({
-              role: "assistant",
-              content: "Test response",
-            }),
-          },
-        ],
-        usage: { total_tokens: 100 },
-      }),
-    ),
-    CreateEmbeddings: spy(() =>
-      Promise.resolve({
-        data: [{ index: 0, embedding: [0.1, 0.2, 0.3] }],
-      }),
-    ),
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock agent client
- * @param {object} overrides - Method overrides
- * @returns {object} Mock agent client
- */
-export function createMockAgentClient(overrides = {}) {
-  return {
-    ProcessUnary: spy(() =>
-      Promise.resolve({
-        resource_id: "test-conversation",
-        choices: [
-          {
-            message: common.Message.fromObject({
-              role: "assistant",
-              content: "Test response",
-            }),
-          },
-        ],
-      }),
-    ),
-    ProcessStream: spy(),
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock trace client
- * @param {object} overrides - Method overrides
- * @returns {object} Mock trace client
- */
-export function createMockTraceClient(overrides = {}) {
-  return {
-    RecordSpan: spy(() => Promise.resolve()),
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock vector client
- * @param {object} overrides - Method overrides
- * @returns {object} Mock vector client
- */
-export function createMockVectorClient(overrides = {}) {
-  return {
-    SearchContent: spy(() =>
-      Promise.resolve({
-        identifiers: [],
-      }),
-    ),
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock graph client
- * @param {object} overrides - Method overrides
- * @returns {object} Mock graph client
- */
-export function createMockGraphClient(overrides = {}) {
-  return {
-    QueryByPattern: spy(() =>
-      Promise.resolve({
-        identifiers: [],
-      }),
-    ),
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock tool client
- * @param {object} overrides - Method overrides
- * @returns {object} Mock tool client
- */
-export function createMockToolClient(overrides = {}) {
-  return {
-    CallTool: spy(() =>
-      Promise.resolve({
-        content: "Tool result",
-      }),
-    ),
-    ...overrides,
-  };
-}

package/src/mock/config.js

@@ -1,45 +0,0 @@
-/**
- * Creates a mock configuration object
- * @param {string} name - Service/extension name
- * @param {object} overrides - Properties to override
- * @returns {object} Mock config
- */
-export function createMockConfig(name = "test-service", overrides = {}) {
-  return {
-    name,
-    namespace: "test",
-    host: "0.0.0.0",
-    port: 3000,
-    max_tokens: 4096,
-    ...overrides,
-  };
-}
-
-/**
- * Creates a mock service config with common service properties
- * @param {string} name - Service name
- * @param {object} overrides - Properties to override
- * @returns {object} Mock service config
- */
-export function createMockServiceConfig(name, overrides = {}) {
-  return createMockConfig(name, {
-    budget: 1000,
-    threshold: 0.3,
-    limit: 10,
-    ...overrides,
-  });
-}
-
-/**
- * Creates a mock extension config
- * @param {string} name - Extension name
- * @param {object} overrides - Properties to override
- * @returns {object} Mock extension config
- */
-export function createMockExtensionConfig(name, overrides = {}) {
-  return createMockConfig(name, {
-    secret: "test-secret",
-    anthropicToken: async () => "test-anthropic-key",
-    ...overrides,
-  });
-}