@ftarganski/omni-ai 0.1.0

package/dist/chunk-6APAA6WD.js

@@ -0,0 +1,495 @@
+// ../core/src/middleware/compose.ts
+function composeMiddleware(fns, skill) {
+  if (fns.length === 0) return skill;
+  return {
+    name: skill.name,
+    description: skill.description,
+    execute(input, ctx) {
+      let index = 0;
+      const dispatch = () => {
+        if (index < fns.length) {
+          const fn = fns[index++];
+          return fn(skill.name, input, ctx, dispatch);
+        }
+        return skill.execute(input, ctx);
+      };
+      return dispatch();
+    }
+  };
+}
+
+// ../core/src/types.ts
+function contentToString(content) {
+  if (typeof content === "string") return content;
+  return content.map((p) => p.type === "text" ? p.text : `[image:${p.mimeType}]`).join("");
+}
+
+// ../core/src/agents/agent.ts
+var Agent = class {
+  config;
+  provider;
+  skills;
+  constructor(config, provider, skills = []) {
+    this.config = config;
+    this.provider = provider;
+    this.skills = new Map(skills.map((s) => [s.name, s]));
+  }
+  async run(options) {
+    const memCfg = this.config.memory;
+    const session = options.session;
+    const store = memCfg?.store;
+    const compactor = memCfg?.compactor;
+    const maxCtxTokens = memCfg?.maxContextTokens ?? 8e4;
+    const history = session && store ? (await store.loadMessages(session)).map((e) => ({ role: e.role, content: e.content })) : [];
+    const messages = [...history];
+    const newMessages = [];
+    const firstMsg = { role: "user", content: options.input };
+    messages.push(firstMsg);
+    newMessages.push(firstMsg);
+    const tools = this.buildToolDefinitions();
+    const ctx = { provider: this.provider, config: options.context ?? {} };
+    const maxIterations = this.config.maxIterations ?? 10;
+    let iterations = 0;
+    let totalInput = 0;
+    let totalOutput = 0;
+    while (iterations < maxIterations) {
+      iterations++;
+      if (compactor?.shouldCompact(messages, maxCtxTokens)) {
+        const compacted = await compactor.compact(messages, this.provider);
+        messages.splice(0, messages.length, ...compacted);
+      }
+      const response = await this.provider.complete({
+        messages,
+        model: this.config.model,
+        systemPrompt: this.config.systemPrompt,
+        temperature: this.config.temperature,
+        tools: tools.length > 0 ? tools : void 0,
+        onToken: options.onToken
+      });
+      if (response.usage) {
+        totalInput += response.usage.inputTokens;
+        totalOutput += response.usage.outputTokens;
+      }
+      if (!response.toolCalls || response.toolCalls.length === 0) {
+        const finalMsg = { role: "assistant", content: response.content };
+        messages.push(finalMsg);
+        newMessages.push(finalMsg);
+        await this.persist(store, session, newMessages);
+        return {
+          output: response.content,
+          iterations,
+          usage: { inputTokens: totalInput, outputTokens: totalOutput }
+        };
+      }
+      const assistantMsg = { role: "assistant", content: response.content };
+      messages.push(assistantMsg);
+      newMessages.push(assistantMsg);
+      for (const call of response.toolCalls) {
+        const result = await this.executeToolCall(call, ctx);
+        const toolMsg = { role: "user", content: `[Tool ${call.name} result]: ${result}` };
+        messages.push(toolMsg);
+        newMessages.push(toolMsg);
+      }
+    }
+    await this.persist(store, session, newMessages);
+    throw new Error(`Agent "${this.config.name}" exceeded maxIterations (${maxIterations})`);
+  }
+  async persist(store, session, messages) {
+    if (!store || !session || messages.length === 0) return;
+    const entries = messages.map((m) => ({
+      role: m.role,
+      content: contentToString(m.content),
+      timestamp: Date.now()
+    }));
+    await store.saveMessages(session, entries);
+  }
+  buildToolDefinitions() {
+    return [...this.skills.values()].map((skill) => ({
+      name: skill.name,
+      description: skill.description,
+      parameters: { type: "object", properties: {}, additionalProperties: true }
+    }));
+  }
+  async executeToolCall(call, ctx) {
+    const skill = this.skills.get(call.name);
+    if (!skill) return `Error: skill "${call.name}" not found`;
+    try {
+      const middleware = this.config.middleware ?? [];
+      const wrapped = composeMiddleware(middleware, skill);
+      const result = await wrapped.execute(call.arguments, ctx);
+      return typeof result === "string" ? result : JSON.stringify(result);
+    } catch (err) {
+      return `Error: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+};
+
+// ../core/src/config/schema.ts
+import { z } from "zod";
+var RetryConfigSchema = z.object({
+  maxRetries: z.number().int().positive().default(3),
+  initialDelayMs: z.number().int().positive().default(500),
+  maxDelayMs: z.number().int().positive().default(3e4)
+});
+var ProviderConfigSchema = z.object({
+  name: z.string(),
+  type: z.enum(["anthropic", "openai", "copilot", "google", "groq", "ollama", "custom"]),
+  // nullish handles YAML empty value (parsed as null) and absent key (undefined)
+  apiKey: z.string().nullish().transform((v) => v ?? void 0),
+  baseUrl: z.string().url().nullish().transform((v) => v ?? void 0),
+  defaultModel: z.string().nullish().transform((v) => v ?? void 0),
+  options: z.record(z.unknown()).optional(),
+  retry: RetryConfigSchema.optional(),
+  fallback: z.string().optional()
+});
+var AgentConfigSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  systemPrompt: z.string(),
+  skills: z.array(z.string()).optional(),
+  maxIterations: z.number().int().positive().default(10),
+  temperature: z.number().min(0).max(2).optional()
+});
+var ScaffoldPathsSchema = z.object({
+  agents: z.string().default("agents"),
+  skills: z.string().default("src/skills"),
+  providers: z.string().default("packages")
+});
+var OmniAiConfigSchema = z.object({
+  version: z.string().default("1"),
+  providers: z.array(ProviderConfigSchema).min(1, "At least one provider must be configured"),
+  defaultProvider: z.string(),
+  agentsDir: z.string().default("agents"),
+  scaffoldPaths: ScaffoldPathsSchema.optional(),
+  agents: z.array(AgentConfigSchema).optional()
+});
+
+// ../core/src/providers/fallback.ts
+var FallbackProvider = class {
+  name;
+  capabilities;
+  providers;
+  constructor(providers) {
+    if (providers.length === 0) throw new Error("FallbackProvider requires at least one provider");
+    this.providers = providers;
+    this.name = providers.map((p) => p.name).join("|");
+    this.capabilities = providers.reduce(
+      (acc, p) => ({
+        chat: acc.chat || p.capabilities.chat,
+        embedding: acc.embedding || p.capabilities.embedding,
+        streaming: acc.streaming || p.capabilities.streaming,
+        toolUse: acc.toolUse || p.capabilities.toolUse,
+        vision: acc.vision || p.capabilities.vision
+      }),
+      { chat: false, embedding: false, streaming: false, toolUse: false, vision: false }
+    );
+  }
+  async complete(request) {
+    const errors = [];
+    for (const provider of this.providers) {
+      try {
+        return await provider.complete(request);
+      } catch (err) {
+        errors.push(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+    throw new Error(
+      `All providers failed:
+${errors.map((e, i) => `  [${this.providers[i].name}] ${e.message}`).join("\n")}`
+    );
+  }
+  async embed(request) {
+    const errors = [];
+    for (const provider of this.providers) {
+      if (!provider.embed) continue;
+      try {
+        return await provider.embed(request);
+      } catch (err) {
+        errors.push(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+    if (errors.length === 0) throw new Error(`No provider in "${this.name}" supports embeddings`);
+    throw new Error(
+      `All providers failed for embed:
+${errors.map((e, i) => `  [${this.providers[i].name}] ${e.message}`).join("\n")}`
+    );
+  }
+};
+
+// ../core/src/providers/retry.ts
+function isRetryable(err) {
+  if (!(err instanceof Error)) return false;
+  const msg = err.message.toLowerCase();
+  return msg.includes("429") || msg.includes("rate limit") || msg.includes("too many requests") || msg.includes("500") || msg.includes("502") || msg.includes("503") || msg.includes("504") || msg.includes("econnreset") || msg.includes("etimedout") || msg.includes("enotfound");
+}
+function delay(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+var RetryProvider = class {
+  name;
+  capabilities;
+  inner;
+  maxRetries;
+  initialDelayMs;
+  maxDelayMs;
+  constructor(inner, options = {}) {
+    this.inner = inner;
+    this.name = inner.name;
+    this.capabilities = inner.capabilities;
+    this.maxRetries = options.maxRetries ?? 3;
+    this.initialDelayMs = options.initialDelayMs ?? 500;
+    this.maxDelayMs = options.maxDelayMs ?? 3e4;
+  }
+  async complete(request) {
+    return this.withRetry(() => this.inner.complete(request));
+  }
+  async embed(request) {
+    const embedFn = this.inner.embed;
+    if (!embedFn) throw new Error(`Provider "${this.name}" does not support embeddings`);
+    return this.withRetry(() => embedFn.call(this.inner, request));
+  }
+  async withRetry(fn) {
+    let attempt = 0;
+    while (true) {
+      try {
+        return await fn();
+      } catch (err) {
+        attempt++;
+        if (attempt > this.maxRetries || !isRetryable(err)) throw err;
+        const base = this.initialDelayMs * 2 ** (attempt - 1);
+        const jitter = Math.random() * base * 0.2;
+        const wait = Math.min(base + jitter, this.maxDelayMs);
+        await delay(wait);
+      }
+    }
+  }
+};
+
+// ../core/src/providers/registry.ts
+var factories = /* @__PURE__ */ new Map();
+function registerProvider(type, factory) {
+  factories.set(type, factory);
+}
+function createProvider(config) {
+  const factory = factories.get(config.type);
+  if (!factory) {
+    throw new Error(`Unknown provider type "${config.type}". Registered: ${[...factories.keys()].join(", ")}`);
+  }
+  return factory(config);
+}
+function buildProvider(cfg, allConfigs) {
+  let provider = createProvider(cfg);
+  if (cfg.retry) {
+    provider = new RetryProvider(provider, cfg.retry);
+  }
+  if (cfg.fallback) {
+    const fallbackCfg = allConfigs.find((p) => p.name === cfg.fallback);
+    if (!fallbackCfg) {
+      throw new Error(`Fallback provider "${cfg.fallback}" not found in config for provider "${cfg.name}"`);
+    }
+    let fallbackProvider = createProvider(fallbackCfg);
+    if (fallbackCfg.retry) {
+      fallbackProvider = new RetryProvider(fallbackProvider, fallbackCfg.retry);
+    }
+    provider = new FallbackProvider([provider, fallbackProvider]);
+  }
+  return provider;
+}
+function getRegisteredProviders() {
+  return [...factories.keys()];
+}
+
+// ../core/src/agents/loader.ts
+import { readFile } from "fs/promises";
+import YAML from "yaml";
+async function loadAgent(yamlPath, config, skills) {
+  const raw = await readFile(yamlPath, "utf-8");
+  const data = YAML.parse(raw);
+  const agentConfig = AgentConfigSchema.parse(data);
+  const providerName = agentConfig.provider ?? config.defaultProvider;
+  const providerConfig = config.providers.find((p) => p.name === providerName);
+  if (!providerConfig) {
+    throw new Error(
+      `Provider "${providerName}" not found in config. Available: ${config.providers.map((p) => p.name).join(", ")}`
+    );
+  }
+  const provider = buildProvider(providerConfig, config.providers);
+  const resolvedSkills = (agentConfig.skills ?? []).map((name) => skills.get(name));
+  return new Agent(agentConfig, provider, resolvedSkills);
+}
+
+// ../core/src/config/loader.ts
+import { readFile as readFile2 } from "fs/promises";
+import { resolve } from "path";
+import YAML2 from "yaml";
+import { ZodError } from "zod";
+function substituteEnvVars(text) {
+  return text.replace(/\$\{([^}]+)\}/g, (_, name) => process.env[name] ?? "");
+}
+function formatZodError(err) {
+  const lines = err.errors.map((e) => `  \u2022 ${e.path.join(".")}: ${e.message}`);
+  return `Invalid omni-ai.yaml configuration:
+${lines.join("\n")}`;
+}
+async function loadConfig(configPath) {
+  const filePath = configPath ?? resolve(process.cwd(), "config", "omni-ai.yaml");
+  const raw = await readFile2(filePath, "utf-8");
+  const substituted = substituteEnvVars(raw);
+  const data = YAML2.parse(substituted);
+  try {
+    return OmniAiConfigSchema.parse(data);
+  } catch (err) {
+    if (err instanceof ZodError) {
+      throw new Error(formatZodError(err));
+    }
+    throw err;
+  }
+}
+
+// ../core/src/skills/registry.ts
+var SkillRegistry = class {
+  skills = /* @__PURE__ */ new Map();
+  register(skill) {
+    this.skills.set(skill.name, skill);
+    return this;
+  }
+  get(name) {
+    const skill = this.skills.get(name);
+    if (!skill) {
+      throw new Error(`Skill "${name}" not found. Available: ${[...this.skills.keys()].join(", ")}`);
+    }
+    return skill;
+  }
+  all() {
+    return [...this.skills.values()];
+  }
+};
+
+// ../core/src/bootstrap.ts
+import { readFile as readFile3 } from "fs/promises";
+import { dirname, resolve as resolve2 } from "path";
+import { glob } from "glob";
+import YAML3 from "yaml";
+async function createRuntime(options) {
+  const config = await loadConfig(options?.configPath);
+  const skills = new SkillRegistry();
+  for (const skill of options?.skills ?? []) {
+    skills.register(skill);
+  }
+  const configDir = options?.configPath ? dirname(resolve2(options.configPath)) : resolve2(process.cwd(), "config");
+  const agentsBaseDir = resolve2(configDir, "..", config.agentsDir);
+  async function resolveAgent(nameOrPath) {
+    if (nameOrPath.includes("/") || nameOrPath.endsWith(".yaml")) {
+      return loadAgent(resolve2(nameOrPath), config, skills);
+    }
+    const inlineCfg = config.agents?.find((a) => a.name === nameOrPath);
+    if (inlineCfg) {
+      const providerName = inlineCfg.provider ?? config.defaultProvider;
+      const providerConfig = config.providers.find((p) => p.name === providerName);
+      if (!providerConfig) {
+        throw new Error(`Provider "${providerName}" not found in config for agent "${nameOrPath}"`);
+      }
+      const provider = buildProvider(providerConfig, config.providers);
+      const resolvedSkills = (inlineCfg.skills ?? []).map((n) => skills.get(n));
+      return new Agent(inlineCfg, provider, resolvedSkills);
+    }
+    const files = await glob("**/*.yaml", { cwd: agentsBaseDir, absolute: true });
+    for (const file of files) {
+      const raw = await readFile3(file, "utf-8");
+      const data = YAML3.parse(raw);
+      if (data?.name === nameOrPath) return loadAgent(file, config, skills);
+    }
+    throw new Error(`Agent "${nameOrPath}" not found in ${agentsBaseDir}`);
+  }
+  return {
+    config,
+    skills,
+    async run(nameOrPath, input, opts = {}) {
+      const agent = await resolveAgent(nameOrPath);
+      if (options?.memoryStore && opts.session && !agent.config.memory?.store) {
+        agent.config.memory = {
+          ...agent.config.memory ?? {},
+          store: options.memoryStore
+        };
+      }
+      return agent.run({ ...opts, input });
+    },
+    async listAgents(agentsDir) {
+      const summaries = [];
+      for (const a of config.agents ?? []) {
+        summaries.push({ name: a.name, description: a.description, path: "(config)" });
+      }
+      const dir = agentsDir ?? agentsBaseDir;
+      const files = await glob("**/*.yaml", { cwd: dir, absolute: true });
+      for (const file of files) {
+        try {
+          const raw = await readFile3(file, "utf-8");
+          const data = YAML3.parse(raw);
+          if (data?.name && !summaries.find((s) => s.name === data.name)) {
+            summaries.push({ name: data.name, description: data.description ?? "", path: file });
+          }
+        } catch {
+        }
+      }
+      return summaries.sort((a, b) => a.name.localeCompare(b.name));
+    }
+  };
+}
+
+// ../core/src/parallel.ts
+async function parallel(runtime, opts) {
+  const runOpts = {
+    session: opts.session
+  };
+  const settled = await Promise.allSettled(
+    opts.agents.map((name) => {
+      const agentOpts = {
+        ...runOpts,
+        input: opts.input,
+        ...opts.onToken ? { onToken: (chunk) => opts.onToken?.(name, chunk) } : {}
+      };
+      return runtime.run(name, opts.input, agentOpts);
+    })
+  );
+  const results = {};
+  let totalInput = 0;
+  let totalOutput = 0;
+  for (let i = 0; i < opts.agents.length; i++) {
+    const name = opts.agents[i];
+    const outcome = settled[i];
+    if (outcome.status === "fulfilled") {
+      results[name] = outcome.value;
+      totalInput += outcome.value.usage?.inputTokens ?? 0;
+      totalOutput += outcome.value.usage?.outputTokens ?? 0;
+    } else {
+      results[name] = {
+        error: outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason)
+      };
+    }
+  }
+  return { results, usage: { inputTokens: totalInput, outputTokens: totalOutput } };
+}
+
+export {
+  composeMiddleware,
+  contentToString,
+  Agent,
+  RetryConfigSchema,
+  ProviderConfigSchema,
+  AgentConfigSchema,
+  ScaffoldPathsSchema,
+  OmniAiConfigSchema,
+  FallbackProvider,
+  RetryProvider,
+  registerProvider,
+  createProvider,
+  buildProvider,
+  getRegisteredProviders,
+  loadAgent,
+  loadConfig,
+  SkillRegistry,
+  createRuntime,
+  parallel
+};

package/dist/chunk-6OPRALDC.js

@@ -0,0 +1,163 @@
+// ../skills/src/git/git-commit-message.ts
+import { resolve } from "path";
+import { z } from "zod";
+
+// ../skills/src/git/shared.ts
+import { spawn } from "child_process";
+function runGit(args, cwd) {
+  return new Promise((resolve5, reject) => {
+    const proc = spawn("git", args, { cwd, shell: false });
+    const stdout = [];
+    const stderr = [];
+    proc.stdout.on("data", (chunk) => stdout.push(chunk));
+    proc.stderr.on("data", (chunk) => stderr.push(chunk));
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(Buffer.concat(stderr).toString().trim() || `git ${args[0]} exited with code ${code}`));
+      } else {
+        resolve5(Buffer.concat(stdout).toString());
+      }
+    });
+    proc.on("error", reject);
+  });
+}
+
+// ../skills/src/git/git-commit-message.ts
+var InputSchema = z.object({
+  cwd: z.string().default(".").describe("Repository root directory"),
+  staged: z.boolean().default(true).describe("Use staged diff (true) or full working-tree diff (false)"),
+  hint: z.string().optional().describe("Optional free-text hint passed to the LLM, e.g. 'fix', 'feat', 'refactor'")
+});
+var SYSTEM = `You are an expert software engineer who writes concise, conventional commit messages.
+Rules:
+- Follow Conventional Commits: <type>(<scope>): <subject>
+- Subject line \u2264 72 chars, imperative mood, no trailing period
+- If changes span multiple concerns, add a short bullet body after a blank line
+- Output ONLY the commit message \u2014 no explanation, no markdown fences`;
+var gitCommitMessageSkill = {
+  name: "git-commit-message",
+  description: "Generate a conventional commit message for the current staged (or working-tree) changes using the configured LLM provider. Returns a ready-to-use commit message string.",
+  async execute(input, ctx) {
+    const { cwd, staged, hint } = InputSchema.parse(input);
+    const dir = resolve(cwd);
+    const diffArgs = ["diff"];
+    if (staged) diffArgs.push("--cached");
+    const diff = await runGit(diffArgs, dir);
+    if (!diff.trim()) {
+      return { message: "chore: no changes staged" };
+    }
+    const promptParts = [hint ? `Hint from the developer: ${hint}` : null, "--- GIT DIFF ---", diff.slice(0, 12e3)].filter(Boolean).join("\n");
+    const response = await ctx.provider.complete({
+      systemPrompt: SYSTEM,
+      messages: [{ role: "user", content: promptParts }],
+      temperature: 0.2,
+      maxTokens: 256
+    });
+    return { message: response.content.trim() };
+  }
+};
+
+// ../skills/src/git/git-diff.ts
+import { resolve as resolve2 } from "path";
+import { z as z2 } from "zod";
+var InputSchema2 = z2.object({
+  cwd: z2.string().default(".").describe("Repository root directory"),
+  staged: z2.boolean().default(false).describe("Show staged (cached) diff instead of working-tree diff"),
+  file: z2.string().optional().describe("Limit diff to a specific file path"),
+  base: z2.string().optional().describe("Base ref to diff from (e.g. 'main', 'HEAD~1')")
+});
+var gitDiffSkill = {
+  name: "git-diff",
+  description: "Return the unified diff of uncommitted changes (or staged changes). Use this to understand what code changed before writing a commit message or performing a code review.",
+  async execute(input) {
+    const { cwd, staged, file, base } = InputSchema2.parse(input);
+    const dir = resolve2(cwd);
+    const diffArgs = ["diff"];
+    if (staged) diffArgs.push("--cached");
+    if (base) diffArgs.push(base);
+    if (file) diffArgs.push("--", file);
+    const nameArgs = ["diff", "--name-only"];
+    if (staged) nameArgs.push("--cached");
+    if (base) nameArgs.push(base);
+    if (file) nameArgs.push("--", file);
+    const [diff, names] = await Promise.all([runGit(diffArgs, dir), runGit(nameArgs, dir)]);
+    const changedFiles = names.split("\n").map((l) => l.trim()).filter(Boolean);
+    return { diff, changedFiles };
+  }
+};
+
+// ../skills/src/git/git-log.ts
+import { resolve as resolve3 } from "path";
+import { z as z3 } from "zod";
+var InputSchema3 = z3.object({
+  cwd: z3.string().default(".").describe("Repository root directory"),
+  maxEntries: z3.number().int().positive().default(10).describe("Maximum number of commits to return"),
+  branch: z3.string().optional().describe("Branch or ref to read log from (defaults to HEAD)"),
+  since: z3.string().optional().describe("Show commits more recent than this date, e.g. '2 weeks ago'")
+});
+var SEP = "";
+var FORMAT = [`%H${SEP}%h${SEP}%an${SEP}%ai${SEP}%s`].join("");
+var gitLogSkill = {
+  name: "git-log",
+  description: "Return recent commit history with hash, author, date and subject. Use this to understand recent changes, find the last stable commit, or generate release notes.",
+  async execute(input) {
+    const { cwd, maxEntries, branch, since } = InputSchema3.parse(input);
+    const dir = resolve3(cwd);
+    const args = ["log", `--format=${FORMAT}`, `-n`, String(maxEntries)];
+    if (since) args.push(`--since=${since}`);
+    if (branch) args.push(branch);
+    const raw = await runGit(args, dir);
+    const commits = raw.split("\n").filter(Boolean).map((line) => {
+      const [hash, shortHash, author, date, ...rest] = line.split(SEP);
+      return { hash, shortHash, author, date, message: rest.join(SEP) };
+    });
+    return { commits };
+  }
+};
+
+// ../skills/src/git/git-status.ts
+import { resolve as resolve4 } from "path";
+import { z as z4 } from "zod";
+var InputSchema4 = z4.object({
+  cwd: z4.string().default(".").describe("Repository root directory (defaults to process.cwd())")
+});
+function parsePorcelain(raw) {
+  const staged = [];
+  const unstaged = [];
+  const untracked = [];
+  for (const line of raw.split("\n")) {
+    if (!line || line.startsWith("##")) continue;
+    const x = line[0];
+    const y = line[1];
+    const path = line.slice(3);
+    if (x === "?" && y === "?") {
+      untracked.push(path);
+    } else {
+      if (x !== " " && x !== "?") staged.push({ path, status: x });
+      if (y !== " " && y !== "?") unstaged.push({ path, status: y });
+    }
+  }
+  return { staged, unstaged, untracked };
+}
+var gitStatusSkill = {
+  name: "git-status",
+  description: "Return the current git working-tree status: staged changes, unstaged modifications, untracked files and the active branch. Use this before generating a commit message or reviewing pending changes.",
+  async execute(input) {
+    const { cwd } = InputSchema4.parse(input);
+    const dir = resolve4(cwd);
+    const [porcelain, branchRaw] = await Promise.all([
+      runGit(["status", "--porcelain", "-b"], dir),
+      runGit(["rev-parse", "--abbrev-ref", "HEAD"], dir)
+    ]);
+    const branch = branchRaw.trim();
+    const { staged, unstaged, untracked } = parsePorcelain(porcelain);
+    return { branch, staged, unstaged, untracked };
+  }
+};
+
+export {
+  gitCommitMessageSkill,
+  gitDiffSkill,
+  gitLogSkill,
+  gitStatusSkill
+};