sentinelayer-cli 0.1.0

package/src/config/agent-dictionary.js

@@ -0,0 +1,182 @@
+const SUPPORTED_CODING_AGENT_TABLE = Object.freeze({
+  "claude-code": Object.freeze({
+    name: "Claude Code",
+    promptTarget: "claude",
+    configFile: "CLAUDE.md",
+    configDir: ".claude/",
+  }),
+  cursor: Object.freeze({
+    name: "Cursor",
+    promptTarget: "cursor",
+    configFile: ".cursorrules",
+    configDir: ".cursor/",
+  }),
+  copilot: Object.freeze({
+    name: "GitHub Copilot",
+    promptTarget: "copilot",
+    configFile: ".github/copilot-instructions.md",
+    configDir: ".github/",
+  }),
+  windsurf: Object.freeze({
+    name: "Windsurf",
+    promptTarget: "generic",
+    configFile: ".windsurfrules",
+    configDir: null,
+  }),
+  cody: Object.freeze({
+    name: "Sourcegraph Cody",
+    promptTarget: "generic",
+    configFile: ".cody/cody.json",
+    configDir: ".cody/",
+  }),
+  aider: Object.freeze({
+    name: "Aider",
+    promptTarget: "generic",
+    configFile: ".aider.conf.yml",
+    configDir: null,
+  }),
+  continue: Object.freeze({
+    name: "Continue",
+    promptTarget: "generic",
+    configFile: ".continue/config.json",
+    configDir: ".continue/",
+  }),
+  codex: Object.freeze({
+    name: "OpenAI Codex",
+    promptTarget: "codex",
+    configFile: "AGENTS.md",
+    configDir: null,
+  }),
+  bolt: Object.freeze({
+    name: "Bolt.new",
+    promptTarget: "generic",
+    configFile: null,
+    configDir: null,
+  }),
+  generic: Object.freeze({
+    name: "Other",
+    promptTarget: "generic",
+    configFile: null,
+    configDir: null,
+  }),
+});
+
+const SUPPORTED_IDE_TABLE = Object.freeze({
+  vscode: Object.freeze({
+    name: "VS Code",
+    detect: (env) =>
+      String(env.TERM_PROGRAM || "").toLowerCase().includes("vscode") &&
+      !String(env.CURSOR_TRACE_ID || "").trim(),
+  }),
+  cursor: Object.freeze({
+    name: "Cursor",
+    detect: (env) => Boolean(String(env.CURSOR_TRACE_ID || "").trim()),
+  }),
+  jetbrains: Object.freeze({
+    name: "JetBrains",
+    detect: (env) => Boolean(String(env.JETBRAINS_IDE || "").trim()),
+  }),
+  neovim: Object.freeze({
+    name: "Neovim",
+    detect: (env) => Boolean(String(env.NVIM || "").trim()),
+  }),
+  zed: Object.freeze({
+    name: "Zed",
+    detect: (env) => String(env.TERM_PROGRAM || "").trim().toLowerCase() === "zed",
+  }),
+  sublime: Object.freeze({
+    name: "Sublime Text",
+    detect: (env) => Boolean(String(env.SUBLIME_TEXT || "").trim()),
+  }),
+  vim: Object.freeze({
+    name: "Vim",
+    detect: (env) => Boolean(String(env.VIM || "").trim()),
+  }),
+  emacs: Object.freeze({
+    name: "Emacs",
+    detect: (env) => Boolean(String(env.INSIDE_EMACS || "").trim()),
+  }),
+  terminal: Object.freeze({
+    name: "Terminal",
+    detect: () => true,
+  }),
+});
+
+const IDE_DETECTION_ORDER = Object.freeze([
+  "cursor",
+  "vscode",
+  "jetbrains",
+  "neovim",
+  "zed",
+  "sublime",
+  "vim",
+  "emacs",
+  "terminal",
+]);
+
+export const DEFAULT_CODING_AGENT_ID = "generic";
+export const DEFAULT_IDE_ID = "terminal";
+
+export const SUPPORTED_CODING_AGENTS = SUPPORTED_CODING_AGENT_TABLE;
+export const SUPPORTED_IDES = SUPPORTED_IDE_TABLE;
+
+function normalizeKey(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase();
+}
+
+export function listSupportedCodingAgents() {
+  return Object.entries(SUPPORTED_CODING_AGENT_TABLE).map(([id, record]) => ({
+    id,
+    ...record,
+  }));
+}
+
+export function resolveCodingAgent(agentId = DEFAULT_CODING_AGENT_ID) {
+  const normalized = normalizeKey(agentId) || DEFAULT_CODING_AGENT_ID;
+  const record = SUPPORTED_CODING_AGENT_TABLE[normalized];
+  if (!record) {
+    throw new Error(
+      `Unsupported coding agent '${agentId}'. Use one of: ${Object.keys(SUPPORTED_CODING_AGENT_TABLE).join(", ")}`
+    );
+  }
+  return {
+    id: normalized,
+    ...record,
+  };
+}
+
+export function detectCodingAgentFromEnv(env = process.env) {
+  const explicit = normalizeKey(env.SENTINELAYER_CODING_AGENT || env.CODING_AGENT || "");
+  if (explicit && Object.prototype.hasOwnProperty.call(SUPPORTED_CODING_AGENT_TABLE, explicit)) {
+    return resolveCodingAgent(explicit);
+  }
+  if (String(env.CURSOR_TRACE_ID || "").trim()) {
+    return resolveCodingAgent("cursor");
+  }
+  return resolveCodingAgent(DEFAULT_CODING_AGENT_ID);
+}
+
+export function listSupportedIdes() {
+  return Object.entries(SUPPORTED_IDE_TABLE).map(([id, record]) => ({
+    id,
+    name: record.name,
+  }));
+}
+
+export function detectIdeFromEnv(env = process.env) {
+  for (const id of IDE_DETECTION_ORDER) {
+    const entry = SUPPORTED_IDE_TABLE[id];
+    if (entry && typeof entry.detect === "function" && entry.detect(env)) {
+      return {
+        id,
+        name: entry.name,
+      };
+    }
+  }
+  return {
+    id: DEFAULT_IDE_ID,
+    name: SUPPORTED_IDE_TABLE[DEFAULT_IDE_ID].name,
+  };
+}

