@yunhozz/arc 0.0.0-stage → 0.1.1

package/codex/skill/scripts/model_config.py

@@ -0,0 +1,362 @@
+"""Load ARC model settings and render model fields into TOML profiles."""
+
+from __future__ import annotations
+
+import json
+import re
+import tomllib
+import unicodedata
+from pathlib import Path
+from typing import TypedDict
+
+
+ROLE_FILES: dict[str, str] = {
+    "arc_scouter": "arc-scouter.toml",
+    "arc_planner": "arc-planner.toml",
+    "arc_coder": "arc-coder.toml",
+    "arc_qa": "arc-qa.toml",
+    "arc_reviewer": "arc-reviewer.toml",
+}
+
+
+class RoleSettings(TypedDict):
+    model: str
+    model_reasoning_effort: str
+
+
+class ValidationError(Exception):
+    """An invalid model settings file or agent profile."""
+
+
+_MODEL_FIELDS = ("model", "model_reasoning_effort")
+_BARE_KEY = re.compile(r"[A-Za-z0-9_-]+")
+_STRING_ASSIGNMENT = re.compile(
+    r"(?P<prefix>[ \t]*(?:model|model_reasoning_effort|\"model\"|\"model_reasoning_effort\"|"
+    r"'model'|'model_reasoning_effort')[ \t]*=[ \t]*)"
+    r'(?P<literal>"(?:\\.|[^"\\\r\n])*"|\x27[^\x27\r\n]*\x27)'
+    r"(?P<tail>[ \t]*(?:\#[^\r\n]*)?)(?P<newline>\r?\n)?\Z"
+)
+
+
+def _error(path: Path, key: str, message: str) -> ValidationError:
+    return ValidationError(f"{path}: {key}: {message}")
+
+
+def _validated_string(value: object, path: Path, key: str) -> str:
+    if not isinstance(value, str):
+        raise _error(path, key, "must be a string")
+    if not value or value != value.strip():
+        raise _error(path, key, "must be nonempty and have no surrounding whitespace")
+    if any(unicodedata.category(char) == "Cc" or char in "\u2028\u2029" for char in value):
+        raise _error(path, key, "must not contain control characters or line breaks")
+    return value
+
+
+def _decode_toml(content: bytes, path: Path, label: str) -> tuple[str, dict]:
+    try:
+        text = content.decode("utf-8")
+    except UnicodeDecodeError as exc:
+        raise _error(path, label, f"is not valid UTF-8: {exc}") from exc
+    try:
+        parsed = tomllib.loads(text)
+    except tomllib.TOMLDecodeError as exc:
+        raise _error(path, label, f"is not valid TOML: {exc}") from exc
+    return text, parsed
+
+
+def _parse_file(path: Path, label: str) -> tuple[bytes, str, dict]:
+    try:
+        content = path.read_bytes()
+    except OSError as exc:
+        raise _error(path, label, f"cannot read file: {exc}") from exc
+    text, parsed = _decode_toml(content, path, label)
+    return content, text, parsed
+
+
+PRESETS = ("economy", "balanced", "smart")
+
+
+def validate_config(config: dict, path: Path) -> dict:
+    if not isinstance(config, dict) or set(config) != {"version", "preset", "roles"} or type(config["version"]) is not int or config["version"] != 1:
+        raise _error(path, "settings", "update to version 1 unified presets; reinstall ARC or edit models.toml to include preset and all role presets")
+    if not isinstance(config["preset"], str) or config["preset"] not in PRESETS:
+        raise _error(path, "preset", "must be economy, balanced or smart")
+    roles = config["roles"]
+    if not isinstance(roles, dict) or set(roles) != set(ROLE_FILES):
+        raise _error(path, "roles", "must define exactly the five ARC roles")
+    for role, variants in roles.items():
+        if not isinstance(variants, dict) or set(variants) != set(PRESETS):
+            raise _error(path, f"roles.{role}", "must contain exactly economy, balanced and smart")
+        for preset, values in variants.items():
+            _settings_for_profile(values, f"{role}.{preset}", path)
+    return config
+
+
+def load_settings(config_path: Path) -> dict[str, RoleSettings]:
+    """Validate every preset and return the active role settings."""
+    _, _, config = _parse_file(config_path, "settings")
+    validate_config(config, config_path)
+    return {role: dict(variants[config["preset"]]) for role, variants in config["roles"].items()}
+
+
+def serialize_settings(config: dict) -> bytes:
+    """Serialize a complete unified configuration without losing inactive presets."""
+    validate_config(config, Path("models.toml"))
+    lines = ["version = 1", f'preset = {json.dumps(config["preset"])}']
+    for role in ROLE_FILES:
+        for preset in PRESETS:
+            lines.extend(["", f"[roles.{role}.{preset}]"])
+            lines.extend(f"{key} = {json.dumps(config['roles'][role][preset][key], ensure_ascii=False)}" for key in _MODEL_FIELDS)
+    return ("\n".join(lines) + "\n").encode("utf-8")
+
+
+def _physical_lines(text: str) -> list[tuple[str, int]]:
+    """Return physical LF/CRLF lines with their starting character offsets."""
+    lines: list[tuple[str, int]] = []
+    start = 0
+    while start < len(text):
+        newline = text.find("\n", start)
+        end = len(text) if newline < 0 else newline + 1
+        lines.append((text[start:end], start))
+        start = end
+    return lines
+
+
+def _quoted_key_value(token: str) -> str | None:
+    try:
+        parsed = tomllib.loads(f"{token} = 0")
+    except tomllib.TOMLDecodeError:
+        return None
+    if len(parsed) != 1:
+        return None
+    return next(iter(parsed))
+
+
+def _assignment_key(line: str) -> str | None:
+    """Read one root assignment key token from a line, if it is a plain assignment."""
+    cursor = len(line) - len(line.lstrip(" \t"))
+    if cursor >= len(line) or line[cursor] == "#":
+        return None
+    start = cursor
+    first = line[cursor]
+    if first in "\"'":
+        quote = first
+        cursor += 1
+        while cursor < len(line):
+            char = line[cursor]
+            if quote == '"' and char == "\\":
+                cursor += 2
+                continue
+            if char == quote:
+                cursor += 1
+                break
+            if char in "\r\n":
+                return None
+            cursor += 1
+        else:
+            return None
+    else:
+        match = _BARE_KEY.match(line, cursor)
+        if match is None:
+            return None
+        cursor = match.end()
+    token = line[start:cursor]
+    while cursor < len(line) and line[cursor] in " \t":
+        cursor += 1
+    if cursor >= len(line) or line[cursor] != "=":
+        return None
+    return token if token in _MODEL_FIELDS else _quoted_key_value(token)
+
+
+def _multiline_close(line: str, quote: str, basic: bool) -> int | None:
+    """Find a TOML multiline string terminator in a physical line."""
+    cursor = 0
+    while cursor < len(line):
+        start = line.find(quote, cursor)
+        if start < 0:
+            return None
+        end = start
+        while end < len(line) and line[end] == quote[0]:
+            end += 1
+        count = end - start
+        if count >= 3:
+            close_start = end - 3
+            if basic:
+                slash_count = 0
+                before = close_start - 1
+                while before >= 0 and line[before] == "\\":
+                    slash_count += 1
+                    before -= 1
+                if slash_count % 2:
+                    cursor = end
+                    continue
+            return close_start
+        cursor = end
+    return None
+
+
+def _scan_root(text: str) -> tuple[dict[str, list[int]], int | None]:
+    """Locate model assignments before the first real table header."""
+    assignments: dict[str, list[int]] = {key: [] for key in _MODEL_FIELDS}
+    square_depth = 0
+    brace_depth = 0
+    multiline: str | None = None
+    multiline_basic = False
+    lines = _physical_lines(text)
+
+    for index, (physical, offset) in enumerate(lines):
+        body = physical[:-2] if physical.endswith("\r\n") else physical[:-1] if physical.endswith("\n") else physical
+        if multiline is None and square_depth == 0 and brace_depth == 0:
+            first = len(body) - len(body.lstrip(" \t"))
+            if first < len(body) and body[first] == "[":
+                return assignments, offset
+            key = _assignment_key(body)
+            if key in assignments:
+                assignments[key].append(index)
+
+        cursor = 0
+        while cursor < len(body):
+            if multiline is not None:
+                close_at = _multiline_close(body[cursor:], multiline, multiline_basic)
+                if close_at is None:
+                    break
+                cursor += close_at + 3
+                multiline = None
+                multiline_basic = False
+                continue
+
+            char = body[cursor]
+            if char == "#":
+                break
+            if body.startswith('"""', cursor) or body.startswith("'''", cursor):
+                multiline = body[cursor : cursor + 3]
+                multiline_basic = multiline == '"""'
+                cursor += 3
+                continue
+            if char == '"' or char == "'":
+                quote = char
+                cursor += 1
+                while cursor < len(body):
+                    if quote == '"' and body[cursor] == "\\":
+                        cursor += 2
+                    elif body[cursor] == quote:
+                        cursor += 1
+                        break
+                    else:
+                        cursor += 1
+                continue
+            if char == "[":
+                square_depth += 1
+            elif char == "]":
+                square_depth = max(0, square_depth - 1)
+            elif char == "{":
+                brace_depth += 1
+            elif char == "}":
+                brace_depth = max(0, brace_depth - 1)
+            cursor += 1
+
+    return assignments, None
+
+
+def _profile_parts(profile_bytes: bytes, role: str, source_path: Path) -> tuple[str, dict, dict[str, list[int]], int | None, list[tuple[str, int]]]:
+    if role not in ROLE_FILES:
+        raise _error(source_path, "role", f"unknown ARC role {role!r}")
+    text, profile = _decode_toml(profile_bytes, source_path, "profile")
+    if profile.get("name") != role:
+        raise _error(source_path, "name", f"expected profile name {role!r}, found {profile.get('name')!r}")
+    assignments, first_table = _scan_root(text)
+    return text, profile, assignments, first_table, _physical_lines(text)
+
+
+def validate_template(profile_bytes: bytes, role: str, source_path: Path) -> None:
+    """Validate a model-free source profile template without modifying it."""
+    _, profile, assignments, _, _ = _profile_parts(profile_bytes, role, source_path)
+    for key in _MODEL_FIELDS:
+        if key in profile or assignments[key]:
+            raise _error(source_path, key, "must be absent from the root of a source template")
+
+
+def _settings_for_profile(settings: RoleSettings, role: str, source_path: Path) -> RoleSettings:
+    if not isinstance(settings, dict) or set(settings) != set(_MODEL_FIELDS):
+        raise _error(source_path, f"roles.{role}", "must contain only 'model' and 'model_reasoning_effort'")
+    return {
+        "model": _validated_string(settings["model"], source_path, f"roles.{role}.model"),
+        "model_reasoning_effort": _validated_string(
+            settings["model_reasoning_effort"], source_path, f"roles.{role}.model_reasoning_effort"
+        ),
+    }
+
+
+def _newline(text: str) -> str:
+    match = re.search(r"\r\n|\n", text)
+    return match.group(0) if match else "\n"
+
+
+def _replace_line_literal(line: str, key: str, value: str, source_path: Path) -> str:
+    match = _STRING_ASSIGNMENT.fullmatch(line)
+    if match is None:
+        raise _error(source_path, key, "must be a one-line quoted string assignment")
+    prefix = match.group("prefix")
+    # A quoted key may resolve to this name while using a noncanonical escape;
+    # that form is valid TOML but not safe to edit textually.
+    key_text = prefix.split("=", 1)[0].strip()
+    if key_text not in (key, f'"{key}"', f"'{key}'"):
+        raise _error(source_path, key, "uses an unsupported quoted key spelling")
+    try:
+        current = tomllib.loads(f"{key} = {match.group('literal')}\n")[key]
+    except tomllib.TOMLDecodeError as exc:
+        raise _error(source_path, key, f"cannot parse quoted string assignment: {exc}") from exc
+    if not isinstance(current, str):
+        raise _error(source_path, key, "must be a quoted string assignment")
+    if current == value:
+        return line
+    return prefix + json.dumps(value, ensure_ascii=False) + match.group("tail") + (match.group("newline") or "")
+
+
+def render_profile(profile_bytes: bytes, role: str, settings: RoleSettings, source_path: Path) -> bytes:
+    """Return valid profile TOML bytes with the role's model fields rendered."""
+    text, profile, assignments, first_table, lines = _profile_parts(profile_bytes, role, source_path)
+    validated_settings = _settings_for_profile(settings, role, source_path)
+    line_values = [line for line, _ in lines]
+    missing: list[str] = []
+
+    for key in _MODEL_FIELDS:
+        present = key in profile
+        found = assignments[key]
+        if not present:
+            if found:
+                raise _error(source_path, key, "root assignment could not be matched to the parsed TOML value")
+            missing.append(key)
+            continue
+        if not isinstance(profile[key], str):
+            raise _error(source_path, key, "root value must be a one-line quoted string assignment")
+        if len(found) != 1:
+            raise _error(source_path, key, f"expected one safe root assignment, found {len(found)}")
+        index = found[0]
+        updated = _replace_line_literal(line_values[index], key, validated_settings[key], source_path)
+        line_values[index] = updated
+
+    rendered = "".join(line_values)
+    if missing:
+        newline = _newline(text)
+        addition = newline.join(f"{key} = {json.dumps(validated_settings[key], ensure_ascii=False)}" for key in missing)
+        addition += newline
+        if first_table is not None:
+            table_line = next(index for index, (_, offset) in enumerate(lines) if offset == first_table)
+            insertion = sum(len(line) for line in line_values[:table_line])
+            prefix = rendered[:insertion]
+            if prefix and not prefix.endswith(("\n", "\r")):
+                addition = newline + addition
+            rendered = rendered[:insertion] + addition + rendered[insertion:]
+        else:
+            if rendered and not rendered.endswith(("\n", "\r")):
+                addition = newline + addition
+            rendered += addition
+
+    try:
+        checked = tomllib.loads(rendered)
+    except tomllib.TOMLDecodeError as exc:
+        raise _error(source_path, "rendered profile", f"is not valid TOML: {exc}") from exc
+    if checked.get("name") != role or any(checked.get(key) != value for key, value in validated_settings.items()):
+        raise _error(source_path, "rendered profile", "does not match the validated role and model settings")
+    return rendered.encode("utf-8")

