@harness-engineering/cli 1.23.1 → 1.24.0

package/dist/chunk-5LMZA5LZ.js

@@ -0,0 +1,38 @@
+// ../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"
+];
+var SESSION_SECTION_NAMES = [
+  "terminology",
+  "decisions",
+  "constraints",
+  "risks",
+  "openQuestions",
+  "evidence"
+];
+
+export {
+  Ok,
+  Err,
+  isOk,
+  isErr,
+  STANDARD_COGNITIVE_MODES,
+  SESSION_SECTION_NAMES
+};

package/dist/chunk-6B6UN6SG.js

@@ -0,0 +1,112 @@
+// src/utils/paths.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+function findUpFrom(startDir, targetName, marker, maxLevels) {
+  let dir = startDir;
+  for (let i = 0; i < maxLevels; i++) {
+    const candidate = path.join(dir, targetName);
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+      if (fs.existsSync(path.join(candidate, marker))) {
+        return candidate;
+      }
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+function findUpDir(targetName, marker, maxLevels = 8) {
+  const fromModule = findUpFrom(__dirname, targetName, marker, maxLevels);
+  if (fromModule) return fromModule;
+  return findUpFrom(process.cwd(), targetName, marker, maxLevels);
+}
+function resolveTemplatesDir() {
+  return findUpDir("templates", "base") ?? path.join(__dirname, "templates");
+}
+function resolvePersonasDir() {
+  const agentsDir = findUpDir("agents", "personas");
+  if (agentsDir) {
+    return path.join(agentsDir, "personas");
+  }
+  return path.join(__dirname, "agents", "personas");
+}
+function resolveSkillsDir() {
+  const agentsDir = findUpDir("agents", "skills");
+  if (agentsDir) {
+    return path.join(agentsDir, "skills", "claude-code");
+  }
+  return path.join(__dirname, "agents", "skills", "claude-code");
+}
+function resolveProjectSkillsDir(cwd) {
+  let dir = cwd ?? process.cwd();
+  for (let i = 0; i < 8; i++) {
+    const candidate = path.join(dir, "agents", "skills", "claude-code");
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+      const agentsDir = path.join(dir, "agents");
+      if (fs.existsSync(path.join(agentsDir, "skills"))) {
+        return candidate;
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function resolveGlobalSkillsDir() {
+  const agentsDir = findUpDir("agents", "skills");
+  if (agentsDir) {
+    return path.join(agentsDir, "skills", "claude-code");
+  }
+  return path.join(__dirname, "agents", "skills", "claude-code");
+}
+function resolveCommunitySkillsDir(platform = "claude-code") {
+  const agentsDir = findUpDir("agents", "skills");
+  if (agentsDir) {
+    return path.join(agentsDir, "skills", "community", platform);
+  }
+  return path.join(__dirname, "agents", "skills", "community", platform);
+}
+function resolveGlobalCommunitySkillsDir(platform = "claude-code") {
+  return path.join(os.homedir(), ".harness", "skills", "community", platform);
+}
+function resolveGlobalCommunityBaseDir() {
+  return path.join(os.homedir(), ".harness", "skills", "community");
+}
+function resolveAllSkillsDirs(platform = "claude-code") {
+  const dirs = [];
+  const projectDir = resolveProjectSkillsDir();
+  if (projectDir) {
+    const platformDir = path.join(path.dirname(projectDir), platform);
+    if (fs.existsSync(platformDir)) {
+      dirs.push(platformDir);
+    }
+  }
+  const communityDir = resolveCommunitySkillsDir(platform);
+  if (fs.existsSync(communityDir)) {
+    dirs.push(communityDir);
+  }
+  const globalDir = resolveGlobalSkillsDir();
+  const globalPlatformDir = path.join(path.dirname(globalDir), platform);
+  if (fs.existsSync(globalPlatformDir)) {
+    if (!dirs.some((d) => path.resolve(d) === path.resolve(globalPlatformDir))) {
+      dirs.push(globalPlatformDir);
+    }
+  }
+  return dirs;
+}
+
+export {
+  resolveTemplatesDir,
+  resolvePersonasDir,
+  resolveSkillsDir,
+  resolveProjectSkillsDir,
+  resolveGlobalSkillsDir,
+  resolveCommunitySkillsDir,
+  resolveGlobalCommunitySkillsDir,
+  resolveGlobalCommunityBaseDir,
+  resolveAllSkillsDirs
+};

package/dist/chunk-7QYO5UWW.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-M6FBUXZD.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
+};

package/dist/chunk-ANXOO2HR.js

@@ -0,0 +1,85 @@
+import {
+  resolveProjectConfig
+} from "./chunk-Q3XYV5UC.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-27IJJDWG.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-OLSOE537.js");
+    const store = await loadGraphStore(projectPath);
+    let graphDependencyData;
+    if (store) {
+      const { GraphConstraintAdapter } = await import("./dist-M6FBUXZD.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
+};