package/src/config/io.js

@@ -0,0 +1,56 @@
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+import { parse, stringify } from "yaml";
+
+import { configSchema } from "./schema.js";
+
+function parseConfigObject(raw, filePath) {
+  const parsed = parse(raw);
+  if (parsed === null || parsed === undefined) {
+    return {};
+  }
+  if (typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Config at ${filePath} must be a YAML mapping/object.`);
+  }
+
+  const normalized = configSchema.safeParse(parsed);
+  if (!normalized.success) {
+    throw new Error(`Invalid config at ${filePath}: ${normalized.error.issues[0]?.message || "schema error"}`);
+  }
+
+  return normalized.data;
+}
+
+export async function readConfigFile(filePath) {
+  try {
+    const raw = await fsp.readFile(filePath, "utf-8");
+    if (!String(raw || "").trim()) {
+      return {};
+    }
+    return parseConfigObject(raw, filePath);
+  } catch (error) {
+    if (error && error.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+}
+
+export async function writeConfigFile(filePath, data) {
+  const normalized = configSchema.parse(data || {});
+  await fsp.mkdir(path.dirname(filePath), { recursive: true });
+  await fsp.writeFile(filePath, stringify(normalized), "utf-8");
+}
+
+export async function ensureConfigFile(filePath) {
+  try {
+    await fsp.access(filePath);
+  } catch (error) {
+    if (error && error.code === "ENOENT") {
+      await writeConfigFile(filePath, {});
+      return;
+    }
+    throw error;
+  }
+}

package/src/config/paths.js

@@ -0,0 +1,18 @@
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+
+export function getGlobalConfigPath({ homeDir = os.homedir() } = {}) {
+  return path.join(homeDir, ".sentinelayer", "config.yml");
+}
+
+export function getProjectConfigPath({ cwd = process.cwd() } = {}) {
+  return path.join(path.resolve(cwd), ".sentinelayer.yml");
+}
+
+export function getConfigPaths({ cwd = process.cwd(), homeDir } = {}) {
+  return {
+    global: getGlobalConfigPath({ homeDir }),
+    project: getProjectConfigPath({ cwd }),
+  };
+}

package/src/config/schema.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+
+function emptyToUndefined(value) {
+  if (value === null || value === undefined) {
+    return undefined;
+  }
+  const normalized = String(value).trim();
+  return normalized ? normalized : undefined;
+}
+
+const optionalTrimmedString = z.preprocess(emptyToUndefined, z.string().min(1)).optional();
+const optionalUrl = z.preprocess(emptyToUndefined, z.string().url()).optional();
+const optionalStringArray = z
+  .array(z.preprocess(emptyToUndefined, z.string().min(1)))
+  .optional();
+
+const alertsChannelSchema = z
+  .object({
+    type: optionalTrimmedString,
+    webhook_url: optionalTrimmedString,
+    webhookUrl: optionalTrimmedString,
+    url: optionalTrimmedString,
+    bot_token: optionalTrimmedString,
+    botToken: optionalTrimmedString,
+    chat_id: optionalTrimmedString,
+    chatId: optionalTrimmedString,
+  })
+  .passthrough();
+
+const alertsConfigSchema = z
+  .object({
+    channels: z.array(alertsChannelSchema).optional(),
+    frequency: optionalTrimmedString,
+    events: optionalStringArray,
+  })
+  .passthrough()
+  .optional();
+
+export const configSchema = z
+  .object({
+    apiUrl: optionalUrl,
+    webUrl: optionalUrl,
+    outputDir: optionalTrimmedString,
+    defaultPolicyPack: optionalTrimmedString,
+    defaultModelProvider: z.enum(["openai", "anthropic", "google"]).optional(),
+    defaultModelId: optionalTrimmedString,
+    sentinelayerToken: optionalTrimmedString,
+    openaiApiKey: optionalTrimmedString,
+    anthropicApiKey: optionalTrimmedString,
+    googleApiKey: optionalTrimmedString,
+    alerts: alertsConfigSchema,
+  })
+  .strict();
+
+export const CONFIG_KEYS = Object.freeze(Object.keys(configSchema.shape));

package/src/config/service.js

@@ -0,0 +1,184 @@
+import process from "node:process";
+import path from "node:path";
+
+import { getConfigPaths } from "./paths.js";
+import { ensureConfigFile, readConfigFile, writeConfigFile } from "./io.js";
+import { CONFIG_KEYS, configSchema } from "./schema.js";
+
+const ENV_MAPPING = Object.freeze({
+  SENTINELAYER_API_URL: "apiUrl",
+  SENTINELAYER_WEB_URL: "webUrl",
+  SENTINELAYER_TOKEN: "sentinelayerToken",
+  SENTINELAYER_POLICY_PACK: "defaultPolicyPack",
+  OPENAI_API_KEY: "openaiApiKey",
+  ANTHROPIC_API_KEY: "anthropicApiKey",
+  GOOGLE_API_KEY: "googleApiKey",
+});
+
+const WRITABLE_SCOPES = new Set(["global", "project"]);
+const LAYER_SCOPES = new Set(["global", "project", "env", "resolved"]);
+
+function normalizeKey(key) {
+  const normalized = String(key || "").trim();
+  if (!CONFIG_KEYS.includes(normalized)) {
+    throw new Error(`Unknown config key '${normalized}'. Allowed keys: ${CONFIG_KEYS.join(", ")}`);
+  }
+  return normalized;
+}
+
+function normalizeValueForKey(key, value) {
+  const payload = { [key]: value };
+  const parsed = configSchema.partial().parse(payload);
+  return parsed[key];
+}
+
+function buildEnvLayer(env) {
+  const layer = {};
+  for (const [envVar, key] of Object.entries(ENV_MAPPING)) {
+    if (envVar in env) {
+      const value = normalizeValueForKey(key, env[envVar]);
+      if (value !== undefined) {
+        layer[key] = value;
+      }
+    }
+  }
+  return layer;
+}
+
+function mergeLayers(...layers) {
+  return layers.reduce((accumulator, layer) => {
+    for (const [key, value] of Object.entries(layer || {})) {
+      if (value !== undefined) {
+        accumulator[key] = value;
+      }
+    }
+    return accumulator;
+  }, {});
+}
+
+function normalizeLayerScope(scope, { allowResolved = true } = {}) {
+  const normalized = String(scope || "resolved").trim();
+  if (!allowResolved && normalized === "resolved") {
+    throw new Error("Resolved scope is read-only. Use global or project.");
+  }
+  if (!LAYER_SCOPES.has(normalized)) {
+    throw new Error(`Invalid scope '${normalized}'. Use global, project, env, or resolved.`);
+  }
+  return normalized;
+}
+
+export async function loadConfig({ cwd = process.cwd(), env = process.env, homeDir } = {}) {
+  const paths = getConfigPaths({ cwd, homeDir });
+  const [globalConfig, projectConfig] = await Promise.all([
+    readConfigFile(paths.global),
+    readConfigFile(paths.project),
+  ]);
+
+  const envConfig = buildEnvLayer(env);
+  const resolved = configSchema.parse(mergeLayers(globalConfig, projectConfig, envConfig));
+
+  return {
+    paths,
+    layers: {
+      global: globalConfig,
+      project: projectConfig,
+      env: envConfig,
+    },
+    resolved,
+  };
+}
+
+export function getLayer(config, scope) {
+  const normalized = normalizeLayerScope(scope);
+  if (normalized === "resolved") {
+    return config.resolved;
+  }
+  return config.layers[normalized] || {};
+}
+
+export function findConfigSource(config, key) {
+  const normalizedKey = normalizeKey(key);
+  if (Object.prototype.hasOwnProperty.call(config.layers.env, normalizedKey)) {
+    return "env";
+  }
+  if (Object.prototype.hasOwnProperty.call(config.layers.project, normalizedKey)) {
+    return "project";
+  }
+  if (Object.prototype.hasOwnProperty.call(config.layers.global, normalizedKey)) {
+    return "global";
+  }
+  return null;
+}
+
+export async function setConfigValue({
+  key,
+  value,
+  scope = "project",
+  cwd = process.cwd(),
+  homeDir,
+} = {}) {
+  const normalizedScope = normalizeLayerScope(scope, { allowResolved: false });
+  if (!WRITABLE_SCOPES.has(normalizedScope)) {
+    throw new Error(`Cannot write scope '${normalizedScope}'. Use global or project.`);
+  }
+
+  const normalizedKey = normalizeKey(key);
+  const normalizedValue = normalizeValueForKey(normalizedKey, value);
+
+  const paths = getConfigPaths({ cwd, homeDir });
+  const targetPath = paths[normalizedScope];
+  const current = await readConfigFile(targetPath);
+  const next = {
+    ...current,
+    [normalizedKey]: normalizedValue,
+  };
+
+  await writeConfigFile(targetPath, next);
+
+  return {
+    scope: normalizedScope,
+    path: targetPath,
+    key: normalizedKey,
+    value: normalizedValue,
+  };
+}
+
+export async function ensureEditableConfigPath({ scope = "project", cwd = process.cwd(), homeDir } = {}) {
+  const normalizedScope = normalizeLayerScope(scope, { allowResolved: false });
+  if (!WRITABLE_SCOPES.has(normalizedScope)) {
+    throw new Error(`Cannot edit scope '${normalizedScope}'. Use global or project.`);
+  }
+
+  const paths = getConfigPaths({ cwd, homeDir });
+  const targetPath = paths[normalizedScope];
+  await ensureConfigFile(targetPath);
+
+  return {
+    scope: normalizedScope,
+    path: targetPath,
+  };
+}
+
+export function listConfigKeys() {
+  return [...CONFIG_KEYS];
+}
+
+export async function resolveOutputRoot({
+  cwd = process.cwd(),
+  outputDirOverride = "",
+  env = process.env,
+  homeDir,
+} = {}) {
+  const overrideValue = String(outputDirOverride || "").trim();
+  if (overrideValue) {
+    return path.resolve(cwd, overrideValue);
+  }
+
+  const config = await loadConfig({ cwd, env, homeDir });
+  const configuredOutputDir = String(config.resolved.outputDir || "").trim();
+  if (configuredOutputDir) {
+    return path.resolve(cwd, configuredOutputDir);
+  }
+
+  return path.resolve(cwd, ".sentinelayer");
+}