package/install.command

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+exec node "$SCRIPT_DIR/bin/arc.mjs" "$@"

package/lib/cli/choices.mjs

@@ -0,0 +1,47 @@
+import readline from 'node:readline';
+import {EventEmitter} from 'node:events';
+function inputError(message){return Object.assign(new Error(message),{code:'ARC_CLI_INPUT'});}
+function cancelled(){return Object.assign(new Error('Installation cancelled.'),{code:'ARC_CANCELLED'});}
+export async function selectChoices(options,{input=process.stdin,output=process.stdout,targetOnly=false,languageDefault}={}){
+ if(languageDefault===undefined&&options.target&&(targetOnly||options.preset)||languageDefault!==undefined&&options.language)return options;
+ if(!input.isTTY||!output.isTTY)throw inputError(targetOnly?'Non-interactive execution requires --target':'Non-interactive execution requires --target and --preset');
+ const menus=languageDefault!==undefined?[['language',['English','한국어'],['en','ko'],languageDefault==='ko'?1:0]]:[['target',['Claude','Codex','All'],['claude','codex','all'],0],['preset',['Economy','Balanced','Smart'],['economy','balanced','smart'],1]].filter(([key])=>!options[key]&&(!targetOnly||key==='target'));
+ const wasRaw=input.isRaw,wasFlowing=input.readableFlowing,listeners=new Map(['data','newListener'].map(event=>[event,input.listeners(event)]));
+ let menu=0,index=menus[0][3];
+ const draw=(redraw=false)=>{const [key,labels]=menus[menu];if(redraw)output.write(`\x1b[${labels.length}A\r`);else output.write(`Select ${key==='target'?'an installation target':key==='language'?'an output language':'a performance preset'} [Up/Down]:\n`);output.write(labels.map((label,i)=>`\x1b[2K${i===index?'>':' '} ${label}`).join('\n')+'\n');};
+ const keys=new EventEmitter();let onKey,onData,onEnd,onError,abort;
+ try{return await new Promise((resolve,reject)=>{
+  abort=()=>reject(cancelled());onEnd=abort;onError=reject;
+  onKey=(str,key={})=>{try{if(key.name==='c'&&key.ctrl||key.name==='d'&&key.ctrl)return abort();if(key.name==='up'||key.name==='down'){index=(index+(key.name==='up'?-1:1)+menus[menu][1].length)%menus[menu][1].length;draw(true);}else if(key.name==='return'||key.name==='enter'){const [name,,values]=menus[menu];options[name]=values[index];output.write('\n');if(++menu===menus.length){keys.removeListener('keypress',onKey);resolve(options);}else{index=menus[menu][3];draw();}}}catch(error){reject(error);}};
+  keys.on('keypress',onKey);readline.emitKeypressEvents(keys);onData=chunk=>keys.emit('data',chunk);input.on('data',onData);input.once('end',onEnd);input.once('error',onError);process.once('SIGINT',abort);
+  if(input.setRawMode)input.setRawMode(true);input.resume();draw();
+ });}finally{
+  keys.removeAllListeners();input.removeListener('data',onData);input.removeListener('end',onEnd);input.removeListener('error',onError);process.removeListener('SIGINT',abort);
+  for(const [event,before]of listeners)for(const listener of input.listeners(event))if(!before.includes(listener))input.removeListener(event,listener);
+  if(input.setRawMode)input.setRawMode(Boolean(wasRaw));if(wasFlowing!==true)input.pause();
+ }
+}
+
+export async function selectLimits(options,selections,{input=process.stdin,output=process.stdout}={}){
+ const{parsePositiveLimit}=await import('../limits.mjs');
+ const fields=[['maxTotalSubagents','max_total_subagents',100,'total'],['maxConcurrentSubagents','max_concurrent_subagents',5,'concurrent']].filter(([key])=>options[key]===undefined);
+ if(!fields.length)return options;
+ const wasRaw=input.isRaw,wasFlowing=input.readableFlowing,listeners=new Map(['data','newListener'].map(event=>[event,input.listeners(event)]));
+ let index=0,value='',onKey,onData,onEnd,onError,abort;
+ const draw=()=>{const[,,fallback,label]=fields[index];output.write(`Maximum ${label} subagents [Default=${fallback}]: `);};
+ try{return await new Promise((resolve,reject)=>{
+  abort=()=>reject(cancelled());onEnd=abort;onError=reject;
+  onKey=(str,key={})=>{if(key.ctrl&&(key.name==='c'||key.name==='d'))return abort();if(key.name==='return'||key.name==='enter'){
+   const[name,,,label]=fields[index];if(value.trim()){try{options[name]=parsePositiveLimit(value,label);}catch(cause){output.write(`\n${cause.message}\n`);value='';draw();return;}}
+   if(name==='maxConcurrentSubagents')options.concurrentSelected=true;output.write('\n');value='';if(++index===fields.length){input.removeListener('keypress',onKey);resolve(options);}else draw();
+  }else if(key.name==='backspace'){value=value.slice(0,-1);output.write('\b \b');}else if(str&&!key.ctrl&&!key.meta){value+=str;output.write(str);}};
+  onData=chunk=>{for(const character of chunk.toString()){if(index===fields.length)break;const name=character==='\r'||character==='\n'?'return':character==='\x03'?'c':character==='\x04'?'d':character==='\x7f'||character==='\b'?'backspace':undefined;onKey(character,{name,ctrl:character==='\x03'||character==='\x04'});}};
+  input.on('data',onData);input.once('end',onEnd);input.once('error',onError);process.once('SIGINT',abort);if(input.setRawMode)input.setRawMode(true);input.resume();draw();
+ });}finally{
+  input.removeListener('data',onData);input.removeListener('end',onEnd);input.removeListener('error',onError);process.removeListener('SIGINT',abort);
+  for(const[event,before]of listeners)for(const listener of input.listeners(event))if(!before.includes(listener))input.removeListener(event,listener);
+  if(input.setRawMode)input.setRawMode(Boolean(wasRaw));if(wasFlowing!==true)input.pause();
+ }
+}
+
+export async function selectLanguage(options,languageDefault,io={}){return selectChoices(options,{...io,languageDefault});}

