gityo 0.0.0 → 1.0.1

package/README.md

@@ -1,6 +1,6 @@
 # gityo
 
-`gityo` is a CLI that helps you stage changes, write or generate a commit message, commit, and optionally run a post-commit git action.
+`gityo` is a CLI that writes or generates a commit message for your changes, stages them, creates the commit, and optionally runs a post-commit git action.
 
 It is built for people who want a faster commit flow without turning git into a wall of commands.
 
@@ -18,9 +18,8 @@ npx gityo
 
 ## What it does
 
-- lets you choose which changed files to stage
-- lets you write your own commit message
-- can generate a commit message with AI
+- writes or generates a commit message based on your current git state
+- stages everything when nothing is staged yet
 - creates the commit for you
 - can run a post-commit action like `git push`
 
@@ -34,48 +33,87 @@ gityo
 
 Typical flow:
 
-1. Pick files to stage
-2. Type a commit message or generate one
+1. Write a commit message or generate one (from staged files if any, otherwise all changes)
+2. Stage everything if nothing is staged
 3. Create the commit
 4. Optionally run the configured post-commit action
 
+If you already staged files before running `gityo`, only those are used for the message and committed — your other changes are left alone.
+
 ## Common commands
 
 ```bash
 gityo
-gityo --stage
 gityo --generate
+gityo --model fast --generate
 gityo --message "fix login redirect bug"
 gityo --yolo
 ```
 
 ## AI setup
 
-If you want AI-generated commit messages, set a model once and reuse it:
+A configured model is required — gityo won't run without one, and the API key must be resolvable from your environment even when you pass `--message`. Models live in a `models` map in your config file. Each key is a name you can pick with `--model`; the `default` key is used when you don't pass `--model`:
 
-```bash
-gityo config set model openai gpt-4.1 YOUR_API_KEY
+```json
+{
+  "$schema": "https://github.com/NazmusSayad/gityo/raw/refs/heads/schema/schema.json",
+  "models": {
+    "default": {
+      "npm": "@openrouter/ai-sdk-provider",
+      "apiKeyEnv": "OPENROUTER_API_KEY",
+      "model": "deepseek/deepseek-chat"
+    },
+    "fast": {
+      "npm": "@ai-sdk/openai",
+      "apiKeyEnv": "OPENAI_API_KEY",
+      "model": "gpt-4.1-mini"
+    }
+  }
+}
+```
+
+Each model config:
+
+- `npm` — the provider package, one of 30 supported AI SDK providers (autocompleted by the schema). Optional; defaults to `@ai-sdk/openai-compatible`
+- `apiKeyEnv` — environment variable(s) holding the API key, tried in order
+- `model` — the model ID
+- `apiUrl` — optional base URL (required when `npm` is `@ai-sdk/openai-compatible`)
+- `options` — extra provider options passed to the provider factory
+
+`apiKeyEnv` accepts a single variable name or an array of names:
+
+```json
+"apiKeyEnv": ["GITYO_API_KEY", "OPENROUTER_API_KEY"]
+```
+
+OpenAI-compatible example without `npm`:
+
+```json
+"local": {
+  "apiKeyEnv": "MY_API_KEY",
+  "model": "my-model",
+  "apiUrl": "https://my-endpoint.example.com/v1"
+}
 ```
 
 Then use:
 
 ```bash
 gityo --generate
+gityo --model fast --generate
 ```
 
-Supported providers include OpenAI, Anthropic, Google, OpenRouter, and compatible custom endpoints.
+Providers are the official Vercel AI SDK packages: `@ai-sdk/openai`, `@ai-sdk/openai-compatible`, `@ai-sdk/anthropic`, `@ai-sdk/google`, `@ai-sdk/xai`, `@ai-sdk/azure`, `@ai-sdk/amazon-bedrock`, `@ai-sdk/groq`, `@ai-sdk/mistral`, `@ai-sdk/deepseek`, `@ai-sdk/togetherai`, `@ai-sdk/fireworks`, `@ai-sdk/perplexity`, `@ai-sdk/cohere`, `@ai-sdk/cerebras`, `@ai-sdk/luma`, `@ai-sdk/fal`, `@ai-sdk/deepinfra`, `@ai-sdk/google-vertex`, `@openrouter/ai-sdk-provider`, plus `ai-sdk-ollama`, `ollama-ai-provider-v2`, `workers-ai-provider`, `zhipu-ai-provider`, `sambanova-ai-provider`, `vercel-minimax-ai-provider`, `@aihubmix/ai-sdk-provider`, `ai-gateway-provider`, `@friendliai/ai-provider`, `@helicone/ai-sdk-provider`, and `ai-sdk-provider-opencode-sdk`.
 
 ## Config
 
-View your current config:
+Show where your config files live:
 
 ```bash
 gityo config
 ```
 
-You can also write config manually.
-
-Project config goes in:
+Config is edited by hand in a JSON file. Project config goes in:
 
 ```text
 .gityo.config.json
@@ -95,7 +133,7 @@ You can also add repo-specific writing instructions in:
 
 That file is useful when you want commit messages in a certain tone or format for one project.
 
-If you want editor autocomplete and validation, use this schema:
+Set `$schema` in your config file for editor autocomplete and validation:
 
 ```text
 https://github.com/NazmusSayad/gityo/raw/refs/heads/schema/schema.json
@@ -106,9 +144,12 @@ Example:
 ```json
 {
   "$schema": "https://github.com/NazmusSayad/gityo/raw/refs/heads/schema/schema.json",
-  "model": {
-    "provider": "openai",
-    "name": "gpt-4.1"
+  "models": {
+    "default": {
+      "npm": "@ai-sdk/openai",
+      "apiKeyEnv": "OPENAI_API_KEY",
+      "model": "gpt-4.1"
+    }
   },
   "autoAcceptMessage": false,
   "postCommand": "push",
@@ -131,14 +172,6 @@ Priority is simple:
 - `.gityo.config.json` for project config
 - `~/.config/gityo.json` for your defaults
 
-A few useful examples:
-
-```bash
-gityo config set postCommand push
-gityo config set autoRunPostCommand true
-gityo config set autoAcceptCommitMessage true
-```
-
 ## Good for
 
 - quick everyday commits
@@ -149,4 +182,6 @@ gityo config set autoAcceptCommitMessage true
 
 - run it inside a git repo
 - if there are no changed files, it exits early
+- if anything is already staged, the message is generated from staged files only and those are committed as-is
+- if nothing is staged, the message is generated from all changes and everything is staged before committing
 - `--yolo` is the fastest mode and skips the usual prompts

package/dist/chunk-CjLZ-eKX.js

@@ -0,0 +1,35 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toDynamicImportESM = (isNodeMode) => (mod) => __toESM(mod.default, isNodeMode);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+export { __toCommonJS as a, __require as i, __esmMin as n, __toDynamicImportESM as o, __export as r, __toESM as s, __commonJSMin as t };

package/dist/defineProperty-DXo2ZDb8.js

@@ -0,0 +1,43 @@
+import { n as __esmMin } from "./chunk-CjLZ-eKX.js";
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+var init_typeof = __esmMin((() => {}));
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+var init_toPrimitive = __esmMin((() => {
+	init_typeof();
+}));
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+var init_toPropertyKey = __esmMin((() => {
+	init_typeof();
+	init_toPrimitive();
+}));
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+var init_defineProperty = __esmMin((() => {
+	init_toPropertyKey();
+}));
+export { init_defineProperty as n, _defineProperty as t };