@bilalimamoglu/sift 0.2.0 → 0.2.2

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-type ProviderName = "openai-compatible";
+type ProviderName = "openai" | "openai-compatible";
 type OutputFormat = "brief" | "bullets" | "json" | "verdict";
 type ResponseMode = "text" | "json";
 type JsonResponseFormatMode = "auto" | "on" | "off";
-type PromptPolicyName = "test-status" | "audit-critical" | "diff-summary" | "build-failure" | "log-errors" | "infra-risk";
+type PromptPolicyName = "test-status" | "audit-critical" | "diff-summary" | "build-failure" | "log-errors" | "infra-risk" | "typecheck-summary" | "lint-failures";
 interface ProviderConfig {
     provider: ProviderName;
     model: string;
@@ -70,6 +70,7 @@ interface RunRequest {
     stdin: string;
     config: SiftConfig;
     dryRun?: boolean;
+    presetName?: string;
     policyName?: PromptPolicyName;
     outputContract?: string;
     fallbackJson?: unknown;
@@ -89,6 +90,7 @@ interface PreparedInput {
 
 interface ExecRequest extends Omit<RunRequest, "stdin"> {
     command?: string[];
+    failOn?: boolean;
     shellCommand?: string;
 }
 declare function runExec(request: ExecRequest): Promise<number>;

package/dist/index.js

@@ -6,19 +6,150 @@ import pc2 from "picocolors";
 // src/constants.ts
 import os from "os";
 import path from "path";
-var DEFAULT_CONFIG_SEARCH_PATHS = [
-  path.resolve(process.cwd(), "sift.config.yaml"),
-  path.resolve(process.cwd(), "sift.config.yml"),
-  path.join(os.homedir(), ".config", "sift", "config.yaml"),
-  path.join(os.homedir(), ".config", "sift", "config.yml")
-];
+function getDefaultGlobalConfigPath() {
+  return path.join(os.homedir(), ".config", "sift", "config.yaml");
+}
+function getDefaultConfigSearchPaths() {
+  return [
+    path.resolve(process.cwd(), "sift.config.yaml"),
+    path.resolve(process.cwd(), "sift.config.yml"),
+    getDefaultGlobalConfigPath(),
+    path.join(os.homedir(), ".config", "sift", "config.yml")
+  ];
+}
 var INSUFFICIENT_SIGNAL_TEXT = "Insufficient signal in the provided input.";
 var GENERIC_JSON_CONTRACT = '{"answer":string,"evidence":string[],"risks":string[]}';
 var CAPTURE_OMITTED_MARKER = "\n...[captured output omitted]...\n";
 
+// src/core/gate.ts
+var FAIL_ON_SUPPORTED_PRESETS = /* @__PURE__ */ new Set(["infra-risk", "audit-critical"]);
+function parseJson(output) {
+  try {
+    return JSON.parse(output);
+  } catch {
+    return null;
+  }
+}
+function supportsFailOnPreset(presetName) {
+  return typeof presetName === "string" && FAIL_ON_SUPPORTED_PRESETS.has(presetName);
+}
+function evaluateGate(args) {
+  const parsed = parseJson(args.output);
+  if (!parsed || typeof parsed !== "object") {
+    return { shouldFail: false };
+  }
+  if (args.presetName === "infra-risk") {
+    return {
+      shouldFail: parsed["verdict"] === "fail"
+    };
+  }
+  if (args.presetName === "audit-critical") {
+    const status = parsed["status"];
+    const vulnerabilities = parsed["vulnerabilities"];
+    return {
+      shouldFail: status === "ok" && Array.isArray(vulnerabilities) && vulnerabilities.length > 0
+    };
+  }
+  return { shouldFail: false };
+}
+
 // src/core/run.ts
 import pc from "picocolors";
 
+// src/providers/systemInstruction.ts
+var REDUCTION_SYSTEM_INSTRUCTION = "You reduce noisy command output into compact answers for agents and automation.";
+
+// src/providers/openai.ts
+function usesNativeJsonResponseFormat(mode) {
+  return mode !== "off";
+}
+function extractResponseText(payload) {
+  if (typeof payload?.output_text === "string") {
+    return payload.output_text.trim();
+  }
+  if (!Array.isArray(payload?.output)) {
+    return "";
+  }
+  return payload.output.flatMap((item) => Array.isArray(item?.content) ? item.content : []).map((item) => item?.type === "output_text" ? item.text : "").filter((text) => typeof text === "string" && text.trim().length > 0).join("").trim();
+}
+async function buildOpenAIError(response) {
+  let detail = `Provider returned HTTP ${response.status}`;
+  try {
+    const data = await response.json();
+    const message = data?.error?.message;
+    if (typeof message === "string" && message.trim().length > 0) {
+      detail = `${detail}: ${message.trim()}`;
+    }
+  } catch {
+  }
+  return new Error(detail);
+}
+var OpenAIProvider = class {
+  name = "openai";
+  baseUrl;
+  apiKey;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.apiKey = options.apiKey;
+  }
+  async generate(input) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), input.timeoutMs);
+    try {
+      const url = new URL("responses", `${this.baseUrl}/`);
+      const response = await fetch(url, {
+        method: "POST",
+        signal: controller.signal,
+        headers: {
+          "content-type": "application/json",
+          ...this.apiKey ? { authorization: `Bearer ${this.apiKey}` } : {}
+        },
+        body: JSON.stringify({
+          model: input.model,
+          instructions: REDUCTION_SYSTEM_INSTRUCTION,
+          input: input.prompt,
+          reasoning: {
+            effort: "minimal"
+          },
+          text: {
+            verbosity: "low",
+            ...input.responseMode === "json" && usesNativeJsonResponseFormat(input.jsonResponseFormat) ? {
+              format: {
+                type: "json_object"
+              }
+            } : {}
+          },
+          max_output_tokens: input.maxOutputTokens
+        })
+      });
+      if (!response.ok) {
+        throw await buildOpenAIError(response);
+      }
+      const data = await response.json();
+      const text = extractResponseText(data);
+      if (!text) {
+        throw new Error("Provider returned an empty response");
+      }
+      return {
+        text,
+        usage: data?.usage ? {
+          inputTokens: data.usage.input_tokens,
+          outputTokens: data.usage.output_tokens,
+          totalTokens: data.usage.total_tokens
+        } : void 0,
+        raw: data
+      };
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error("Provider request timed out");
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+
 // src/providers/openaiCompatible.ts
 function supportsNativeJsonResponseFormat(baseUrl, mode) {
   if (mode === "off") {
@@ -39,6 +170,18 @@ function extractMessageText(payload) {
   }
   return "";
 }
+async function buildOpenAICompatibleError(response) {
+  let detail = `Provider returned HTTP ${response.status}`;
+  try {
+    const data = await response.json();
+    const message = data?.error?.message;
+    if (typeof message === "string" && message.trim().length > 0) {
+      detail = `${detail}: ${message.trim()}`;
+    }
+  } catch {
+  }
+  return new Error(detail);
+}
 var OpenAICompatibleProvider = class {
   name = "openai-compatible";
   baseUrl;
@@ -67,7 +210,7 @@ var OpenAICompatibleProvider = class {
           messages: [
             {
               role: "system",
-              content: "You reduce noisy command output into compact answers for agents and automation."
+              content: REDUCTION_SYSTEM_INSTRUCTION
             },
             {
               role: "user",
@@ -77,7 +220,7 @@ var OpenAICompatibleProvider = class {
         })
       });
       if (!response.ok) {
-        throw new Error(`Provider returned HTTP ${response.status}`);
+        throw await buildOpenAICompatibleError(response);
       }
       const data = await response.json();
       const text = extractMessageText(data);
@@ -106,6 +249,12 @@ var OpenAICompatibleProvider = class {
 
 // src/providers/factory.ts
 function createProvider(config) {
+  if (config.provider.provider === "openai") {
+    return new OpenAIProvider({
+      baseUrl: config.provider.baseUrl,
+      apiKey: config.provider.apiKey
+    });
+  }
   if (config.provider.provider === "openai-compatible") {
     return new OpenAICompatibleProvider({
       baseUrl: config.provider.baseUrl,
@@ -231,6 +380,33 @@ var BUILT_IN_POLICIES = {
       `If there is no clear error signal, reply exactly with: ${INSUFFICIENT_SIGNAL_TEXT}`
     ]
   },
+  "typecheck-summary": {
+    name: "typecheck-summary",
+    responseMode: "text",
+    taskRules: [
+      "Return at most 5 short bullet points.",
+      "Determine whether the typecheck failed or passed.",
+      "Group repeated diagnostics into root-cause buckets instead of echoing many duplicate lines.",
+      "Mention the first concrete files, symbols, or error categories to fix when they are visible.",
+      "Prefer compiler or type-system errors over timing, progress, or summary noise.",
+      "If the output clearly indicates success, say that briefly and do not add extra bullets.",
+      `If you cannot tell whether the typecheck failed, reply exactly with: ${INSUFFICIENT_SIGNAL_TEXT}`
+    ]
+  },
+  "lint-failures": {
+    name: "lint-failures",
+    responseMode: "text",
+    taskRules: [
+      "Return at most 5 short bullet points.",
+      "Determine whether lint failed or whether there are no blocking lint failures.",
+      "Group repeated rule violations instead of listing the same rule many times.",
+      "Mention the top offending files and rule names when they are visible.",
+      "Distinguish blocking failures from warnings only when that distinction is clearly visible in the input.",
+      "Do not invent autofixability; only mention autofix or --fix support when the tool output explicitly says so.",
+      "If the output clearly indicates success or no blocking failures, say that briefly and stop.",
+      `If there is not enough evidence to determine the lint result, reply exactly with: ${INSUFFICIENT_SIGNAL_TEXT}`
+    ]
+  },
   "infra-risk": {
     name: "infra-risk",
     responseMode: "json",
@@ -800,6 +976,15 @@ function buildCommandPreview(request) {
   }
   return (request.command ?? []).join(" ");
 }
+function getExecSuccessShortcut(args) {
+  if (args.exitCode !== 0) {
+    return null;
+  }
+  if (args.presetName === "typecheck-summary" && args.capturedOutput.trim() === "") {
+    return "No type errors.";
+  }
+  return null;
+}
 async function runExec(request) {
   const hasArgvCommand = Array.isArray(request.command) && request.command.length > 0;
   const hasShellCommand = typeof request.shellCommand === "string";
@@ -864,6 +1049,7 @@ async function runExec(request) {
     throw childSpawnError;
   }
   const exitCode = normalizeChildExitCode(childStatus, childSignal);
+  const capturedOutput = capture.render();
   if (request.config.runtime.verbose) {
     process.stderr.write(
       `${pc2.dim("sift")} child_exit=${exitCode} captured_chars=${capture.getTotalChars()} capture_truncated=${capture.wasTruncated()}
@@ -871,12 +1057,34 @@ async function runExec(request) {
     );
   }
   if (!bypassed) {
+    const execSuccessShortcut = getExecSuccessShortcut({
+      presetName: request.presetName,
+      exitCode,
+      capturedOutput
+    });
+    if (execSuccessShortcut && !request.dryRun) {
+      if (request.config.runtime.verbose) {
+        process.stderr.write(
+          `${pc2.dim("sift")} exec_shortcut=${request.presetName}
+`
+        );
+      }
+      process.stdout.write(`${execSuccessShortcut}
+`);
+      return exitCode;
+    }
     const output = await runSift({
       ...request,
-      stdin: capture.render()
+      stdin: capturedOutput
     });
     process.stdout.write(`${output}
 `);
+    if (request.failOn && !request.dryRun && exitCode === 0 && supportsFailOnPreset(request.presetName) && evaluateGate({
+      presetName: request.presetName,
+      output
+    }).shouldFail) {
+      return 1;
+    }
   }
   return exitCode;
 }
@@ -884,23 +1092,23 @@ async function runExec(request) {
 // src/config/defaults.ts
 var defaultConfig = {
   provider: {
-    provider: "openai-compatible",
-    model: "gpt-4.1-mini",
+    provider: "openai",
+    model: "gpt-5-nano",
     baseUrl: "https://api.openai.com/v1",
     apiKey: "",
     jsonResponseFormat: "auto",
     timeoutMs: 2e4,
     temperature: 0.1,
-    maxOutputTokens: 220
+    maxOutputTokens: 400
   },
   input: {
     stripAnsi: true,
     redact: false,
     redactStrict: false,
-    maxCaptureChars: 25e4,
-    maxInputChars: 2e4,
-    headChars: 6e3,
-    tailChars: 6e3
+    maxCaptureChars: 4e5,
+    maxInputChars: 6e4,
+    headChars: 2e4,
+    tailChars: 2e4
   },
   runtime: {
     rawFallback: true,
@@ -934,6 +1142,16 @@ var defaultConfig = {
       format: "bullets",
       policy: "log-errors"
     },
+    "typecheck-summary": {
+      question: "Summarize the blocking typecheck failures. Group repeated errors by root cause and point to the first files or symbols to fix.",
+      format: "bullets",
+      policy: "typecheck-summary"
+    },
+    "lint-failures": {
+      question: "Summarize the blocking lint failures. Group repeated rules, highlight the top offending files, and call out only failures that matter for fixing the run.",
+      format: "bullets",
+      policy: "lint-failures"
+    },
     "infra-risk": {
       question: "Assess whether the infrastructure changes are risky and whether they look safe to apply.",
       format: "verdict",
@@ -954,7 +1172,7 @@ function findConfigPath(explicitPath) {
     }
     return resolved;
   }
-  for (const candidate of DEFAULT_CONFIG_SEARCH_PATHS) {
+  for (const candidate of getDefaultConfigSearchPaths()) {
     if (fs.existsSync(candidate)) {
       return candidate;
     }
@@ -1002,23 +1220,26 @@ function resolveCompatibleEnvName(baseUrl) {
   return match?.envName;
 }
 function resolveProviderApiKey(provider, baseUrl, env) {
-  if (env.SIFT_PROVIDER_API_KEY) {
-    return env.SIFT_PROVIDER_API_KEY;
-  }
   if (provider === "openai-compatible") {
+    if (env.SIFT_PROVIDER_API_KEY) {
+      return env.SIFT_PROVIDER_API_KEY;
+    }
     const envName2 = resolveCompatibleEnvName(baseUrl);
     return envName2 ? env[envName2] : void 0;
   }
   if (!provider) {
-    return void 0;
+    return env.SIFT_PROVIDER_API_KEY;
   }
   const envName = PROVIDER_API_KEY_ENV[provider];
-  return envName ? env[envName] : void 0;
+  if (envName && env[envName]) {
+    return env[envName];
+  }
+  return env.SIFT_PROVIDER_API_KEY;
 }
 
 // src/config/schema.ts
 import { z } from "zod";
-var providerNameSchema = z.enum(["openai-compatible"]);
+var providerNameSchema = z.enum(["openai", "openai-compatible"]);
 var outputFormatSchema = z.enum([
   "brief",
   "bullets",
@@ -1033,7 +1254,9 @@ var promptPolicyNameSchema = z.enum([
   "diff-summary",
   "build-failure",
   "log-errors",
-  "infra-risk"
+  "infra-risk",
+  "typecheck-summary",
+  "lint-failures"
 ]);
 var providerConfigSchema = z.object({
   provider: providerNameSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bilalimamoglu/sift",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Agent-first command-output reduction layer for agents, CI, and automation.",
   "type": "module",
   "bin": {