package/lib/cli/completion.mjs

@@ -0,0 +1,53 @@
+export function renderCompletion(shell){
+ if(shell==='bash')return `_arc() {
+ local cur="\${COMP_WORDS[COMP_CWORD]}" prev="\${COMP_WORDS[COMP_CWORD-1]}" command="\${COMP_WORDS[1]}" choices=""
+ case "$prev" in
+  --target) choices="claude codex all" ;;
+  --preset) choices="economy balanced smart" ;;
+  --language) choices="en ko" ;;
+  *)
+   if (( COMP_CWORD == 1 )) && [[ $cur != -* ]]; then choices="preset uninstall"
+   else
+    case "$command" in
+     preset)
+      if (( COMP_CWORD == 2 )) && [[ $cur != -* ]]; then choices="economy balanced smart"
+      else choices="--target --check --dry-run --help"; fi ;;
+     uninstall) choices="--target --dry-run --skip-global --help --version" ;;
+     completion) (( COMP_CWORD == 2 )) && choices="zsh bash" ;;
+     -*) choices="--target --preset --language --max-total-subagents --max-concurrent-subagents --check --dry-run --skip-global --help --version" ;;
+    esac
+   fi ;;
+ esac
+ COMPREPLY=( $(compgen -W "$choices" -- "$cur") )
+}
+complete -F _arc arc
+`;
+ if(shell==='zsh')return `_arc() {
+ local -a candidates
+ if (( CURRENT == 2 )) && [[ \${words[CURRENT]} != -* ]]; then
+  candidates=(preset uninstall)
+ else
+  case "\${words[CURRENT-1]}" in
+   --target) candidates=(claude codex all) ;;
+   --preset) candidates=(economy balanced smart) ;;
+   --language) candidates=(en ko) ;;
+   *) case "\${words[2]}" in
+    preset)
+     if (( CURRENT == 3 )) && [[ \${words[CURRENT]} != -* ]]; then candidates=(economy balanced smart)
+     else candidates=(--target --check --dry-run --help); fi ;;
+    uninstall) candidates=(--target --dry-run --skip-global --help --version) ;;
+    completion) (( CURRENT == 3 )) && candidates=(zsh bash) ;;
+    -*) candidates=(--target --preset --language --max-total-subagents --max-concurrent-subagents --check --dry-run --skip-global --help --version) ;;
+   esac ;;
+  esac
+ fi
+ compadd -a candidates
+}
+if (( ! $+functions[compdef] )); then
+ autoload -Uz compinit
+ compinit -D
+fi
+compdef _arc arc
+`;
+ throw new Error('Unsupported completion shell');
+}

