@technomoron/agent-run 0.99.26 → 0.99.28

package/CHANGES

@@ -1,6 +1,24 @@
 CHANGES
 =======
 
+Version 0.99.28 (2026-08-30)
+----------------------------
+* Add interactive `agent-run setup [org/repo]`, make `agent-run generate` the
+  profile-initialization command, and retain `init` as a deprecated alias.
+* Use `~/.agent-run` as the single default config directory, overridable with
+  `--configdir`, `AGENT_CONFIG_DIR`, or a project-local `.agent-run.env`.
+* Resolve profiles from `package.json.repository` and avoid rewriting unchanged
+  generated files.
+
+Version 0.99.27 (2026-08-11)
+----------------------------
+* Rename the unattended-run option from `--danger` to `--yolo` for Codex and
+  Claude.
+* Add `agent-run setup [config-root]` to create the packaged starter agent
+  configuration files without overwriting local edits.
+* Resolve plain directories without Git metadata or a package name as
+  `[parent]/[current]` profiles.
+
 Version 0.99.26 (2026-07-31)
 ----------------------------
 * Add `--danger` support for Claude so unattended runs pass

package/README.md

@@ -3,8 +3,7 @@
 Small wrapper for AI coding CLIs like Codex and Claude.
 
 It keeps agent files out of normal repos and stores them in a separate
-agent config tree. By default, that tree lives beside owner/repo checkouts
-under the same code root.
+agent config tree. By default, that tree lives at `~/.agent-run`.
 
 ## Model
 
@@ -17,31 +16,29 @@ There are three things:
 Example:
 
 ```text
-~/source/
-  agent-config/
-    agent-run.defaults.jsonc
-    org/
-      my-api/
-        agent-run.jsonc
-        local.md.njk       # optional
-        overrides/         # optional
-        live/
-          CLAUDE.md
-          .claude/
-          bin/
-          memories/
-            codex-home/
-              AGENTS.md
-              config.toml
-              skills/
+~/.agent-run/
+  agent-run.defaults.jsonc
   org/
     my-api/
+      agent-run.jsonc
+      local.md.njk       # optional
+      overrides/         # optional
+      live/
+        CLAUDE.md
+        .claude/
+        bin/
+        memories/
+          codex-home/
+            AGENTS.md
+            config.toml
+            skills/
+~/source/org/my-api/
 ```
 
 If your source repo is `~/source/org/my-api`, `agent-run` maps it to:
 
 ```text
-~/source/agent-config/org/my-api
+~/.agent-run/org/my-api
 ```
 
 The source repo stays clean. The agent files live in the matching path under
@@ -96,19 +93,24 @@ The mapped path is:
 
 1. `AGENT_RUN_PROFILE` in `.agent-run.env`
 2. GitHub `origin` remote
-3. `package.json.name`
+3. `package.json.repository` (string or object `url`)
+4. `package.json.name`
+5. the project path as `[parent]/[current]`
 
 Examples:
 
 - `AGENT_RUN_PROFILE=org/my-api` -> `org/my-api`
 - `AGENT_RUN_PROFILE=unrelated/hello` -> `unrelated/hello`
+- `package.json.repository = "github:org/my-api"` -> `org/my-api`
 - `package.json.name = "@org/my-api"` -> `org/my-api`
 - `package.json.name = "my-api"` -> `my-api`
+- `/work/org/my-api` with none of the above -> `org/my-api`
 
 `AGENT_RUN_PROFILE` is relative to the config root. It is not a filesystem
 path, so values like `/tmp/foo`, `C:/tmp/foo`, or `../foo` are rejected.
 
-If neither exists, `agent-run` fails instead of guessing.
+The path fallback lets plain directories work without a Git repository or a
+`package.json`. The explicit profile sources above always take precedence.
 
 ## Overrides
 
@@ -121,20 +123,10 @@ AGENT_RUN_PROFILE=org/my-api
 
 Config root:
 
