aes-cli 0.6.0__tar.gz → 0.9.0__tar.gz

{aes_cli-0.6.0 → aes_cli-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aes-cli
-Version: 0.6.0
+Version: 0.9.0
 Summary: CLI tool for the Agentic Engineering Standard
 Author: Hiro
 License: Apache-2.0

{aes_cli-0.6.0 → aes_cli-0.9.0}/aes/__init__.py

@@ -2,4 +2,4 @@
 
 from __future__ import annotations
 
-__version__ = "0.6.0"
+__version__ = "0.9.0"

{aes_cli-0.6.0 → aes_cli-0.9.0}/aes/__main__.py

@@ -53,7 +53,7 @@ def cli(lang: Optional[str] = None) -> None:
     """
     from aes.i18n import init_locale
 
-    # Priority: --lang flag > AES_LANG env > ~/.aes/config.yaml > first-run prompt
+    # Priority: --lang flag > AES_LANG env > .agent/local.yaml > ~/.aes/config.yaml > first-run prompt
     if lang:
         init_locale(lang)
         return
@@ -63,7 +63,14 @@ def cli(lang: Optional[str] = None) -> None:
         init_locale(env_lang)
         return
 
-    from aes.global_config import get_locale
+    from pathlib import Path
+    from aes.global_config import get_locale, get_project_locale
+
+    project_locale = get_project_locale(Path.cwd())
+    if project_locale:
+        init_locale(project_locale)
+        return
+
     saved = get_locale()
     if saved is None and sys.stdin.isatty():
         _prompt_language()

{aes_cli-0.6.0 → aes_cli-0.9.0}/aes/commands/init.py

@@ -22,9 +22,17 @@ from aes.config import (
     AGENTIGNORE_FILE,
     BOM_FILE,
     DECISIONS_DIR,
+    INSTINCTS_DIR,
+    LEARNING_CONFIG_FILE,
+    LEARNING_DIR,
+    LIFECYCLE_FILE,
     LOCAL_EXAMPLE_FILE,
     LOCAL_FILE,
+    LOGS_DIR,
+    RULES_CONFIG_FILE,
+    RULES_DIR,
     SCAFFOLD_DIR,
+    SCRIPTS_DIR,
     SKILLS_DIR,
     REGISTRY_DIR,
     WORKFLOWS_DIR,
@@ -254,6 +262,7 @@ def _get_agent_integrated_types() -> list:
     return [
         (t("init.type_ml"), "ml"),
         (t("init.type_research"), "research"),
+        (t("init.type_assistant"), "assistant"),
         (t("init.type_custom"), "other"),
     ]
 
@@ -734,6 +743,100 @@ def init_cmd(
         content = _render_template(env, "operations.md.jinja", ops_context)
         (agent_dir / MEMORY_DIR / "operations.md").write_text(content)
 
+    # Lifecycle hooks (all domains)
+    if domain_config.scaffold_lifecycle:
+        (agent_dir / SCRIPTS_DIR).mkdir(exist_ok=True)
+        (agent_dir / LOGS_DIR).mkdir(exist_ok=True)
+        lifecycle_content = (
+            "# .agent/lifecycle.yaml — Lifecycle Hooks\n"
+            "apiVersion: aes/v1\n"
+            "kind: Lifecycle\n"
+            f"\nprofile: {domain_config.lifecycle_profile}\n"
+            "\nhooks:\n"
+            "  on_session_start:\n"
+            "    - name: restore-context\n"
+            "      description: Load previous session summary into context\n"
+            "      profile: minimal\n"
+            "      action: script\n"
+            "      command: node .agent/scripts/restore-context.js\n"
+            "      timeout_seconds: 10\n"
+            "      async: false\n"
+            "      fail_strategy: warn\n"
+            "\n"
+            "  on_session_end:\n"
+            "    - name: persist-summary\n"
+            "      description: Save session summary for next session\n"
+            "      profile: minimal\n"
+            "      action: script\n"
+            "      command: node .agent/scripts/persist-summary.js\n"
+            "      timeout_seconds: 15\n"
+            "      async: true\n"
+            "      fail_strategy: warn\n"
+        )
+        (agent_dir / LIFECYCLE_FILE).write_text(lifecycle_content)
+
+    # Continuous learning (agent-integrated domains only)
+    if domain_config.scaffold_learning:
+        (agent_dir / LEARNING_DIR).mkdir(exist_ok=True)
+        (agent_dir / INSTINCTS_DIR / "active").mkdir(parents=True, exist_ok=True)
+        (agent_dir / INSTINCTS_DIR / "candidates").mkdir(exist_ok=True)
+        (agent_dir / INSTINCTS_DIR / "archived").mkdir(exist_ok=True)
+        learning_content = (
+            "# .agent/learning/config.yaml\n"
+            "apiVersion: aes/v1\n"
+            "kind: LearningConfig\n"
+            "\nextraction:\n"
+            "  enabled: true\n"
+            "  auto_extract: true\n"
+            "  min_session_length: 5\n"
+            "  max_candidates_per_session: 3\n"
+            "\nconfidence:\n"
+            "  initial_score: 0.4\n"
+            "  promotion_threshold: 0.6\n"
+            "  promotion_min_validations: 3\n"
+            "  decay_rate_per_week: 0.01\n"
+            "  min_score: 0.3\n"
+            "\ncontext_loading:\n"
+            "  max_instincts_in_context: 10\n"
+            "  sort_by: confidence_score\n"
+            "  token_budget: 2000\n"
+            "  format: compact\n"
+        )
+        (agent_dir / LEARNING_CONFIG_FILE).write_text(learning_content)
+
+    # Rules & conventions (all domains)
+    if domain_config.scaffold_rules:
+        (agent_dir / RULES_DIR).mkdir(exist_ok=True)
+        (agent_dir / RULES_DIR / "common").mkdir(exist_ok=True)
+        rules_content = (
+            "# .agent/rules/rules.yaml\n"
+            "apiVersion: aes/v1\n"
+            "kind: RulesConfig\n"
+            "\nloading:\n"
+            "  always: [common]\n"
+        )
+        (agent_dir / RULES_CONFIG_FILE).write_text(rules_content)
+
+        # Starter rule
+        starter_rule = (
+            "---\n"
+            "name: testing\n"
+            "scope: common\n"
+            "priority: high\n"
+            "---\n\n"
+            "# Testing Standards\n\n"
+            "## Requirements\n"
+            "- All public functions must have unit tests\n"
+            "- No test should take longer than 5 seconds\n\n"
+            "## Patterns\n"
+            "- Use Arrange-Act-Assert structure\n"
+            "- Mock external dependencies\n\n"
+            "## Anti-patterns\n"
+            "- Never test implementation details\n"
+            "- Never share state between tests\n"
+        )
+        (agent_dir / RULES_DIR / "common" / "testing.md").write_text(starter_rule)
+
     # Auto-sync: generate tool-specific config files
     synced_files = run_sync(project_root, force=True, quiet=True)
     _write_mcp_config(project_root)

{aes_cli-0.6.0 → aes_cli-0.9.0}/aes/commands/inspect.py

@@ -12,7 +12,11 @@ import yaml
 from rich.console import Console
 from rich.table import Table
 
-from aes.config import AGENT_DIR, BOM_FILE, DECISIONS_DIR
+from aes.config import (
+    AGENT_DIR, BOM_FILE, DECISIONS_DIR,
+    INSTINCTS_DIR, LEARNING_CONFIG_FILE, LIFECYCLE_FILE,
+    RULES_CONFIG_FILE, RULES_DIR,
+)
 from aes.i18n import t
 from aes.registry import (
     fetch_index,
@@ -246,6 +250,45 @@ def _inspect_local(path: str) -> None:
             console.print(f"  {t('inspect.decisions_count', count=dr_count)}")
             console.print()
 
+    # Lifecycle hooks
+    lifecycle_path = agent_dir / LIFECYCLE_FILE
+    if lifecycle_path.exists():
+        lc = _load_yaml(lifecycle_path)
+        hooks = lc.get("hooks", {}) or {}
+        hook_count = sum(
+            len(v) if isinstance(v, list) else (1 if isinstance(v, dict) else 0)
+            for v in hooks.values()
+        )
+        profile = lc.get("profile", "standard")
+        console.print(f"[bold]Lifecycle[/]")
+        console.print(f"  Profile: {profile} | Hooks: {hook_count}")
+        console.print()
+
+    # Learning / instincts
+    learning_config_path = agent_dir / LEARNING_CONFIG_FILE
+    if learning_config_path.exists():
+        lconf = _load_yaml(learning_config_path)
+        extraction = lconf.get("extraction", {}).get("enabled", True)
+        instincts_base = agent_dir / INSTINCTS_DIR
+        active = len(list((instincts_base / "active").glob("*.instinct.yaml"))) if (instincts_base / "active").exists() else 0
+        candidates = len(list((instincts_base / "candidates").glob("*.instinct.yaml"))) if (instincts_base / "candidates").exists() else 0
+        archived = len(list((instincts_base / "archived").glob("*.instinct.yaml"))) if (instincts_base / "archived").exists() else 0
+        console.print(f"[bold]Learning[/]")
+        console.print(f"  Extraction: {'enabled' if extraction else 'disabled'} | Active: {active} | Candidates: {candidates} | Archived: {archived}")
+        console.print()
+
+    # Rules
+    rules_config_path = agent_dir / RULES_CONFIG_FILE
+    if rules_config_path.exists():
+        rconf = _load_yaml(rules_config_path)
+        languages = rconf.get("languages", [])
+        rules_base = agent_dir / RULES_DIR
+        rule_count = len(list(rules_base.glob("**/*.md"))) if rules_base.exists() else 0
+        lang_str = ", ".join(languages) if languages else "auto-detect"
+        console.print(f"[bold]Rules[/]")
+        console.print(f"  Languages: {lang_str} | Rule files: {rule_count}")
+        console.print()
+
     # Summary
     console.print(f"[bold]{t('inspect.summary')}[/]")
     console.print(f"  {t('inspect.skills_count', count=len(skills))}")

{aes_cli-0.6.0 → aes_cli-0.9.0}/aes/commands/status.py

@@ -70,7 +70,12 @@ def status_cmd(path: str) -> None:
 
     for name in TARGET_NAMES:
         adapter = TARGETS[name]()
-        plan = adapter.plan(ctx, force=True)
+        try:
+            plan = adapter.plan(ctx, force=True)
+        except Exception:
+            # Target-specific validation failure (e.g. openclaw requires
+            # identity/model) — skip incompatible targets silently in status.
+            continue
         for gf in plan.files:
             would_generate[gf.relative_path] = gf.content
 

{aes_cli-0.6.0 → aes_cli-0.9.0}/aes/commands/sync.py

@@ -16,10 +16,15 @@ from rich.console import Console
 from aes.config import (
     AGENT_DIR,
     COMMANDS_DIR,
+    INSTINCTS_DIR,
+    LEARNING_CONFIG_FILE,
+    LIFECYCLE_FILE,
     LOCAL_FILE,
     MANIFEST_FILE,
     MEMORY_DIR,
     PERMISSIONS_FILE,
+    RULES_CONFIG_FILE,
+    RULES_DIR,
     SKILLS_DIR,
 )
 from aes.i18n import t
@@ -64,7 +69,15 @@ def run_sync(
     all_plans: List[SyncPlan] = []
     for name in selected:
         adapter = TARGETS[name]()
-        all_plans.append(adapter.plan(ctx, force))
+        try:
+            all_plans.append(adapter.plan(ctx, force))
+        except click.ClickException:
+            # Target-specific validation failure — skip when syncing
+            # multiple targets (e.g. openclaw requires identity/model
+            # which non-assistant projects won't have).
+            if len(selected) == 1:
+                raise
+            continue
 
     sync_manifest = _load_sync_manifest(project_root)
     written = 0
@@ -158,6 +171,14 @@ def _load_agent_context(project_root: Path) -> AgentContext:
                     "negative_triggers": skill_data.get("negative_triggers", []),
                     "activation": skill_data.get("activation", "explicit"),
                     "allowed_tools": skill_data.get("allowed_tools"),
+                    "version": skill_data.get("version", "0.1.0"),
+                    "emoji": skill_data.get("emoji", ""),
+                    "license": skill_data.get("license", "MIT"),
+                    "user_invocable": skill_data.get("user_invocable", True),
+                    "primary_env": skill_data.get("primary_env", ""),
+                    "requires_bins": (skill_data.get("requires") or {}).get("bins", []),
+                    "requires_env": (skill_data.get("requires") or {}).get("env", []),
+                    "mcp_server": skill_data.get("mcp_server"),
                 }
         if skill_id not in skill_metadata:
             skill_metadata[skill_id] = {
@@ -208,6 +229,84 @@ def _load_agent_context(project_root: Path) -> AgentContext:
         if local_perms and permissions:
             permissions = _deep_merge(permissions, local_perms)
 
+    # Load lifecycle.yaml
+    lifecycle: Optional[dict] = None
+    lifecycle_path = agent_dir / LIFECYCLE_FILE
+    if lifecycle_path.exists():
+        with open(lifecycle_path) as f:
+            lifecycle = yaml.safe_load(f) or {}
+
+    # Load learning config and active instincts
+    learning_config: Optional[dict] = None
+    active_instincts: List[dict] = []
+    learning_config_path = agent_dir / LEARNING_CONFIG_FILE
+    if learning_config_path.exists():
+        with open(learning_config_path) as f:
+            learning_config = yaml.safe_load(f) or {}
+
+    instincts_active_dir = agent_dir / INSTINCTS_DIR / "active"
+    if instincts_active_dir.exists():
+        max_instincts = 10
+        if learning_config:
+            max_instincts = (
+                learning_config.get("context_loading", {})
+                .get("max_instincts_in_context", 10)
+            )
+        raw_instincts = []
+        for inst_file in sorted(instincts_active_dir.glob("*.instinct.yaml")):
+            with open(inst_file) as f:
+                inst_data = yaml.safe_load(f)
+            if inst_data:
+                raw_instincts.append(inst_data)
+        # Sort by confidence score descending
+        raw_instincts.sort(
+            key=lambda i: i.get("confidence", {}).get("score", 0),
+            reverse=True,
+        )
+        active_instincts = raw_instincts[:max_instincts]
+
+    # Load rules config and rule files
+    rules_config: Optional[dict] = None
+    rules_files: Dict[str, str] = {}
+    rules_config_path = agent_dir / RULES_CONFIG_FILE
+    if rules_config_path.exists():
+        with open(rules_config_path) as f:
+            rules_config = yaml.safe_load(f) or {}
+
+        rules_base = agent_dir / RULES_DIR
+        overrides = rules_config.get("overrides", {})
+
+        # Determine which language directories to load
+        languages = rules_config.get("languages", [])
+        if not languages:
+            # Auto-detect from project root
+            detection = rules_config.get("detection", {})
+            for lang, patterns in detection.items():
+                for pattern in patterns:
+                    if list(project_root.glob(pattern)):
+                        languages.append(lang)
+                        break
+
+        # Always-load directories (default: common)
+        always = rules_config.get("loading", {}).get("always", ["common"])
+        dirs_to_load = list(always) + languages
+
+        for dir_name in dirs_to_load:
+            rule_dir = rules_base / dir_name
+            if not rule_dir.exists():
+                continue
+            for md_file in sorted(rule_dir.glob("*.md")):
+                content = md_file.read_text()
+                # Resolve ${variable} placeholders from overrides
+                rule_name = md_file.stem
+                rule_overrides = overrides.get(rule_name, {})
+                for var_name, var_value in rule_overrides.items():
+                    content = content.replace(
+                        f"${{{var_name}}}", str(var_value)
+                    )
+                key = f"{dir_name}/{md_file.name}"
+                rules_files[key] = content
+
     return AgentContext(
         project_root=project_root,
         agent_dir=agent_dir,
@@ -220,6 +319,11 @@ def _load_agent_context(project_root: Path) -> AgentContext:
         memory_project=memory_project,
         skill_metadata=skill_metadata,
         local_config=local_config,
+        lifecycle=lifecycle,
+        learning_config=learning_config,
+        active_instincts=active_instincts,
+        rules_config=rules_config,
+        rules_files=rules_files,
     )
 
 
@@ -305,7 +409,19 @@ def sync_cmd(
     all_plans: List[SyncPlan] = []
     for target_name in selected:
         adapter = TARGETS[target_name]()
-        sync_plan = adapter.plan(ctx, force)
+        try:
+            sync_plan = adapter.plan(ctx, force)
+        except click.ClickException as exc:
+            # Target-specific validation failure (e.g. openclaw requires
+            # identity/model). When syncing a single explicit target, re-raise
+            # so the user sees the error. When syncing all targets, skip and
+            # warn — not every project is compatible with every target.
+            if len(selected) == 1:
+                raise
+            console.print(
+                f"  [yellow]⚠ {target_name}:[/] {exc.format_message()}"
+            )
+            continue
         all_plans.append(sync_plan)
 
     # Execute plans

{aes_cli-0.6.0 → aes_cli-0.9.0}/aes/config.py

@@ -34,6 +34,14 @@ OVERRIDES_DIR = "overrides"
 LOCAL_FILE = "local.yaml"
 LOCAL_EXAMPLE_FILE = "local.example.yaml"
 BOM_FILE = "bom.yaml"
+LIFECYCLE_FILE = "lifecycle.yaml"
+LEARNING_DIR = "learning"
+LEARNING_CONFIG_FILE = "learning/config.yaml"
+INSTINCTS_DIR = "learning/instincts"
+RULES_DIR = "rules"
+RULES_CONFIG_FILE = "rules/rules.yaml"
+SCRIPTS_DIR = "scripts"
+LOGS_DIR = "logs"
 
 # Schema file mapping
 SCHEMA_MAP = {
@@ -44,4 +52,8 @@ SCHEMA_MAP = {
     "permissions": "permissions.schema.json",
     "bom": "bom.schema.json",
     "decision-record": "decision-record.schema.json",
+    "lifecycle": "lifecycle.schema.json",
+    "instinct": "instinct.schema.json",
+    "learning-config": "learning-config.schema.json",
+    "rules-config": "rules-config.schema.json",
 }