package/lib/cli/index.mjs

@@ -0,0 +1,55 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+const packageRoot=fileURLToPath(new URL('../../',import.meta.url));
+import{parsePositiveLimit}from'../limits.mjs';
+const usage='Usage: arc --target <claude|codex|all> --preset <economy|balanced|smart> --language <en|ko>\n  [--max-total-subagents <count>] [--max-concurrent-subagents <count>]\n  [--check | --dry-run] [--skip-global] [--help] [--version]\n  --max-total-subagents: positive integer (default: 100)\n  --max-concurrent-subagents: positive integer (default: 5)';
+function inputError(message){return Object.assign(new Error(message),{code:'ARC_CLI_INPUT'});}
+function cancelled(){return Object.assign(new Error('Installation cancelled.'),{code:'ARC_CANCELLED'});}
+export function parseArgs(args){
+ const options={},seen=new Set();const names={'--max-total-subagents':'maxTotalSubagents','--max-concurrent-subagents':'maxConcurrentSubagents','--target':'target','--preset':'preset','--language':'language','--skip-global':'skipGlobal','--check':'check','--dry-run':'dryRun','--help':'help','--version':'version'};
+ for(let i=0;i<args.length;i++){const flag=args[i],key=Object.hasOwn(names,flag)?names[flag]:undefined;if(!key)throw inputError(`Unknown argument: ${flag}`);if(seen.has(flag))throw inputError(`Duplicate argument: ${flag}`);seen.add(flag);if(key==='maxTotalSubagents'||key==='maxConcurrentSubagents'){try{options[key]=parsePositiveLimit(args[++i],flag);}catch(cause){throw inputError(cause.message);}}else if(key==='target'||key==='preset'||key==='language'){const value=args[++i],allowed=key==='target'?['claude','codex','all']:key==='preset'?['economy','balanced','smart']:['en','ko'];if(!allowed.includes(value))throw inputError(`Invalid ${key}: ${value??'missing value'}`);options[key]=value;}else options[key]=true;}
+ if(options.check&&options.dryRun)throw inputError('--check and --dry-run cannot be combined');return options;
+}
+export async function selectChoices(options,io){return(await import('./choices.mjs')).selectChoices(options,io);}
+export async function runCli(args=process.argv.slice(2),{input=process.stdin,output=process.stdout,error=process.stderr}={}){
+ let controller,onInterrupt,progress;
+ try{
+  const options=parseArgs(args);if(options.help){output.write(usage+'\n');return 0;}if(options.version){output.write(JSON.parse(fs.readFileSync(path.join(packageRoot,'package.json'))).version+'\n');return 0;}
+  if((!input.isTTY||!output.isTTY)&&(!options.target||!options.preset||!options.language))throw inputError('Non-interactive execution requires --target, --preset and --language');
+  await selectChoices(options,{input,output});
+  const {startProgress}=await import('./progress.mjs');
+  const interactive=input.isTTY&&output.isTTY,label=options.check?'Checking ARC…':options.dryRun?'Preparing ARC dry run…':'Installing ARC…';
+  if(!interactive)progress=startProgress({output,label});
+  controller=new AbortController();onInterrupt=()=>controller.abort();process.once('SIGINT',onInterrupt);
+  const {loadNative}=await import('../safe-fs/native.mjs');const native=loadNative();
+  const [{openRoot},{verifyPayload},{resolveTarget},{buildInstallPlan,validatePlanSet}]=await Promise.all([import('../safe-fs/index.mjs'),import('../installer/manifest.mjs'),import('../installer/targets.mjs'),import('../installer/plan.mjs')]);
+  const safeFs={openRoot:p=>openRoot(p,{native})},payload=verifyPayload({packageRoot,safeFs});
+  const platforms=options.target==='all'?['codex','claude']:[options.target];
+  const {previewLimits,previewLanguage}=await import('../installer/plan.mjs');const{defaultLanguage}=await import('../installer/language.mjs');const selections=platforms.map(platform=>{const target=resolveTarget(platform,{userHome:os.homedir(),env:process.env});return{target,preview:previewLimits({target,safeFs}),languagePreview:previewLanguage({target,safeFs})};});
+  if(interactive){const{selectLimits,selectLanguage}=await import('./choices.mjs');await selectLimits(options,selections,{input,output});await selectLanguage(options,defaultLanguage(selections.map(item=>item.languagePreview.existing)),{input,output});}
+  progress??=startProgress({output,label});
+  const plans=selections.map(({target,preview,languagePreview})=>buildInstallPlan({payload,target,language:options.language,languagePreview,preset:options.preset,skipGlobal:options.skipGlobal,safeFs,limitsPreview:preview,limits:{...(options.maxTotalSubagents===undefined?{}:{max_total_subagents:options.maxTotalSubagents}),...(options.maxConcurrentSubagents===undefined?{}:{max_concurrent_subagents:options.maxConcurrentSubagents})},concurrentExplicit:options.maxConcurrentSubagents!==undefined||Boolean(options.concurrentSelected)}));const {attachShellCompletion}=await import('../installer/shell-completion.mjs');attachShellCompletion(plans,{safeFs});validatePlanSet(plans);
+  const languageLabel=options.language==='ko'?'한국어':'English';
+  progress.write(`Install: ${platforms.join('/')} · ${options.preset} · ${languageLabel}\n`);
+  for(const plan of plans)progress.write(`${plan.target.platform}: ${plan.target.home} · total ${plan.limits.max_total_subagents} · concurrent ${plan.limits.max_concurrent_subagents}\n`);
+  if(options.skipGlobal)progress.write('Global settings: skipped\n');
+  else progress.write('zsh completion: eval "$(arc completion zsh)" for this session\n');
+  if(plans.some(plan=>plan.limits.max_concurrent_subagents>plan.limits.max_total_subagents))progress.write(`Note: fresh ARC sessions cap concurrency at ${Math.min(...plans.map(plan=>plan.limits.max_total_subagents))}.\n`);
+  if(options.dryRun)for(const plan of plans){
+   for(const name of plan.generated.skill.keys())progress.write(`Would write file: ${path.join(plan.target.home,'skills/arc',name)}\n`);
+   for(const name of plan.generated.profiles.keys())progress.write(`Would write file: ${path.join(plan.target.home,'agents',name)}\n`);
+   for(const change of plan.globalChanges)progress.write(`Would update global file: ${change.path}\n`);
+  }
+  if(options.check||options.dryRun){progress.stop();output.write(options.check?'Check completed. No changes made.\n':'Dry run completed. No changes made.\n');return 0;}
+  const [{installTargets},{acquireExternalSkills}]=await Promise.all([import('../installer/install.mjs'),import('../installer/acquisition.mjs')]);
+  const result=await installTargets(plans,{safeFs,signal:controller.signal,acquisition:async()=>{const work=fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()),'arc-acquire-'));const acquired=await acquireExternalSkills({work,safeFs,signal:controller.signal});const dispose=acquired.dispose;return{...acquired,dispose:async()=>{await dispose();fs.rmdirSync(work);}};}});
+  progress.stop();
+  const reportResults=()=>{for(const item of result.results){output.write(`${item.platform}: ${item.status}; rollback: ${item.rollback}\n`);for(const recovery of item.residualPaths)output.write(`Residual path: ${recovery}\n`);if(item.error)error.write(`Error: ${item.error.message}\n`);}};
+  if(result.interrupted){reportResults();return 130;}
+  if(result.results.every(item=>item.status==='installed'&&!item.error)){output.write(`ARC installed! [${result.results.map(item=>item.platform).join('/')}]\n`);return 0;}
+  reportResults();return 1;
+ }catch(cause){progress?.stop();error.write(`Error: ${cause.message}\n`);if(cause.code==='ARC_CLI_INPUT'){error.write(usage+'\n');return 2;}if(cause.code==='ARC_CANCELLED')return 130;return ['ARC_UNSUPPORTED_RUNTIME','ARC_NATIVE_UNAVAILABLE','ARC_TARGET_CONFIGURATION'].includes(cause.code)?2:1;
+ }finally{progress?.stop();if(onInterrupt)process.removeListener('SIGINT',onInterrupt);}
+}