-- default for a project at `[code]/owner/repo`: `[code]/agent-config`
-- override with `--config-root /path/to/agent-configs`
+- default: `~/.agent-run`
+- override with `--configdir=/path/to/agent-configs`
 - override with `AGENT_CONFIG_DIR=/path/to/agent-configs`
-- override with `AGENT_CONFIG_ROOT=/path/to/agent-configs`
-- or set `AGENT_CONFIG_DIR=/path/to/agent-configs` or `AGENT_CONFIG_ROOT=/path/to/agent-configs` in `.agent-run.env`
-
-For commands without a project root, `agent-run` looks for an existing config
-root in these locations:
-
-- Windows: `~/Documents/code/agent-config`, `~/Documents/code/agent-configs`,
-  `~/Desktop/code/agent-config`, `~/Desktop/code/agent-configs`,
-  `C:\code\agent-config`, `C:\code\agent-configs`
-- Unix: `~/code/agent-config`, `~/code/agent-configs`, `~/agent-config`,
-  `~/agent-configs`, `~/.agent-config`, `~/.agent-configs`
+- or set `AGENT_CONFIG_DIR=/path/to/agent-configs` in `.agent-run.env`
 
 ## Commands
 
@@ -168,7 +160,7 @@ replace the user's normal `CLAUDE_CONFIG_DIR`. If Claude writes remembered
 permissions to `.claude/settings.local.json`, `agent-run` removes that file
 after the session unless `--local` was used.
 
-`--danger` runs either tool unattended, with no approval prompts: Codex with
+`--yolo` runs either tool unattended, with no approval prompts: Codex with
 `-a never -s danger-full-access`, Claude with `--dangerously-skip-permissions`.
 Only use it when the agent may change or delete anything it can reach. Claude
 refuses `--dangerously-skip-permissions` when it runs as root, so run it as a
@@ -183,12 +175,12 @@ to warn and continue for a specific invocation.
 Initialize mapped files for the current repo:
 
 ```sh
-agent-run init
+agent-run generate
 ```
 
 This creates `<config-root>/agent-run.defaults.jsonc` when needed and a minimal
 `agent-run.jsonc` marker for the mapped profile. It does not create empty local
-instruction or override files.
+instruction or override files. `agent-run init` remains as a deprecated alias.
 
 Edit the source file for the current repo:
 
@@ -206,19 +198,18 @@ agent-run update
 ```
 
 `update` requires an existing profile marker or local/legacy instruction file;
-it does not silently scaffold an unconfigured project. Use `agent-run init` or
+it does not silently scaffold an unconfigured project. Use `agent-run generate` or
 the tool command's `--create` option first.
 
 Regenerate every profile under the config root without requiring matching code
 checkouts:
 
 ```sh
-agent-run update --all ~/.agent-config
+agent-run update --all ~/.agent-run
 ```
 
 If the config root argument is omitted, `update --all` uses the normal configured
-root. Without a project path, that falls back to `$HOME/.agent-config`; for
-project commands, the default is `[code]/agent-config`.
+root. Without an override, the root is `$HOME/.agent-run`.
 
 You can also generate from a tool command and stop before launch:
 
@@ -242,27 +233,28 @@ Per-profile override templates can be placed in:
 - `overrides/codex-config.toml.njk`
 - `overrides/claude-settings.json.njk`
 
-## Starter Config
+## Default Config Tree
 
-A complete starter lives in `examples/basic-config`. It includes a minimal
+A complete default tree lives in `examples/basic-config`. It includes a minimal
 project, `.agent-run.env`, root manifest defaults, global templates and
 snippets, profile-local templates, skill templates, a personal memory skill,
 profile skill overrides, tool config overrides, guardrails, checks, and
 generated runtime paths.
 
-To copy the packaged starter config root into your default config location:
+To install the default tree and detected profile in your resolved config root:
 
 ```sh
-agent-run --init
+agent-run setup
 ```
 
-Or choose a destination:
+Or select a profile non-interactively:
 
 ```sh
