@harness-engineering/cli 1.9.0 → 1.10.0

package/dist/chunk-MDUK2J2O.js

@@ -0,0 +1,67 @@
+// src/skill/schema.ts
+import { z } from "zod";
+var SkillPhaseSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  required: z.boolean().default(true)
+});
+var SkillCliSchema = z.object({
+  command: z.string(),
+  args: z.array(
+    z.object({
+      name: z.string(),
+      description: z.string(),
+      required: z.boolean().default(false)
+    })
+  ).default([])
+});
+var SkillMcpSchema = z.object({
+  tool: z.string(),
+  input: z.record(z.string())
+});
+var SkillStateSchema = z.object({
+  persistent: z.boolean().default(false),
+  files: z.array(z.string()).default([])
+});
+var ALLOWED_TRIGGERS = [
+  "manual",
+  "on_pr",
+  "on_commit",
+  "on_new_feature",
+  "on_bug_fix",
+  "on_refactor",
+  "on_project_init",
+  "on_review",
+  "on_milestone",
+  "on_task_complete",
+  "on_doc_check"
+];
+var ALLOWED_PLATFORMS = ["claude-code", "gemini-cli"];
+var ALLOWED_COGNITIVE_MODES = [
+  "adversarial-reviewer",
+  "constructive-architect",
+  "meticulous-implementer",
+  "diagnostic-investigator",
+  "advisory-guide",
+  "meticulous-verifier"
+];
+var 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(),
+  cognitive_mode: z.string().regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, "Cognitive mode must be kebab-case").optional(),
+  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 {
+  ALLOWED_COGNITIVE_MODES,
+  SkillMetadataSchema
+};

package/dist/chunk-MHBMTPW7.js

@@ -0,0 +1,29 @@
+// ../types/dist/index.mjs
+function Ok(value) {
+  return { ok: true, value };
+}
+function Err(error) {
+  return { ok: false, error };
+}
+function isOk(result) {
+  return result.ok === true;
+}
+function isErr(result) {
+  return result.ok === false;
+}
+var STANDARD_COGNITIVE_MODES = [
+  "adversarial-reviewer",
+  "constructive-architect",
+  "meticulous-implementer",
+  "diagnostic-investigator",
+  "advisory-guide",
+  "meticulous-verifier"
+];
+
+export {
+  Ok,
+  Err,
+  isOk,
+  isErr,
+  STANDARD_COGNITIVE_MODES
+};

package/dist/chunk-MO4YQOMB.js