package/lib/cli/preset.mjs

@@ -0,0 +1,29 @@
+import os from 'node:os';
+import {validatePlanSet} from '../installer/plan.mjs';
+import {selectChoices} from './choices.mjs';
+const usage='Usage: arc preset [economy|balanced|smart] --target <codex|claude|all> [--check | --dry-run] [--help]';
+const inputError=message=>Object.assign(new Error(message),{code:'ARC_CLI_INPUT'});
+export function parseArgs(args){
+ const options={},seen=new Set();
+ for(let i=0;i<args.length;i++){
+  const arg=args[i];if(['economy','balanced','smart'].includes(arg)){if(options.preset)throw inputError('Duplicate preset');options.preset=arg;continue;}
+  if(!['--target','--check','--dry-run','--help'].includes(arg))throw inputError(`Unknown argument: ${arg}`);if(seen.has(arg))throw inputError(`Duplicate argument: ${arg}`);seen.add(arg);
+  if(arg==='--target'){const value=args[++i];if(!['codex','claude','all'].includes(value))throw inputError('Invalid target');options.target=value;}else options[arg==='--dry-run'?'dryRun':arg.slice(2)]=true;
+ }
+ if(options.check&&options.dryRun)throw inputError('--check and --dry-run cannot be combined');return options;
+}
+export async function runCli(args=process.argv.slice(2),{input=process.stdin,output=process.stdout,error=process.stderr}={}){
+ let onInterrupt;
+ try{
+  const options=parseArgs(args);if(options.help){output.write(usage+'\n');return 0;}
+  await selectChoices(options,{input,output});
+  const[{loadNative},{openRoot},{resolveTarget},{buildPresetPlan,switchPresetTargets}]=await Promise.all([import('../safe-fs/native.mjs'),import('../safe-fs/index.mjs'),import('../installer/targets.mjs'),import('../installer/preset.mjs')]);
+  const native=loadNative(),safeFs={openRoot:p=>openRoot(p,{native})};
+  const plans=(options.target==='all'?['codex','claude']:[options.target]).map(platform=>buildPresetPlan({target:resolveTarget(platform,{userHome:os.homedir(),env:process.env}),preset:options.preset,safeFs}));
+  validatePlanSet(plans);
+  if(options.check||options.dryRun){for(const plan of plans){output.write(`${plan.target.platform}: ${plan.specs.length} file(s) would change\n`);if(options.dryRun)for(const spec of plan.specs)output.write(`Would write: ${spec.path}\n`);}output.write('Check completed. No changes made.\n');return 0;}
+  const controller=new AbortController();onInterrupt=()=>controller.abort();process.once('SIGINT',onInterrupt);const result=await switchPresetTargets(plans,{safeFs,signal:controller.signal});
+  for(const item of result.results){output.write(`${item.platform}: ${item.status}; rollback: ${item.rollback}\n`);for(const name of item.residualPaths)output.write(`Residual path: ${name}\n`);if(item.error)error.write(`Error: ${item.error.message}\n`);}
+  output.write('Open a new session to use the selected preset.\n');return result.interrupted?130:result.results.every(item=>['updated','unchanged'].includes(item.status)&&!item.error)?0:1;
+ }catch(cause){error.write(`Error: ${cause.message}\n`);if(cause.code==='ARC_CLI_INPUT'){error.write(usage+'\n');return 2;}return cause.code==='ARC_CANCELLED'?130:['ARC_UNSUPPORTED_RUNTIME','ARC_NATIVE_UNAVAILABLE','ARC_TARGET_CONFIGURATION'].includes(cause.code)?2:1;}finally{if(onInterrupt)process.removeListener('SIGINT',onInterrupt);}
+}