-agent-run --init ~/.agent-config
+agent-run setup myorg/myrepo
 ```
 
-The copy skips files that already exist, so local edits are preserved.
+Use `--configdir=DIR` to choose a different destination. The copy skips files
+that already exist, so local edits are preserved.
 
 Try it from a checkout:
 
@@ -295,7 +287,7 @@ agent-run check --all ~/source
 Migrate an existing config tree to the manifest/template layout:
 
 ```sh
-agent-run migrate-config ~/.agent-config
+agent-run migrate-config ~/.agent-run
 ```
 
 This preserves `AGENTS-MODS.md`, creates `local.md.njk` and a sparse

package/dist/cli.js

@@ -10,15 +10,6 @@ function parseInvocation(invokedTool, argv) {
     let command = normalizeCommandName(invokedTool);
     const options = extractGlobalOptions(argv);
     applyGlobalOptions(options);
-    if (options.initConfig) {
-        if (options.args.length > 0) {
-            (0, utils_1.fail)('--init cannot be combined with a command');
-        }
-        return {
-            command: 'init-config',
-            targetPath: path.resolve(options.initConfigTargetPath ?? (0, project_1.defaultConfigRoot)())
-        };
-    }
     if (command === null) {
         command = extractCommand(options.args);
     }
@@ -34,7 +25,7 @@ function applyGlobalOptions(options) {
 }
 function extractCommand(args) {
     if (args.length === 0) {
-        (0, utils_1.fail)('usage: agent-run <codex|claude|check|init|edit|update> [options] (run with --help for details)');
+        (0, utils_1.fail)('usage: agent-run <codex|claude|check|setup|generate|edit|update> [options] (run with --help for details)');
     }
     if (isHelpFlag(args[0])) {
         printHelp('general');
@@ -59,6 +50,10 @@ function parseCommand(command, args) {
             return parseCheckCommand(args);
         case 'init':
             return parseInitCommand(args);
+        case 'generate':
+            return parseGenerateCommand(args);
+        case 'setup':
+            return parseSetupCommand(args);
         case 'edit':
             return parseEditCommand(args);
         case 'update':
@@ -73,8 +68,6 @@ function extractGlobalOptions(argv) {
     const options = {
         args: [],
         configRootOverride: null,
-        initConfig: false,
-        initConfigTargetPath: null,
         verbose: false
     };
     let passthrough = false;
@@ -94,26 +87,18 @@ function extractGlobalOptions(argv) {
         else if (arg === '-v' || arg === '--verbose') {
             options.verbose = true;
         }
-        else if (arg === '--init') {
-            options.initConfig = true;
-            const nextArg = argv[index + 1];
-            if (nextArg !== undefined && !nextArg.startsWith('-')) {
-                options.initConfigTargetPath = nextArg;
-                index += 1;
-            }
-        }
-        else if (arg === '--config-root') {
+        else if (arg === '--configdir') {
             const nextArg = argv[index + 1];
             if (nextArg === undefined) {
-                (0, utils_1.fail)('missing value for --config-root');
+                (0, utils_1.fail)('missing value for --configdir');
             }
             options.configRootOverride = path.resolve(nextArg);
             index += 1;
         }
-        else if (arg.startsWith('--config-root=')) {
-            const rootValue = arg.slice('--config-root='.length);
+        else if (arg.startsWith('--configdir=')) {
+            const rootValue = arg.slice('--configdir='.length);
             if (!rootValue) {
-                (0, utils_1.fail)('missing value for --config-root');
+                (0, utils_1.fail)('missing value for --configdir');
             }
             options.configRootOverride = path.resolve(rootValue);
         }
@@ -154,7 +139,7 @@ function parseRunCommand(command, inputArgs) {
         args.push(arg);
     }
     if (wrapperArgs.codexNetwork && wrapperArgs.sandboxMode === 'danger') {
-        (0, utils_1.fail)('--network cannot be combined with agent-run codex --danger');
+        (0, utils_1.fail)('--network cannot be combined with agent-run codex --yolo');
     }
     return { args, command, wrapperArgs };
 }
@@ -174,19 +159,19 @@ function applyCommonRunOption(arg, options) {
     return true;
 }
 function applySandboxRunOption(command, arg, options) {
-    if (!['--danger', '--sandboxed', '--network'].includes(arg)) {
+    if (!['--yolo', '--sandboxed', '--network'].includes(arg)) {
         return false;
     }
-    if (arg !== '--danger' && command !== 'codex') {
+    if (arg !== '--yolo' && command !== 'codex') {
         (0, utils_1.fail)(`${arg} is only supported for agent-run codex`);
     }
     if (arg === '--network') {
         options.codexNetwork = true;
         return true;
     }
-    const mode = arg === '--danger' ? 'danger' : 'sandboxed';
+    const mode = arg === '--yolo' ? 'danger' : 'sandboxed';
     if (options.sandboxMode !== null && options.sandboxMode !== mode) {
-        (0, utils_1.fail)('cannot combine --danger and --sandboxed');
+        (0, utils_1.fail)('cannot combine --yolo and --sandboxed');
     }
     options.sandboxMode = mode;
     return true;
@@ -213,11 +198,30 @@ function parseCheckCommand(inputArgs) {
 function parseInitCommand(inputArgs) {
     return { command: 'init', targetPath: parseSinglePath(inputArgs, 'init') };
 }
+function parseGenerateCommand(inputArgs) {
+    return { command: 'generate', targetPath: parseSinglePath(inputArgs, 'generate') };
+}
+function parseSetupCommand(inputArgs) {
+    let profile = null;
+    for (const arg of inputArgs) {
+        if (isHelpFlag(arg)) {
+            printHelp('setup');
+        }
+        if (arg.startsWith('--')) {
+            (0, utils_1.fail)(`unknown setup option: ${arg}`);
+        }
+        if (profile !== null) {
+            (0, utils_1.fail)('setup accepts at most one profile argument');
+        }
+        profile = arg;
+    }
+    return { command: 'setup', profile };
+}
 function parseEditCommand(inputArgs) {
     return { command: 'edit', targetPath: parseSinglePath(inputArgs, 'edit') };
 }
-function parseSinglePath(inputArgs, command) {
-    let targetPath = process.cwd();
+function parseSinglePath(inputArgs, command, defaultPath = process.cwd()) {
+    let targetPath = defaultPath;
     for (const arg of inputArgs) {
         if (isHelpFlag(arg)) {
             printHelp(command);
@@ -288,7 +292,9 @@ function renderHelp(topic) {
             '  --all       Check every repo under path',
             ''
         ],
-        init: ['Usage:', '  agent-run init [path]', '', 'Create a minimal mapped profile marker and render generated files.', ''],
+        init: ['Usage:', '  agent-run init [path]', '', 'Deprecated alias for `agent-run generate [path]`.', ''],
+        generate: ['Usage:', '  agent-run generate [path]', '', 'Create a minimal mapped profile marker and render generated files.', ''],
+        setup: ['Usage:', '  agent-run setup [org/repo]', '', 'Install the default config tree and selected profile.', ''],
         edit: ['Usage:', '  agent-run edit [path]', '', 'Create or open the editable local profile template.', ''],
         update: [
             'Usage:',
@@ -313,16 +319,16 @@ function renderHelp(topic) {
         `agent-run ${agentRunVersion()}`,
         '',
         'Usage:',
-        '  agent-run <codex|claude|check|init|edit|update> [options]',
-        '  agent-run --init [config-root]',
+        '  agent-run <codex|claude|check|setup|generate|edit|update> [options]',
         '',
         'Commands:',
-        '  codex [--none] [--create] [--local] [--show] [--generate] [--danger|--sandboxed] [--network] [args...]',
+        '  codex [--none] [--create] [--local] [--show] [--generate] [--yolo|--sandboxed] [--network] [args...]',
         '                                           Run codex with generated private config',
-        '  claude [--none] [--create] [--local] [--show] [--generate] [--danger] [args...]',
+        '  claude [--none] [--create] [--local] [--show] [--generate] [--yolo] [args...]',
         '                                           Run claude with generated private config',
+        '  setup [org/repo]                      Install the default tree and selected profile',
         '  check [--all] [path]                  Validate generated profile output',
-        '  init [path]                           Create a sparse profile marker and render output',
+        '  generate [path]                       Create a sparse profile marker and render output',
         '  edit [path]                           Create or open local.md.njk',
         '  update [--all] [path]                 Regenerate existing profile output',
         '  migrate-config [config-root]           Convert existing config tree layout',
@@ -331,14 +337,13 @@ function renderHelp(topic) {
         '  -h, --help         Show this help text',
         '  -V, --version      Show the agent-run version',
         '  -v, --verbose      Print path resolution and wrapper actions',
-        '  --config-root DIR  Override the agent-config root',
-        '  --init [DIR]       Copy the packaged starter config root to DIR (default ~/.agent-config)',
+        '  --configdir=DIR    Override the config directory',
         '',
         'Run wrapper options:',
         '  --local            Warn about local AI files instead of failing',
         '  --show             Show read/include and generated files without running the tool',
         '  --generate         Generate files without running the tool',
-        '  --danger           Run unattended without approval prompts:',
+        '  --yolo             Run unattended without approval prompts:',
         '                     Codex with -a never -s danger-full-access,',
         '                     Claude with --dangerously-skip-permissions',
         '',
@@ -365,7 +370,7 @@ function normalizeCommandName(value) {
     if (base === 'agent-run') {
         return null;
     }
-    return ['codex', 'claude', 'check', 'init', 'edit', 'update', 'migrate-config'].includes(base)
+    return ['codex', 'claude', 'check', 'setup', 'generate', 'init', 'edit', 'update', 'migrate-config'].includes(base)
         ? base
         : null;
 }

package/dist/commands.js

@@ -22,10 +22,13 @@ function dispatch(command) {
             runCheck(command);
             return;
         case 'init':
-            runInit(command);
+            runGenerate(command);
             return;
-        case 'init-config':
-            runInitConfig(command);
+        case 'generate':
+            runGenerate(command);
+            return;
+        case 'setup':
+            runSetup(command);
             return;
         case 'edit':
             runEdit(command);
@@ -65,7 +68,7 @@ function runTool(parsed) {
         return;
     }
     if (wrapperArgs.create) {
-        runInit({ command: 'init', targetPath: projectRoot });
+        runGenerate({ command: 'generate', targetPath: projectRoot });
     }
     const configRoot = (0, project_1.defaultConfigRoot)(projectRoot);
     const agentDir = path.join(configRoot, profile);
@@ -110,7 +113,7 @@ function requireProfile(tool, agentDir) {
     }
     const label = tool ?? 'agent';
     process.stderr.write(`agent-run: no ${label} profile found for this project: ${agentDir}\n`);
-    process.stderr.write('agent-run: run `agent-run init` or use the tool with `--create`.\n');
+    process.stderr.write('agent-run: run `agent-run generate` or use the tool with `--create`.\n');
     process.exit(1);
 }
 function checkLocalAiFiles(command, projectRoot, agentDir, context, allowLocal) {
@@ -146,21 +149,84 @@ function ensureToolEnabled(context, command) {
         (0, utils_1.fail)(`${command} is disabled for agent-run profile ${context.profile}`);
     }
 }
-function runInit(parsed) {
-    const projectRoot = activeProject(parsed.targetPath, 'init');
+function runGenerate(parsed) {
+    if (parsed.command === 'init') {
+        process.stderr.write('agent-run: `init` is deprecated; use `agent-run generate [path]` instead.\n');
+    }
+    const projectRoot = activeProject(parsed.targetPath, 'generate');
     if (projectRoot === null) {
         return;
     }
     const agentDir = initializeProfileSource(projectRoot, true);
     printUpdateSummary((0, renderer_1.syncAgentProfile)(projectRoot, agentDir));
 }
-function runInitConfig(parsed) {
+function runSetup(parsed) {
+    const projectRoot = (0, project_1.findProjectRoot)(process.cwd());
+    const detectedProfile = (0, project_1.resolveProfile)(projectRoot);
+    const profile = parsed.profile === null ? confirmProfile(detectedProfile) : requireValidProfile(parsed.profile);
+    const configRoot = (0, project_1.defaultConfigRoot)(projectRoot);
     const sourcePath = (0, config_tree_1.starterConfigRootPath)();
     if (!fs.existsSync(sourcePath)) {
         (0, utils_1.fail)(`starter config skeleton not found: ${sourcePath}`);
     }
-    (0, config_tree_1.copySkeletonTree)(sourcePath, path.resolve(parsed.targetPath));
-    process.stdout.write(`OK copied starter config to ${path.resolve(parsed.targetPath)}\n`);
+    (0, config_tree_1.copySkeletonTree)(sourcePath, configRoot, new Set(['starter']));
+    const agentDir = path.join(configRoot, profile);
+    (0, config_tree_1.copySkeletonTree)(path.join(sourcePath, 'starter', 'basic-project'), agentDir);
+    if (profile !== detectedProfile) {
+        writeProjectProfileMapping(projectRoot, profile);
+    }
+    printUpdateSummary((0, renderer_1.syncAgentProfile)(projectRoot, agentDir, { configRoot, profile }));
+    process.stdout.write(`OK installed default config tree at ${configRoot}\n`);
+}
+function requireValidProfile(value) {
+    const parsed = (0, project_1.parseProfile)(value, 'setup profile');
+    if (parsed.profile === null) {
+        (0, utils_1.fail)(parsed.reason);
+    }
+    return parsed.profile;
+}
+function confirmProfile(detectedProfile) {
+    process.stdout.write(`Detected profile: ${detectedProfile}\n`);
+    const confirmation = promptLine('Is this correct? [Y/n] ').trim().toLowerCase();
+    if (confirmation === '' || confirmation === 'y' || confirmation === 'yes') {
+        return detectedProfile;
+    }
+    return requireValidProfile(promptLine('Profile (org/repo): '));
+}
+function promptLine(prompt) {
+    if (!process.stdin.isTTY) {
+        (0, utils_1.fail)('setup requires a profile argument when input is not interactive');
+    }
+    process.stdout.write(prompt);
+    const bytes = [];
+    const buffer = Buffer.alloc(1);
+    while (fs.readSync(process.stdin.fd, buffer, 0, 1, null) === 1) {
+        if (buffer[0] === 10) {
+            break;
+        }
+        if (buffer[0] !== 13) {
+            bytes.push(buffer[0] ?? 0);
+        }
+    }
+    return Buffer.from(bytes).toString('utf8');
+}
+function writeProjectProfileMapping(projectRoot, profile) {
+    const envPath = path.join(projectRoot, constants_1.ENV_FILE_NAME);
+    const existing = fs.existsSync(envPath) ? fs.readFileSync(envPath, 'utf8').replace(/\r\n/g, '\n') : '';
+    const lines = existing.length > 0 ? existing.replace(/\n+$/, '').split('\n') : [];
+    const profileLine = `AGENT_RUN_PROFILE=${profile}`;
+    const index = lines.findIndex((line) => /^\s*AGENT_RUN_PROFILE\s*=/.test(line));
+    if (index >= 0) {
+        lines[index] = profileLine;
+    }
+    else {
+        lines.push(profileLine);
+    }
+    const content = `${lines.join('\n')}\n`;
+    if (content !== existing) {
+        fs.writeFileSync(envPath, content, 'utf8');
+        (0, utils_1.verbose)(`write ${envPath}`);
+    }
 }
 function runEdit(parsed) {
     const projectRoot = activeProject(parsed.targetPath, 'edit');

package/dist/config-tree.js

@@ -153,14 +153,17 @@ function migrateLooseFiles(agentDir, pattern, targetDirName) {
 function starterConfigRootPath() {
     return path.resolve(__dirname, '..', 'examples', 'basic-config', 'agent-config');
 }
-function copySkeletonTree(sourceDir, targetDir) {
+function copySkeletonTree(sourceDir, targetDir, excludedNames = new Set()) {
     fs.mkdirSync(targetDir, { recursive: true });
     const entries = fs.readdirSync(sourceDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
+        if (excludedNames.has(entry.name)) {
+            continue;
+        }
         const sourcePath = path.join(sourceDir, entry.name);
         const targetPath = path.join(targetDir, entry.name === 'gitignore' ? '.gitignore' : entry.name);
         if (entry.isDirectory()) {
-            copySkeletonTree(sourcePath, targetPath);
+            copySkeletonTree(sourcePath, targetPath, excludedNames);
         }
         else if (entry.isFile() && !fs.existsSync(targetPath)) {
             fs.mkdirSync(path.dirname(targetPath), { recursive: true });

package/dist/constants.js

@@ -11,7 +11,7 @@ exports.LIVE_DIR_NAME = 'live';
 exports.CONFIG_ROOT_OVERRIDE_ENV = 'AGENT_RUN_CONFIG_ROOT_OVERRIDE';
 exports.CONFIG_DIR_ENV = 'AGENT_CONFIG_DIR';
 exports.VERBOSE_ENV = 'AGENT_RUN_VERBOSE';
-exports.PACKAGE_VERSION = '0.99.25';
+exports.PACKAGE_VERSION = '0.99.28';
 exports.UNEXPANDED_TEMPLATE_RE = /\{\{[^}]+\}\}|\{%[^%]+%\}/;
 exports.LOCAL_AI_FILE_NAMES = new Set([
     'AGENTS.md',

package/dist/project.js

@@ -164,6 +164,11 @@ function profileFromPackage(projectRoot) {
     if (fs.existsSync(packagePath)) {
         try {
             const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+            const repositoryProfile = parsePackageRepositoryProfile(pkg.repository);
+            if (repositoryProfile !== null) {
+                (0, utils_1.verbose)(`using package.json repository profile=${repositoryProfile}`);
+                return parseProfile(repositoryProfile, `${packagePath} repository`);
+            }
             if (typeof pkg.name === 'string' && pkg.name.length > 0) {
                 (0, utils_1.verbose)(`using package.json name=${pkg.name}`);
                 return parseProfile(pkg.name.startsWith('@') ? pkg.name.slice(1) : pkg.name, `${packagePath} name`);
@@ -173,10 +178,37 @@ function profileFromPackage(projectRoot) {
             return { profile: null, reason: `cannot parse package.json: ${packagePath}` };
         }
     }
-    return {
-        profile: null,
-        reason: `cannot resolve agent profile for ${projectRoot}; add ${constants_1.ENV_FILE_NAME} with AGENT_RUN_PROFILE=<org/project>, add a GitHub origin remote, or set package.json.name`
-    };
+    const current = path.basename(projectRoot);
+    const parentDir = path.dirname(projectRoot);
+    const parent = path.basename(parentDir);
+    if (current && parent && parentDir !== projectRoot) {
+        const inferredProfile = `${parent}/${current}`;
+        (0, utils_1.verbose)(`using project path profile=${inferredProfile}`);
+        return parseProfile(inferredProfile, 'project parent and directory name');
+    }
+    return { profile: null, reason: `cannot resolve agent profile from project path: ${projectRoot}` };
+}
+function parsePackageRepositoryProfile(repository) {
+    let repositoryPath = null;
+    if (typeof repository === 'string') {
+        repositoryPath = repository;
+    }
+    else if (repository !== null && typeof repository === 'object' && 'url' in repository) {
+        const url = repository.url;
+        if (typeof url === 'string') {
+            repositoryPath = url;
+        }
+    }
+    if (repositoryPath === null) {
+        return null;
+    }
+    const value = repositoryPath.trim();
+    const githubProfile = parseGitHubRemoteProfile(value.replace(/^git\+/, ''));
+    if (githubProfile !== null) {
+        return githubProfile;
+    }
+    const shorthand = /^(?:github:)?([^/:\s]+)\/([^/\s]+?)(?:\.git)?$/.exec(value);
+    return shorthand?.[1] && shorthand[2] ? `${shorthand[1]}/${shorthand[2]}` : null;
 }
 function resolveGitHubProfile(projectRoot) {
     const result = childProcess.spawnSync('git', ['-C', projectRoot, 'config', '--get', 'remote.origin.url'], {
@@ -266,17 +298,11 @@ function defaultConfigRoot(projectRoot, options = {}) {
     if (explicit !== null) {
         return explicit;
     }
-    if (projectRoot) {
-        const projectConfigRoot = defaultCodeConfigRoot(projectRoot);
-        if (options.preferProjectRoot || fs.existsSync(projectConfigRoot)) {
-            return projectConfigRoot;
-        }
-        return findExistingConfigRoot(defaultConfigRootSearchCandidates()) ?? projectConfigRoot;
-    }
-    return findExistingConfigRoot(defaultConfigRootSearchCandidates()) ?? path.join(os.homedir(), '.agent-config');
+    void options;
+    return path.join(os.homedir(), '.agent-run');
 }
 function explicitConfigRoot(projectRoot) {
-    for (const value of [process.env[constants_1.CONFIG_ROOT_OVERRIDE_ENV], process.env[constants_1.CONFIG_DIR_ENV], process.env.AGENT_CONFIG_ROOT]) {
+    for (const value of [process.env[constants_1.CONFIG_ROOT_OVERRIDE_ENV], process.env[constants_1.CONFIG_DIR_ENV]]) {
         if (value) {
             return path.resolve(value);
         }
@@ -285,21 +311,9 @@ function explicitConfigRoot(projectRoot) {
         return null;
     }
     const env = readAgentRunEnv(projectRoot);
-    const localValue = env[constants_1.CONFIG_DIR_ENV]?.trim() || env.AGENT_CONFIG_ROOT?.trim();
+    const localValue = env[constants_1.CONFIG_DIR_ENV]?.trim();
     return localValue ? path.resolve(projectRoot, localValue) : null;
 }
-function defaultCodeConfigRoot(projectRoot) {
-    const resolvedProjectRoot = path.resolve(projectRoot);
-    const ownerDir = path.dirname(resolvedProjectRoot);
-    const codeRoot = path.dirname(ownerDir);
-    if (ownerDir === resolvedProjectRoot || codeRoot === ownerDir) {
-        return path.join(os.homedir(), '.agent-config');
-    }
-    return path.join(codeRoot, 'agent-config');
-}
-function findExistingConfigRoot(candidates) {
-    return candidates.find((candidate) => fs.existsSync(candidate)) ?? null;
-}
 function defaultConfigRootSearchCandidates(_projectRoot, options = {}) {
     const platform = options.platform ?? process.platform;
     const pathApi = platform === 'win32' ? path.win32 : path.posix;

package/dist/renderer.js

@@ -101,11 +101,18 @@ function syncAgentProfile(projectRoot, agentDir, options) {
 }
 function writeGeneratedFile(filePath, content, executable) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, content, 'utf8');
+    const unchanged = fs.existsSync(filePath) && fs.readFileSync(filePath, 'utf8') === content;
+    if (!unchanged) {
+        fs.writeFileSync(filePath, content, 'utf8');
+        (0, utils_1.verbose)(`write ${filePath}`);
+    }
     if (executable && !constants_1.IS_WINDOWS) {
-        fs.chmodSync(filePath, 0o755);
+        const currentMode = fs.statSync(filePath).mode & 0o777;
+        if (currentMode !== 0o755) {
+            fs.chmodSync(filePath, 0o755);
+            (0, utils_1.verbose)(`chmod 755 ${filePath}`);
+        }
     }
-    (0, utils_1.verbose)(`write ${filePath}`);
 }
 function removeStaleGeneratedEntries(rendered) {
     const expectedFiles = new Set(rendered.files.map((file) => path.resolve(file.path)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@technomoron/agent-run",
-  "version": "0.99.26",
+  "version": "0.99.28",
   "packageManager": "pnpm@10.28.1",
   "bin": {
     "agent-run": "dist/agent-run.js"