@@ -0,0 +1,85 @@
+import {
+  resolveProjectConfig
+} from "./chunk-K6XAPGML.js";
+import {
+  resultToMcpResponse
+} from "./chunk-IDZNPTYD.js";
+import {
+  sanitizePath
+} from "./chunk-W6Y7ZW3Y.js";
+
+// src/mcp/tools/architecture.ts
+var checkDependenciesDefinition = {
+  name: "check_dependencies",
+  description: "Validate layer boundaries and detect circular dependencies",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to project root" }
+    },
+    required: ["path"]
+  }
+};
+async function handleCheckDependencies(input) {
+  let projectPath;
+  try {
+    projectPath = sanitizePath(input.path);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+  const configResult = resolveProjectConfig(projectPath);
+  if (!configResult.ok) return resultToMcpResponse(configResult);
+  try {
+    const { validateDependencies, TypeScriptParser } = await import("./dist-PBTNVK6K.js");
+    const config = configResult.value;
+    const rawLayers = Array.isArray(config.layers) ? config.layers : [];
+    const layers = rawLayers.map((l) => ({
+      name: l.name,
+      patterns: [l.pattern],
+      allowedDependencies: l.allowedDependencies
+    }));
+    const parser = new TypeScriptParser();
+    const { loadGraphStore } = await import("./graph-loader-RLO3KRIX.js");
+    const store = await loadGraphStore(projectPath);
+    let graphDependencyData;
+    if (store) {
+      const { GraphConstraintAdapter } = await import("./dist-I7DB5VKB.js");
+      const adapter = new GraphConstraintAdapter(store);
+      const graphData = adapter.computeDependencyGraph();
+      graphDependencyData = {
+        nodes: [...graphData.nodes],
+        edges: graphData.edges.map((e) => ({ ...e }))
+      };
+    }
+    const result = await validateDependencies({
+      layers,
+      rootDir: projectPath,
+      parser,
+      ...graphDependencyData !== void 0 && { graphDependencyData }
+    });
+    return resultToMcpResponse(result);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+export {
+  checkDependenciesDefinition,
+  handleCheckDependencies
+};

package/dist/chunk-NKDM3FMH.js

@@ -0,0 +1,52 @@
+import {
+  Err,
+  Ok
+} from "./chunk-MHBMTPW7.js";
+
+// src/persona/generators/agents-md.ts
+function formatTrigger(trigger) {
+  switch (trigger.event) {
+    case "on_pr": {
+      const paths = trigger.conditions?.paths?.join(", ") ?? "all files";
+      return `On PR (${paths})`;
+    }
+    case "on_commit": {
+      const branches = trigger.conditions?.branches?.join(", ") ?? "all branches";
+      return `On commit (${branches})`;
+    }
+    case "scheduled":
+      return `Scheduled (cron: ${trigger.cron})`;
+    case "manual":
+      return "Manual";
+  }
+}
+function generateAgentsMd(persona) {
+  try {
+    const triggers = persona.triggers.map(formatTrigger).join(", ");
+    const skills = persona.skills.join(", ");
+    const commands = persona.steps.filter((s) => "command" in s).map((s) => `\`harness ${s.command}\``).join(", ");
+    const stepSkills = persona.steps.filter((s) => "skill" in s).map((s) => `\`harness skill run ${s.skill}\``).join(", ");
+    const allCommands = [commands, stepSkills].filter(Boolean).join(", ");
+    const fragment = `## ${persona.name} Agent
+
+**Role:** ${persona.role}
+
+**Triggers:** ${triggers}
+
+**Skills:** ${skills}
+
+**When this agent flags an issue:** Fix violations before merging. Run ${allCommands} locally to validate.
+`;
+    return Ok(fragment);
+  } catch (error) {
+    return Err(
+      new Error(
+        `Failed to generate AGENTS.md fragment: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+
+export {
+  generateAgentsMd
+};

package/dist/{chunk-CGSHUJES.js → chunk-NX6DSZSM.js}

@@ -1,24 +1,7 @@
-// ../types/dist/index.mjs
-function Ok(value) {
-  return { ok: true, value };
-}
-function Err(error) {
-  return { ok: false, error };
-}
-function isOk(result) {
-  return result.ok === true;
-}
-function isErr(result) {
-  return result.ok === false;
-}
-var STANDARD_COGNITIVE_MODES = [
-  "adversarial-reviewer",
-  "constructive-architect",
-  "meticulous-implementer",
-  "diagnostic-investigator",
-  "advisory-guide",
-  "meticulous-verifier"
-];
+import {
+  Err,
+  Ok
+} from "./chunk-MHBMTPW7.js";
 
 // ../core/dist/index.mjs
 import { access, constants, readFile } from "fs";
@@ -5057,6 +5040,7 @@ ${entry}`);
     } else {
       fs4.appendFileSync(learningsPath, entry);
     }
+    learningsCacheMap.delete(learningsPath);
     return Ok(void 0);
   } catch (error) {
     return Err(
@@ -5136,6 +5120,7 @@ ${entry}`);
     } else {
       fs4.appendFileSync(failuresPath, entry);
     }
+    failuresCacheMap.delete(failuresPath);
     return Ok(void 0);
   } catch (error) {
     return Err(
@@ -5203,6 +5188,7 @@ async function archiveFailures(projectPath, stream) {
       counter++;
     }
     fs4.renameSync(failuresPath, path3.join(archiveDir, archiveName));
+    failuresCacheMap.delete(failuresPath);
     return Ok(void 0);
   } catch (error) {
     return Err(
@@ -8255,11 +8241,6 @@ Run "harness update" to upgrade.`;
 var VERSION = "1.8.2";
 
 export {
-  Ok,
-  Err,
-  isOk,
-  isErr,
-  STANDARD_COGNITIVE_MODES,
   createError,
   validateFileStructure,
   validateConfig,

package/dist/chunk-OPXH4CQN.js

@@ -0,0 +1,62 @@
+// src/mcp/utils/graph-loader.ts
+import * as path from "path";
+import { stat } from "fs/promises";
+var MAX_CACHE_ENTRIES = 8;
+var cache = /* @__PURE__ */ new Map();
+var pending = /* @__PURE__ */ new Map();
+function clearGraphStoreCache() {
+  cache.clear();
+  pending.clear();
+}
+function evictIfNeeded() {
+  if (cache.size > MAX_CACHE_ENTRIES) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) cache.delete(oldest);
+  }
+}
+async function doLoadGraphStore(projectRoot) {
+  const { GraphStore } = await import("./dist-I7DB5VKB.js");
+  const graphDir = path.join(projectRoot, ".harness", "graph");
+  const store = new GraphStore();
+  const loaded = await store.load(graphDir);
+  if (!loaded) return null;
+  return store;
+}
+async function loadGraphStore(projectRoot) {
+  const graphDir = path.join(projectRoot, ".harness", "graph");
+  const graphPath = path.join(graphDir, "graph.json");
+  let mtimeMs;
+  try {
+    const stats = await stat(graphPath);
+    mtimeMs = stats.mtimeMs;
+  } catch {
+    return null;
+  }
+  const cached = cache.get(projectRoot);
+  if (cached && cached.mtimeMs === mtimeMs) {
+    return cached.store;
+  }
+  const pendingLoad = pending.get(projectRoot);
+  let promise;
+  if (pendingLoad && pendingLoad.mtimeMs === mtimeMs) {
+    promise = pendingLoad.promise;
+  } else {
+    promise = doLoadGraphStore(projectRoot);
+    pending.set(projectRoot, { promise, mtimeMs });
+  }
+  const store = await promise;
+  const currentPending = pending.get(projectRoot);
+  if (currentPending && currentPending.promise === promise) {
+    pending.delete(projectRoot);
+  }
+  if (store !== null) {
+    cache.set(projectRoot, { store, mtimeMs });
+    evictIfNeeded();
+  }
+  return store;
+}
+
+export {
+  clearGraphStoreCache,
+  loadGraphStore
+};