package/lib/cli/progress.mjs

@@ -0,0 +1,10 @@
+export function startProgress({output,label,intervalMs=80,setInterval=globalThis.setInterval,clearInterval=globalThis.clearInterval}){
+ const frames=['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];let frame=0,stopped=false,timer;
+ const clear=()=>output.write('\r\x1b[2K');
+ const render=()=>output.write(`${frames[frame]} ${label}`);
+ if(output.isTTY){render();timer=setInterval(()=>{clear();frame=(frame+1)%frames.length;render();},intervalMs);}else output.write(label+'\n');
+ return{
+  write(text){if(output.isTTY&&!stopped){clear();output.write(text);render();}else output.write(text);},
+  stop(){if(stopped)return;stopped=true;if(timer!==undefined)clearInterval(timer);if(output.isTTY){clear();output.write('\n');}}
+ };
+}

package/lib/cli/root.mjs

@@ -0,0 +1,20 @@
+import fs from 'node:fs';
+import {renderCompletion} from './completion.mjs';
+const usage='Usage: arc [installation options]\n  arc preset [economy|balanced|smart] --target <codex|claude|all>\n  arc uninstall --target <codex|claude|all>\n  arc completion <zsh|bash>  (shell setup)\n  arc --help | --version';
+const completionUsage='Usage: arc completion <zsh|bash>';
+export async function runRoot(args=process.argv.slice(2),io={}){
+ const output=io.output??process.stdout,error=io.error??process.stderr;
+ const [command,...rest]=args;
+ if(command==='--help'&&!rest.length){output.write(usage+'\n\n');return(await import('./index.mjs')).runCli(args,io);}
+ if(command==='--version'&&!rest.length){output.write(JSON.parse(fs.readFileSync(new URL('../../package.json',import.meta.url))).version+'\n');return 0;}
+ if(command==='preset')return(await import('./preset.mjs')).runCli(rest,io);
+ if(command==='install'){error.write('Error: The install subcommand was removed. Run npx --yes @yunhozz/arc [installation options].\n');return 2;}
+ if(command===undefined||command.startsWith('--'))return(await import('./index.mjs')).runCli(args,io);
+ if(command==='uninstall')return(await import('./uninstall.mjs')).runCli(rest,io);
+ if(command==='completion'){
+  if(rest.length===1&&rest[0]==='--help'){output.write(completionUsage+'\n');return 0;}
+  if(rest.length===1&&['zsh','bash'].includes(rest[0])){output.write(renderCompletion(rest[0]));return 0;}
+  error.write('Error: Expected a completion shell (zsh or bash).\n'+completionUsage+'\n');return 2;
+ }
+ error.write(`Error: Unknown command: ${command}\n${usage}\n`);return 2;
+}

package/lib/cli/uninstall.mjs

@@ -0,0 +1,17 @@
+import fs from 'node:fs';import os from 'node:os';import path from 'node:path';import {fileURLToPath} from 'node:url';
+const packageRoot=fileURLToPath(new URL('../../',import.meta.url));
+const usage='Usage: arc uninstall [--target <claude|codex|all>] [--dry-run] [--skip-global] [--help] [--version]';
+function inputError(message){return Object.assign(new Error(message),{code:'ARC_CLI_INPUT'});}
+export function parseArgs(args){const options={},seen=new Set(),names={'--target':'target','--dry-run':'dryRun','--skip-global':'skipGlobal','--help':'help','--version':'version'};for(let i=0;i<args.length;i++){const flag=args[i],key=Object.hasOwn(names,flag)?names[flag]:undefined;if(!key)throw inputError(`Unknown argument: ${flag}`);if(seen.has(flag))throw inputError(`Duplicate argument: ${flag}`);seen.add(flag);if(key==='target'){const value=args[++i];if(!['claude','codex','all'].includes(value))throw inputError(`Invalid target: ${value??'missing value'}`);options.target=value;}else options[key]=true;}return options;}
+export async function selectTarget(options,io={}){return(await import('./choices.mjs')).selectChoices(options,{...io,targetOnly:true});}
+export async function runCli(args=process.argv.slice(2),{input=process.stdin,output=process.stdout,error=process.stderr}={}){
+ let onInterrupt;
+ try{const options=parseArgs(args);if(options.help){output.write(usage+'\n');return 0;}if(options.version){output.write(JSON.parse(fs.readFileSync(path.join(packageRoot,'package.json'))).version+'\n');return 0;}
+ if(!options.target&&(!input.isTTY||!output.isTTY))throw inputError('Non-interactive execution requires --target');await selectTarget(options,{input,output});
+ const [{loadNative},{openRoot},{resolveTarget},{buildUninstallPlan,uninstallTargets}]=await Promise.all([import('../safe-fs/native.mjs'),import('../safe-fs/index.mjs'),import('../installer/targets.mjs'),import('../installer/uninstall.mjs')]);const native=loadNative(),safeFs={openRoot:p=>openRoot(p,{native})};
+ const plans=(options.target==='all'?['codex','claude']:[options.target]).map(platform=>buildUninstallPlan({target:resolveTarget(platform,{userHome:os.homedir(),env:process.env}),safeFs,skipGlobal:options.skipGlobal}));
+ for(const plan of plans){output.write(`${plan.target.platform}: ${plan.target.home}\n`);for(const note of plan.summary)output.write(note+'\n');if(options.dryRun){for(const name of plan.removals)output.write(`Would remove: ${name}\n`);for(const change of plan.globalChanges)output.write(`Would remove managed block: ${change.path}\n`);}}
+ if(options.dryRun){output.write('Dry run completed. No changes made.\n');return 0;}
+ const controller=new AbortController();onInterrupt=()=>controller.abort();process.once('SIGINT',onInterrupt);const result=await uninstallTargets(plans,{safeFs,signal:controller.signal});for(const item of result.results){output.write(`${item.platform}: ${item.status}; rollback: ${item.rollback}\n`);for(const name of item.residualPaths)output.write(`Residual path: ${name}\n`);if(item.error)error.write(`Error: ${item.error.message}\n`);}return result.interrupted?130:result.results.every(item=>item.status==='uninstalled'&&!item.error)?0:1;
+ }catch(cause){error.write(`Error: ${cause.message}\n`);if(cause.code==='ARC_CANCELLED')return 130;if(cause.code==='ARC_CLI_INPUT'){error.write(usage+'\n');return 2;}return ['ARC_UNSUPPORTED_RUNTIME','ARC_NATIVE_UNAVAILABLE','ARC_TARGET_CONFIGURATION'].includes(cause.code)?2:1;}finally{if(onInterrupt)process.removeListener('SIGINT',onInterrupt);}
+}