@developerz.ai/aitm 0.0.3 → 0.0.5

package/README.md

@@ -76,8 +76,18 @@ aitm config set autoMerge true --project
 aitm config list
 ```
 
-- **Provider**: OpenRouter only (`OPENROUTER_API_KEY`). Any OpenRouter-routed
-  model id works per role — no Anthropic SDK involved.
+- **Provider**: any OpenAI-compatible endpoint via one credential — OpenRouter by
+  default, or set `baseURL` to run on z.ai GLM, a self-hosted gateway, etc. No
+  Anthropic SDK. **Profiles** switch the whole provider in one command:
+
+  ```bash
+  aitm profile add z.ai --preset zai --api-key "<your z.ai key>"
+  aitm profile use z.ai     # ✅ verified end-to-end on z.ai GLM (glm-5.2 / glm-5-turbo)
+  aitm profile use openrouter
+  ```
+
+  See [providers](https://github.com/developerz-ai/ai-task-master/blob/main/packages/aitm/docs/providers.md)
+  and [`aitm profile`](https://github.com/developerz-ai/ai-task-master/blob/main/packages/aitm/docs/commands/profile.md).
 - **Coding style**: `aitm` reads your repo's `CLAUDE.md` / `AGENTS.md` and feeds
   it to subagents as a style signal (the provider stays OpenRouter).
 - **MCP**: `aitm` is an MCP **client** — declare `mcpServers` in config and their

package/dist/cli/args.d.ts

@@ -1,3 +1,4 @@
+import { type PresetName } from '../config/provider-presets.ts';
 export type StartArgs = {
     kind: 'start';
     goal: string;
@@ -31,7 +32,34 @@ export type ConfigArgs = {
     kind: 'config-list';
     scope: 'global' | 'project';
 };
-export type ParsedArgs = StartArgs | MergePrArgs | ConfigArgs | {
+export type ProfileArgs = {
+    kind: 'profile-list';
+} | {
+    kind: 'profile-use';
+    name: string;
+} | {
+    kind: 'profile-add';
+    name: string;
+    preset?: PresetName;
+    baseURL?: string;
+    apiKey?: string;
+} | {
+    kind: 'profile-set';
+    name: string;
+    key: string;
+    value: string;
+} | {
+    kind: 'profile-get';
+    name: string;
+    key: string;
+} | {
+    kind: 'profile-remove';
+    name: string;
+} | {
+    kind: 'profile-show';
+    name?: string;
+};
+export type ParsedArgs = StartArgs | MergePrArgs | ConfigArgs | ProfileArgs | {
     kind: 'help';
 };
 export declare function parseArgs(argv: ReadonlyArray<string>): ParsedArgs;

package/dist/cli/args.js

@@ -1,3 +1,4 @@
+import { isPresetName } from "../config/provider-presets.js";
 const HELP = { kind: 'help' };
 export function parseArgs(argv) {
     const [command, ...rest] = argv;
@@ -12,6 +13,8 @@ export function parseArgs(argv) {
             return parseMergePr(rest);
         case 'config':
             return parseConfig(rest);
+        case 'profile':
+            return parseProfile(rest);
         default:
             return HELP;
     }
@@ -194,6 +197,116 @@ function parseConfig(args) {
             return HELP;
     }
 }
+function parseProfile(args) {
+    const sub = args[0];
+    if (sub === undefined)
+        return HELP;
+    const tail = args.slice(1);
+    switch (sub) {
+        case 'list':
+            return tail.length === 0 ? { kind: 'profile-list' } : HELP;
+        case 'use': {
+            const name = onlyName(tail);
+            return name === null ? HELP : { kind: 'profile-use', name };
+        }
+        case 'remove': {
+            const name = onlyName(tail);
+            return name === null ? HELP : { kind: 'profile-remove', name };
+        }
+        case 'show': {
+            if (tail.length === 0)
+                return { kind: 'profile-show' };
+            const name = onlyName(tail);
+            return name === null ? HELP : { kind: 'profile-show', name };
+        }
+        case 'get': {
+            if (tail.length !== 2)
+                return HELP;
+            const [name, key] = tail;
+            if (name === undefined ||
+                key === undefined ||
+                name.startsWith('--') ||
+                key.startsWith('--')) {
+                return HELP;
+            }
+            return { kind: 'profile-get', name, key };
+        }
+        case 'set': {
+            if (tail.length !== 3)
+                return HELP;
+            const [name, key, value] = tail;
+            if (name === undefined || key === undefined || value === undefined)
+                return HELP;
+            if (name.startsWith('--') || key.startsWith('--'))
+                return HELP;
+            return { kind: 'profile-set', name, key, value };
+        }
+        case 'add':
+            return parseProfileAdd(tail);
+        default:
+            return HELP;
+    }
+}
+function parseProfileAdd(tail) {
+    const positionals = [];
+    let preset;
+    let baseURL;
+    let apiKey;
+    let i = 0;
+    while (i < tail.length) {
+        const raw = tail[i];
+        if (raw === undefined)
+            break;
+        const { flag, inlineValue, consumed } = splitFlag(raw);
+        if (flag === '--preset') {
+            const v = takeValue(tail, i, inlineValue);
+            if (v === null || !isPresetName(v))
+                return HELP;
+            preset = v;
+            i += consumed(inlineValue !== null);
+        }
+        else if (flag === '--base-url') {
+            const v = takeValue(tail, i, inlineValue);
+            if (v === null || (inlineValue === null && v.startsWith('--')))
+                return HELP;
+            baseURL = v;
+            i += consumed(inlineValue !== null);
+        }
+        else if (flag === '--api-key') {
+            const v = takeValue(tail, i, inlineValue);
+            if (v === null || (inlineValue === null && v.startsWith('--')))
+                return HELP;
+            apiKey = v;
+            i += consumed(inlineValue !== null);
+        }
+        else if (raw.startsWith('--')) {
+            return HELP;
+        }
+        else {
+            positionals.push(raw);
+            i += 1;
+        }
+    }
+    const name = positionals[0];
+    if (name === undefined || positionals.length > 1)
+        return HELP;
+    const out = { kind: 'profile-add', name };
+    if (preset !== undefined)
+        out.preset = preset;
+    if (baseURL !== undefined)
+        out.baseURL = baseURL;
+    if (apiKey !== undefined)
+        out.apiKey = apiKey;
+    return out;
+}
+function onlyName(tail) {
+    if (tail.length !== 1)
+        return null;
+    const name = tail[0];
+    if (name === undefined || name.startsWith('--'))
+        return null;
+    return name;
+}
 function parseNonNegativeInt(s) {
     if (s === undefined || s === null)
         return null;

package/dist/cli/cli.js

@@ -2,7 +2,7 @@
 import { realpathSync } from 'node:fs';
 import { pathToFileURL } from 'node:url';
 import { parseArgs } from "./args.js";
-import { runConfig, runMergePr, runStart } from "./commands.js";
+import { runConfig, runMergePr, runProfile, runStart } from "./commands.js";
 export async function main(argv, ctx = {}) {
     const stdout = ctx.stdout ?? ((chunk) => process.stdout.write(chunk));
     const stderr = ctx.stderr ?? ((chunk) => process.stderr.write(chunk));
@@ -17,6 +17,14 @@ export async function main(argv, ctx = {}) {
         case 'config-get':
         case 'config-list':
             return emit(await runConfig(parsed, buildConfigCtx(ctx, stdout)), stderr);
+        case 'profile-list':
+        case 'profile-use':
+        case 'profile-add':
+        case 'profile-set':
+        case 'profile-get':
+        case 'profile-remove':
+        case 'profile-show':
+            return emit(await runProfile(parsed, buildProfileCtx(ctx, stdout)), stderr);
         case 'help':
             stdout(`${HELP_TEXT}\n`);
             return 0;
@@ -60,6 +68,12 @@ function buildConfigCtx(ctx, stdout) {
         out.homeDir = ctx.homeDir;
     return out;
 }
+function buildProfileCtx(ctx, stdout) {
+    const out = { stdout };
+    if (ctx.homeDir !== undefined)
+        out.homeDir = ctx.homeDir;
+    return out;
+}
 function emit(exit, stderr) {
     if (exit.message !== undefined && exit.message !== '')
         stderr(`${exit.message}\n`);
@@ -76,6 +90,13 @@ Usage:
   aitm config unset <key>       [--project]
   aitm config get <key>         [--project]
   aitm config list              [--project]
+  aitm profile list
+  aitm profile use <name>
+  aitm profile add <name> [--preset openrouter|zai] [--base-url <url>] [--api-key <key>]
+  aitm profile set <name> <key> <value>
+  aitm profile get <name> <key>
+  aitm profile remove <name>
+  aitm profile show [<name>]
   aitm help | --help | -h
 
 Exit codes:
@@ -83,7 +104,7 @@ Exit codes:
   1  precondition failure or run blocked
   2  cancelled
 
-Docs: docs/commands/start.md, docs/commands/merge-pr.md, docs/commands/config.md`;
+Docs: docs/commands/start.md, docs/commands/merge-pr.md, docs/commands/config.md, docs/commands/profile.md`;
 if (isEntrypoint(import.meta.url, process.argv[1])) {
     main(process.argv.slice(2)).then((code) => {
         process.exit(code);

package/dist/cli/commands.d.ts

@@ -72,6 +72,10 @@ export type ConfigCtx = {
     homeDir?: string;
     stdout?: (chunk: string) => void;
 };
+export type ProfileCtx = {
+    homeDir?: string;
+    stdout?: (chunk: string) => void;
+};
 export declare function runStart(args: Extract<ParsedArgs, {
     kind: 'start';
 }>, ctx?: StartCtx): Promise<CommandExit>;
@@ -81,3 +85,6 @@ export declare function runMergePr(args: Extract<ParsedArgs, {
 export declare function runConfig(args: Extract<ParsedArgs, {
     kind: `config-${string}`;
 }>, ctx?: ConfigCtx): Promise<CommandExit>;
+export declare function runProfile(args: Extract<ParsedArgs, {
+    kind: `profile-${string}`;
+}>, ctx?: ProfileCtx): Promise<CommandExit>;

package/dist/cli/commands.js

@@ -3,6 +3,7 @@ import { join, resolve as resolvePath } from 'node:path';
 import { AgentConfigDetector } from "../agent-config/agent-config-detector.js";
 import { ConfigLoader } from "../config/config-loader.js";
 import { ConfigWriter } from "../config/config-writer.js";
+import { ProfileManager } from "../config/profiles.js";
 import { Credentials } from "../credentials/credentials.js";
 import { DEFAULT_MODELS } from "../credentials/defaults.js";
 import { GitHubClient } from "../github/github-client.js";
@@ -257,10 +258,7 @@ export async function runConfig(args, ctx = {}) {
             }
             case 'config-list': {
                 const file = await writer.list(args.scope);
-                const safe = file.openrouterApiKey
-                    ? { ...file, openrouterApiKey: maskSecret(file.openrouterApiKey) }
-                    : file;
-                stdout(`${JSON.stringify(safe, null, 2)}\n`);
+                stdout(`${JSON.stringify(redactConfigKeys(file), null, 2)}\n`);
                 return { code: 0 };
             }
             default:
@@ -274,6 +272,65 @@ export async function runConfig(args, ctx = {}) {
         return { code: 1, message: errMsg(err) };
     }
 }
+export async function runProfile(args, ctx = {}) {
+    const homeDir = ctx.homeDir ?? homedir();
+    const stdout = ctx.stdout ?? ((chunk) => process.stdout.write(chunk));
+    const manager = new ProfileManager(homeDir);
+    try {
+        switch (args.kind) {
+            case 'profile-list': {
+                const listing = await manager.list();
+                stdout(formatProfileList(listing.activeProfile, listing.profiles));
+                return { code: 0 };
+            }
+            case 'profile-use': {
+                await manager.use(args.name);
+                stdout(`Active profile is now "${args.name}".\n`);
+                return { code: 0 };
+            }
+            case 'profile-add': {
+                const input = {};
+                if (args.preset !== undefined)
+                    input.preset = args.preset;
+                if (args.baseURL !== undefined)
+                    input.baseURL = args.baseURL;
+                if (args.apiKey !== undefined)
+                    input.apiKey = args.apiKey;
+                await manager.add(args.name, input);
+                const activated = (await manager.list()).activeProfile === args.name;
+                stdout(activated
+                    ? `Created and activated profile "${args.name}".\n`
+                    : `Created profile "${args.name}". Run \`aitm profile use ${args.name}\` to activate it.\n`);
+                return { code: 0 };
+            }
+            case 'profile-set':
+                await manager.set(args.name, args.key, args.value);
+                return { code: 0 };
+            case 'profile-get': {
+                const value = await manager.get(args.name, args.key);
+                stdout(`${formatConfigValue(value)}\n`);
+                return { code: 0 };
+            }
+            case 'profile-remove':
+                await manager.remove(args.name);
+                stdout(`Removed profile "${args.name}".\n`);
+                return { code: 0 };
+            case 'profile-show': {
+                const { name, profile } = await manager.show(args.name);
+                stdout(`${name}\n${JSON.stringify(redactProfile(profile), null, 2)}\n`);
+                return { code: 0 };
+            }
+            default:
+                return {
+                    code: 1,
+                    message: `Unknown profile subcommand: ${args.kind}`,
+                };
+        }
+    }
+    catch (err) {
+        return { code: 1, message: errMsg(err) };
+    }
+}
 function toCliOverrides(args) {
     const out = {};
     if (args.maxPrs !== undefined)
@@ -362,6 +419,38 @@ function formatConfigValue(value) {
         return value;
     return JSON.stringify(value, null, 2);
 }
+function formatProfileList(active, profiles) {
+    const names = Object.keys(profiles).sort();
+    if (names.length === 0) {
+        return 'No profiles configured. Create one with `aitm profile add <name> --preset zai`.\n';
+    }
+    const lines = names.map((name) => {
+        const p = profiles[name] ?? {};
+        const marker = name === active ? '*' : ' ';
+        const base = p.baseURL ?? '(provider default)';
+        const key = p.openrouterApiKey ? maskSecret(p.openrouterApiKey) : '(no key)';
+        return `${marker} ${name}\t${base}\t${key}`;
+    });
+    return `${lines.join('\n')}\n`;
+}
+function redactProfile(profile) {
+    return profile.openrouterApiKey
+        ? { ...profile, openrouterApiKey: maskSecret(profile.openrouterApiKey) }
+        : profile;
+}
+function redactConfigKeys(file) {
+    const out = file.openrouterApiKey
+        ? { ...file, openrouterApiKey: maskSecret(file.openrouterApiKey) }
+        : { ...file };
+    if (out.profiles) {
+        const profiles = {};
+        for (const [name, profile] of Object.entries(out.profiles)) {
+            profiles[name] = redactProfile(profile);
+        }
+        out.profiles = profiles;
+    }
+    return out;
+}
 const defaultAuthStatus = (cwd) => new GitHubClient(cwd).authStatus();
 async function defaultRunLoop(input) {
     return runLoopAdapter(input);
@@ -370,9 +459,11 @@ async function defaultRunMergeFlow(input) {
     const { runTakeOverFlow } = await import("../loop/take-over-flow.js");
     const { execa } = await import('execa');
     const { githubThreadTool } = await import("../tools/github-thread-tool.js");
+    const { PrContextStore } = await import("../state/pr-context-store.js");
     const worktreePath = input.cwd;
     const baseBranch = await input.github.defaultBranch();
     const styleContents = input.agentConfig.contents;
+    const prContext = new PrContextStore(resolvePath(input.cwd, '.ai-task-master'));
     const workerTools = localEditTools(worktreePath);
     const github = githubThreadTool({ github: input.github });
     const result = await runTakeOverFlow({
@@ -380,6 +471,7 @@ async function defaultRunMergeFlow(input) {
         worktreePath,
         baseBranch,
         github: input.github,
+        prContext,
         mergeMethod: input.runState.options.mergeMethod,
         push: async (cwd) => {
             const r = await execa('git', ['push'], { cwd });
@@ -393,6 +485,7 @@ async function defaultRunMergeFlow(input) {
             workerModel: input.credentials.modelFor('worker'),
             workerTools,
             styleContents,
+            ...(input.resolved.formatCommand ? { formatCommand: input.resolved.formatCommand } : {}),
         },
     });
     if (result.kind === 'merged') {

package/dist/config/config-loader.d.ts

@@ -19,6 +19,8 @@ export declare class ConfigLoader {
     private readMcpEnvelope;
     private resolveMcpServers;
     private readConfigFile;
+    private resolveActiveProfile;
+    private resolveBaseURL;
     private resolveApiKey;
     private resolveModels;
 }

package/dist/config/config-loader.js

@@ -13,12 +13,16 @@ const CLAUDE_PROJECT_MCP_FILE = '.mcp.json';
 const CLAUDE_USER_FILE = '.claude.json';
 const KNOWN_KEYS = new Set([
     'openrouterApiKey',
+    'activeProfile',
+    'profiles',
+    'baseURL',
     'models',
     'maxPrs',
     'maxSessions',
     'autoMerge',
     'mergeMethod',
     'stylePath',
+    'formatCommand',
     'logLevel',
     'concurrency',
     'mcpServers',
@@ -29,6 +33,7 @@ const DEFAULTS = {
     autoMerge: true,
     mergeMethod: 'squash',
     stylePath: null,
+    formatCommand: null,
     logLevel: 'info',
     concurrency: 1,
 };
@@ -48,10 +53,13 @@ export class ConfigLoader {
         const project = await this.readProject();
         const claudeUser = await this.readClaudeUserMcp();
         const claudeProject = await this.readClaudeProjectMcp();
-        const { apiKey, apiKeySource } = this.resolveApiKey(global, project);
+        const active = this.resolveActiveProfile(global);
+        const profile = active?.profile;
+        const { apiKey, apiKeySource } = this.resolveApiKey(global, project, profile);
         if (apiKey === undefined || apiKeySource === undefined) {
-            throw new Error('No OpenRouter API key found. Set OPENROUTER_API_KEY env, or add ' +
-                '"openrouterApiKey" to ~/.aitm.json or ./.ai-task-master/config.json.');
+            throw new Error('No OpenRouter API key found. Set OPENROUTER_API_KEY env, add ' +
+                '"openrouterApiKey" to ~/.aitm.json or ./.ai-task-master/config.json, or ' +
+                'create a profile with `aitm profile add <name> --api-key <key>`.');
         }
         const { mcpServers, mcpServerSources } = this.resolveMcpServers({
             aitmGlobal: global?.mcpServers,
@@ -62,12 +70,15 @@ export class ConfigLoader {
         return {
             openrouterApiKey: apiKey,
             apiKeySource,
-            models: this.resolveModels(global, project, cliOverrides),
+            ...(active ? { activeProfile: active.name } : {}),
+            baseURL: this.resolveBaseURL(global, project, profile),
+            models: this.resolveModels(global, project, profile, cliOverrides),
             maxPrs: pick(cliOverrides.maxPrs, project?.maxPrs, global?.maxPrs, DEFAULTS.maxPrs),
             maxSessions: pickNullable(cliOverrides.maxSessions, project?.maxSessions, global?.maxSessions, DEFAULTS.maxSessions),
             autoMerge: pick(cliOverrides.autoMerge, project?.autoMerge, global?.autoMerge, DEFAULTS.autoMerge),
             mergeMethod: pick(cliOverrides.mergeMethod, project?.mergeMethod, global?.mergeMethod, DEFAULTS.mergeMethod),
             stylePath: pickNullable(cliOverrides.stylePath, project?.stylePath, global?.stylePath, DEFAULTS.stylePath),
+            formatCommand: pickNullable(undefined, project?.formatCommand, global?.formatCommand, DEFAULTS.formatCommand),
             logLevel: pick(undefined, project?.logLevel, global?.logLevel, DEFAULTS.logLevel),
             concurrency: pick(cliOverrides.concurrency, project?.concurrency, global?.concurrency, DEFAULTS.concurrency),
             mcpServers,
@@ -175,27 +186,58 @@ export class ConfigLoader {
         }
         return validated;
     }
-    resolveApiKey(global, project) {
+    resolveActiveProfile(global) {
+        const name = global?.activeProfile;
+        if (!name)
+            return undefined;
+        const profile = global?.profiles?.[name];
+        if (!profile) {
+            this.warn(`activeProfile "${name}" is set in ~/.aitm.json but no such profile exists — ignoring it. ` +
+                'Run `aitm profile list` to see available profiles.');
+            return undefined;
+        }
+        return { name, profile };
+    }
+    resolveBaseURL(global, project, profile) {
+        if (project?.baseURL)
+            return project.baseURL;
+        if (global?.baseURL)
+            return global.baseURL;
+        if (profile?.baseURL)
+            return profile.baseURL;
+        const env = this.env.OPENROUTER_BASE_URL?.trim();
+        if (!env)
+            return undefined;
+        const parsed = z.url().safeParse(env);
+        if (!parsed.success) {
+            throw new Error(`OPENROUTER_BASE_URL is not a valid URL: ${JSON.stringify(env)}`);
+        }
+        return parsed.data;
+    }
+    resolveApiKey(global, project, profile) {
         if (project?.openrouterApiKey) {
             return { apiKey: project.openrouterApiKey, apiKeySource: 'project' };
         }
         if (global?.openrouterApiKey) {
             return { apiKey: global.openrouterApiKey, apiKeySource: 'global' };
         }
+        if (profile?.openrouterApiKey) {
+            return { apiKey: profile.openrouterApiKey, apiKeySource: 'profile' };
+        }
         const envKey = this.env.OPENROUTER_API_KEY;
         if (envKey) {
             return { apiKey: envKey, apiKeySource: 'env' };
         }
         return { apiKey: undefined, apiKeySource: undefined };
     }
-    resolveModels(global, project, cliOverrides) {
+    resolveModels(global, project, profile, cliOverrides) {
         const merged = {
             generic: DEFAULT_MODELS.generic,
             smart: DEFAULT_MODELS.smart,
             coding: DEFAULT_MODELS.coding,
             fast: DEFAULT_MODELS.fast,
         };
-        for (const src of [global?.models, project?.models]) {
+        for (const src of [profile?.models, global?.models, project?.models]) {
             if (!src)
                 continue;
             if (src.generic)

package/dist/config/config-writer.js

@@ -6,8 +6,10 @@ import { ConfigFileSchema } from "./schema.js";
 const GLOBAL_FILE = '.aitm.json';
 const PROJECT_DIR = '.ai-task-master';
 const PROJECT_FILE = 'config.json';
+const PROFILE_MANAGED_KEYS = new Set(['activeProfile', 'profiles']);
 const KNOWN_KEYS = new Set([
     'openrouterApiKey',
+    'baseURL',
     'models',
     'maxPrs',
     'maxSessions',
@@ -28,6 +30,7 @@ export class ConfigWriter {
     async set(scope, key, value) {
         const parts = splitKey(key);
         const top = parts[0];
+        assertNotProfileManaged(top);
         if (!KNOWN_KEYS.has(top)) {
             throw new Error(unknownKeyMessage(top));
         }
@@ -37,6 +40,7 @@ export class ConfigWriter {
     }
     async unset(scope, key) {
         const parts = splitKey(key);
+        assertNotProfileManaged(parts[0]);
         const file = await this.readRaw(scope);
         unsetDottedKey(file, parts);
         return this.validateAndPersist(scope, file);
@@ -158,6 +162,11 @@ function getDottedKey(obj, parts) {
     }
     return cur;
 }
+function assertNotProfileManaged(top) {
+    if (PROFILE_MANAGED_KEYS.has(top)) {
+        throw new Error(`"${top}" is managed by \`aitm profile …\`. Use the profile commands instead.`);
+    }
+}
 function unknownKeyMessage(top) {
     const allowed = [...KNOWN_KEYS].sort().join(', ');
     return `Unknown config key "${top}". Allowed top-level keys: ${allowed}`;

package/dist/config/profiles.d.ts

@@ -0,0 +1,30 @@
+import { type PresetName } from './provider-presets.ts';
+import { type Profile } from './schema.ts';
+export type AddProfileInput = {
+    preset?: PresetName;
+    baseURL?: string;
+    apiKey?: string;
+};
+export type ProfileListing = {
+    activeProfile: string | undefined;
+    profiles: Record<string, Profile>;
+};
+export declare class ProfileManager {
+    private readonly homeDir;
+    constructor(homeDir: string);
+    list(): Promise<ProfileListing>;
+    use(name: string): Promise<void>;
+    add(name: string, input?: AddProfileInput): Promise<Profile>;
+    set(name: string, key: string, value: unknown): Promise<Profile>;
+    get(name: string, key: string): Promise<unknown>;
+    remove(name: string): Promise<void>;
+    show(name?: string): Promise<{
+        name: string;
+        profile: Profile;
+    }>;
+    private filePath;
+    private readRaw;
+    private readValidated;
+    private validate;
+    private persist;
+}