echomodel 0.2.1__tar.gz

echomodel-0.2.1/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: echomodel
+Version: 0.2.1
+Summary: AI agent ecosystem — cross-platform skill management, MCP tools, and configuration
+Requires-Python: >=3.11
+Requires-Dist: click
+Requires-Dist: toml
+Requires-Dist: rich
+Requires-Dist: pyyaml
+Requires-Dist: mcp
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"

echomodel-0.2.1/README.md

@@ -0,0 +1,147 @@
+# aicfg
+
+Know at a glance which AI agent skills are installed on this machine,
+for which platform, and which are missing — then fix it with one command.
+
+aicfg is a unified tool for managing skills, MCP servers, and
+configuration across Claude Code and Gemini CLI. Register git-hosted
+skill marketplaces, browse what's available, and install to both
+platforms without learning each tool's syntax.
+
+## Why
+
+The core problem: you track a set of skills you care about across one
+or more marketplaces. On any given machine, some are installed for
+Claude, some for Gemini, some for both, some for neither. Without
+aicfg, answering "what's missing?" means checking two separate
+directories and comparing manually.
+
+`aicfg skills list` answers that question instantly — one table showing
+every skill from your registered marketplaces, with install status per
+platform. That's the central value. Everything else follows from it:
+
+- **Git-hosted skill marketplaces** — register a repo, browse skills, install by name
+- **One command to install a skill to both platforms** — no need to learn each tool's install syntax
+- **Unified MCP server management** — register, health-check, and list servers across scopes
+- **Context file unification** — keep CLAUDE.md and .gemini/settings.json in sync from shared source files
+
+Skills use the [agentskills.io](https://agentskills.io/) open standard. Marketplace repos work natively with `gemini skills install` too.
+
+## Quick Start
+
+```bash
+# Install
+pipx install -e . --force
+
+# Register a skills marketplace
+aicfg skills marketplace register my/skills https://github.com/YOUR_USERNAME/skills.git
+
+# See what's available
+aicfg skills list
+
+# Install a skill (to both Claude and Gemini)
+aicfg skills install develop-unit-tests
+
+# Install to one platform only
+aicfg skills install nm --platform claude
+
+# Publish a local skill to a marketplace
+aicfg skills publish my-skill --marketplace my/skills
+```
+
+## Commands
+
+### Skills
+
+```bash
+aicfg skills list                              # all skills across marketplaces + local
+aicfg skills list --installed any              # only installed skills
+aicfg skills list --installed claude           # installed on claude
+aicfg skills list --installed none             # not installed anywhere
+aicfg skills list --refresh                    # force marketplace cache refresh
+aicfg skills install <name>                    # install to all configured platforms
+aicfg skills install <name> --platform claude  # install to one platform
+aicfg skills uninstall <name>
+aicfg skills show <name>                       # full details + status per marketplace
+aicfg skills publish <name>                    # publish to source marketplace
+aicfg skills publish <name> --marketplace <alias>
+aicfg skills publish <name> --source-path ~/ws/my-skill  # from arbitrary dir
+aicfg skills marketplace register <alias> <git-url>
+aicfg skills marketplace list
+aicfg skills marketplace remove <alias>
+```
+
+Marketplace repos work natively with both aicfg and the Gemini CLI:
+
+```bash
+# These are equivalent — same repo, same skill:
+aicfg skills install develop-skill               # via aicfg
+gemini skills install <url> --path coding/develop-skill  # via Gemini CLI
+```
+
+Claude Code has no native skill CLI. aicfg copies SKILL.md to `~/.claude/skills/<name>/SKILL.md` directly.
+
+### Claude Utilities
+
+```bash
+aicfg claude find-session "deploy"         # search recent sessions for keywords
+aicfg claude find-session "error" --most-recent=20
+aicfg claude find-session "deploy" "cloud run" --all   # AND match
+```
+
+### MCP Servers
+
+```bash
+aicfg mcp add --self                       # register aicfg's own MCP server
+aicfg mcp add --command some-mcp --name my-server
+aicfg mcp add --path /path/to/repo         # auto-discover from pyproject.toml
+aicfg mcp list
+aicfg mcp show aicfg                       # details + health check
+aicfg mcp remove my-server
+```
+
+### Gemini Slash Commands
+
+```bash
+aicfg cmds list                            # list with sync status
+aicfg cmds add my-fix "Fix: {{context}}"   # create locally
+aicfg cmds publish my-fix                  # promote to repo registry
+aicfg cmds install commitall               # install from registry
+```
+
+### Context Files
+
+```bash
+aicfg context status                       # check CLAUDE.md / GEMINI.md state
+aicfg context unify --scope user           # merge into shared CONTEXT.md
+```
+
+### Settings
+
+```bash
+aicfg settings list
+aicfg paths list                           # context.includeDirectories
+aicfg allowed-tools list                   # tools.allowed
+```
+
+## Architecture
+
+- **SDK-first** — all logic in `src/aicfg/sdk/`. CLI and MCP server are thin wrappers.
+- **Skills** — standard agentskills.io format, copied as-is from git-hosted marketplaces. No transformation.
+- **Marketplace cache** — `~/.cache/ai-common/skills/marketplaces/`. Cloned without `.git`, 5-minute TTL.
+- **Scope convention** — `user` = `~/.gemini/settings.json`, `project` = `./.gemini/settings.json`
+- **Operational transparency** — operations like `publish` that perform multi-step git workflows include a full log of every command executed, with exit codes and output. You always get structured results for programmatic use, plus verifiable evidence of what actually happened under the hood.
+
+## Development
+
+```bash
+make test      # run unit tests (network blocked, isolated via env vars)
+make install   # pipx install in editable mode
+make clean     # remove build artifacts
+```
+
+## Prerequisites
+
+- Python 3.10+
+- pipx
+- Claude Code and/or Gemini CLI

echomodel-0.2.1/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "echomodel"
+version = "0.2.1"
+description = "AI agent ecosystem — cross-platform skill management, MCP tools, and configuration"
+requires-python = ">=3.11"
+dependencies = [
+    "click",
+    "toml",
+    "rich",
+    "pyyaml",
+    "mcp",
+]
+
+[project.optional-dependencies]
+dev = ["pytest"]
+
+[project.scripts]
+em = "aicfg.cli:cli"
+echomodel = "aicfg.cli:cli"
+aicfg = "aicfg.cli:cli"
+aicfg-mcp = "aicfg.mcp.server:run_server"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+aicfg = ["*.yaml"]

echomodel-0.2.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

echomodel-0.2.1/src/aicfg/cli/__init__.py

@@ -0,0 +1,24 @@
+import click
+from aicfg.cli.commands import cmds
+from aicfg.cli.context import context_cli
+from aicfg.cli.settings import paths, settings, allowed_tools
+from aicfg.cli.servers import mcp_servers
+from aicfg.cli.sessions import claude_cli
+from aicfg.cli.skills import skills
+
+@click.group()
+def cli():
+    """AI Config Manager (aicfg)"""
+    pass
+
+cli.add_command(cmds)
+cli.add_command(context_cli)
+cli.add_command(paths)
+cli.add_command(settings)
+cli.add_command(allowed_tools)
+cli.add_command(mcp_servers)
+cli.add_command(claude_cli)
+cli.add_command(skills)
+
+if __name__ == "__main__":
+    cli()

echomodel-0.2.1/src/aicfg/cli/commands.py

@@ -0,0 +1,185 @@
+import click
+import toml
+import json
+from rich.console import Console
+from rich.table import Table
+from rich import print as rprint
+from aicfg.sdk import commands as sdk
+
+console = Console()
+
+@click.group()
+def cmds():
+    """Manage Gemini slash commands (TOML files)."""
+    pass
+
+@cmds.command()
+@click.argument("name")
+@click.argument("prompt", required=False)
+@click.option("--desc", "-d", help="Description of the command")
+@click.option("--scope", type=click.Choice(["user", "project"]),
+default="user", help="Where to create the command (default: user)")
+@click.option("--namespace", "-ns", help="Optional namespace (subdirectory) for the command")
+def add(name, prompt, desc, scope, namespace):
+    """Add a new command."""
+    if not prompt:
+        description = desc or "My custom command"
+        default_content = (
+            f'description = "{description}"\n'
+            'prompt = """\n'
+            'Write your prompt here...\n'
+            '"""'
+        )
+        edited = click.edit(default_content, extension=".toml")
+        if not edited:
+            rprint("[red]Aborted.[/red] No content provided.")
+            return
+        try:
+            data = toml.loads(edited)
+            prompt = data.get("prompt")
+            desc = data.get("description", desc)
+        except Exception as e:
+            rprint(f"[red]Invalid TOML:[/red] {e}")
+            return
+
+    path = sdk.add_command(name, prompt, desc, scope=scope, namespace=namespace)
+    rprint(f"[green]Created[/green] {path} (Scope: [bold]{scope.upper()}[/bold])")
+
+@cmds.command("list")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+@click.option("--format", type=click.Choice(["text", "json"]),
+default="text", help="Output format.")
+@click.option("--filter", "filter_pattern", help="Filter by name (supports wildcards e.g. 'commit*')")
+@click.option("--scope", "scopes", multiple=True, type=click.Choice(["user", "registry", "project"]),
+help="Filter by scope (can specify multiple)")
+def list_cmds(as_json, format, filter_pattern, scopes):
+    """List all commands. Optional filters for name and scope."""
+    
+    # Convert tuple to list for SDK, or None if empty (implies all) 
+    scope_list = list(scopes) if scopes else None
+    
+    results = sdk.list_commands(filter_pattern=filter_pattern, scopes=scope_list)
+    results = sorted(results, key=lambda x: x["name"])
+    
+    if as_json or format == "json":
+        console.print_json(data=results)
+        return
+
+    table = Table(title="Custom Slash Commands")
+    table.add_column("Command", style="cyan")
+    
+    # Determine which columns to show
+    show_user = not scope_list or "user" in scope_list
+    show_reg = not scope_list or "registry" in scope_list
+    show_proj = not scope_list or "project" in scope_list
+    
+    if show_user: table.add_column("User", justify="center")
+    if show_reg: table.add_column("Registry", justify="center")
+    if show_proj: table.add_column("Project", justify="center")
+
+    for item in results:
+        # Define icons
+        # Green check if identical (synced), Yellow not-equal sign if diff
+        synced = item["synced"]
+        icon = "[green]✅[/green]" if synced else "[yellow] ≠ [/yellow]"
+        
+        row = [item["name"]]
+        
+        if show_user:
+            row.append(icon if item["user"]["exists"] else "[dim]- [/dim]")
+        if show_reg:
+            row.append(icon if item["registry"]["exists"] else "[dim]- [/dim]")
+        if show_proj:
+            row.append(icon if item["project"]["exists"] else "[dim]- [/dim]")
+        
+        table.add_row(*row)
+
+    console.print(table)
+
+@cmds.command()
+@click.argument("name")
+@click.option("--update", is_flag=True, help="Overwrite if command exists in registry and content differs.")
+@click.option("--source-scope", type=click.Choice(["user", "project"]), help="Explicitly choose source scope for registration.")
+def register(name, update, source_scope):
+    """Register a command from user/project scope to the registry."""
+    try:
+        path = sdk.register_command(name, update=update, source_scope=source_scope)
+        rprint(f"[green]Registered[/green] '{name}' to {path}")
+        rprint(f"[blue]Note:[/blue] Changes to the registry repo ({path.parent}) will need to be committed and pushed to GitHub.")
+    except (ValueError, FileNotFoundError, FileExistsError) as e:
+        rprint(f"[red]Error:[/red] {e}")
+        exit(1)
+
+@cmds.command()
+@click.argument("name")
+def show(name):
+    """Show details of a command."""
+    data = sdk.get_command(name)
+    if not data:
+        rprint(f"[red]Error:[/red] Command '{name}' not found.")
+        return
+    
+    rprint(f"[bold]Description:[/bold] {data.get('description')}")
+    rprint("[bold]Prompt:[/bold]")
+    rprint(data.get("prompt"))
+
+@cmds.command()
+@click.argument("name")
+@click.option("--scope", type=click.Choice(["user", "project", "registry"]),
+default="user", help="Scope to remove from (default: user)")
+def remove(name, scope):
+    """Remove a command from local, project, or registry scope."""
+    success = sdk.delete_command(name, scope=scope)
+    if success:
+        rprint(f"[green]Removed[/green] '{name}' from {scope} scope.")
+    else:
+        rprint(f"[red]Error:[/red] Command '{name}' not found in {scope} scope.")
+
+@cmds.command()
+@click.argument("name")
+def publish(name):
+    """Publish a command from User scope to the Registry."""
+    try:
+        path = sdk.publish_command(name)
+        rprint(f"[green]Published[/green] '{name}' to Registry ({path})")
+    except FileNotFoundError as e:
+        rprint(f"[red]Error:[/red] {e}")
+
+@cmds.command()
+@click.argument("name")
+def install(name):
+    """Install a command from Registry to User scope."""
+    try:
+        path = sdk.install_command(name)
+        rprint(f"[green]Installed[/green] '{name}' to User scope ({path})")
+    except FileNotFoundError as e:
+        rprint(f"[red]Error:[/red] {e}")
+
+@cmds.command()
+@click.argument("name")
+def diff(name):
+    """Show differences between User and Registry versions."""
+    result = sdk.get_diff(name)
+    if not result:
+        rprint(f"Command '{name}' cannot be diffed (must exist in both User and Registry).")
+        return
+
+    repo_lines, xdg_lines = result
+    import difflib
+    
+    diff = difflib.unified_diff(
+        repo_lines, xdg_lines,
+        fromfile=f"Registry ({name})",
+        tofile=f"User ({name})",
+        lineterm=""
+    )
+    
+    for line in diff:
+        if line.startswith("+"):
+            console.print(line, style="green", end="")
+        elif line.startswith("-"):
+            console.print(line, style="red", end="")
+        elif line.startswith("@"):
+            console.print(line, style="cyan", end="")
+        else:
+            print(line, end="")

echomodel-0.2.1/src/aicfg/cli/context.py

@@ -0,0 +1,183 @@
+"""CLI commands for managing AI assistant context files."""
+import json
+import click
+from rich import print as rprint
+from rich.table import Table
+from aicfg.sdk import context as context_sdk
+from aicfg.sdk import settings as settings_sdk
+
+
+@click.group(name="context")
+def context_cli():
+    """Manage AI assistant context files."""
+    pass
+
+
+@context_cli.command("status")
+@click.option("--scope", type=click.Choice(["user", "project"]), default=None,
+              help="Filter to specific scope (default: show all)")
+@click.option("--format", "output_format", type=click.Choice(["table", "json"]), default="table")
+def status(scope, output_format):
+    """Show the current state of context files for both user and project scopes."""
+    result = context_sdk.get_context_status(scope)
+
+    if output_format == "json":
+        rprint(json.dumps(result, indent=2))
+        return
+
+    rprint(f"[dim]Working directory:[/dim] {result['working_directory']}")
+    if result.get("git_root"):
+        rprint(f"[dim]Git root:[/dim] {result['git_root']}")
+    rprint()
+
+    for scope_name, scope_data in result["scopes"].items():
+        table = Table(title=f"{scope_name.title()} Scope")
+        table.add_column("File", style="cyan")
+        table.add_column("Status", style="green")
+        table.add_column("Details", style="dim")
+
+        for file_name, info in scope_data["files"].items():
+            if not info["exists"]:
+                file_status = "[yellow]missing[/yellow]"
+                details = info["path"]
+            elif info["is_symlink"]:
+                if info.get("points_to_unified"):
+                    file_status = "[green]symlink (unified)[/green]"
+                else:
+                    file_status = "[red]symlink (other)[/red]"
+                details = f"-> {info['symlink_target']}"
+            else:
+                file_status = "present"
+                details = info["path"]
+
+            table.add_row(file_name, file_status, details)
+
+        rprint(table)
+        rprint(f"[dim]State: {scope_data['state']}[/dim]\n")
+
+
+@context_cli.command("unify")
+@click.option("--scope", type=click.Choice(["user", "project"]), default="user",
+              help="Scope to unify (default: user)")
+def unify(scope):
+    """
+    Unify CLAUDE.md and GEMINI.md into a single shared CONTEXT.md.
+
+    Combines context files into a unified location, then creates symlinks
+    so both tools read from the same file.
+
+    This operation is idempotent - running it multiple times is safe.
+    """
+    result = context_sdk.unify_context(scope)
+
+    if result["success"]:
+        rprint(f"[green]Success![/green]\n")
+        rprint(result["message"])
+
+        if result.get("backups"):
+            rprint(f"\n[dim]Backups created:[/dim]")
+            for backup in result["backups"]:
+                rprint(f"  [dim]{backup}[/dim]")
+
+        if result.get("symlinks_created"):
+            rprint(f"\n[dim]Symlinks created:[/dim]")
+            for symlink in result["symlinks_created"]:
+                rprint(f"  [dim]{symlink}[/dim]")
+    else:
+        rprint(f"[red]Failed![/red]\n")
+        rprint(result.get("message", result.get("error", "Unknown error")))
+        raise SystemExit(1)
+
+
+@context_cli.command("analyze")
+@click.argument("scope", type=click.Choice(["user", "project", "all"]))
+@click.argument("prompt")
+@click.option("--model", default=None, help="Gemini model override")
+@click.option("--format", "output_format", type=click.Choice(["text", "json"]), default="text")
+def analyze(scope, prompt, model, output_format):
+    """
+    Analyze context files using Gemini.
+
+    SCOPE: 'user', 'project', or 'all' to analyze both scopes together.
+
+    PROMPT: Your question or analysis request about the context files.
+    """
+    result = context_sdk.analyze_context(scope, prompt, model)
+
+    if output_format == "json":
+        rprint(json.dumps(result, indent=2))
+        return
+
+    if result.get("success"):
+        rprint(result["response"])
+    else:
+        rprint(f"[red]Error:[/red] {result.get('error', 'Unknown error')}")
+        raise SystemExit(1)
+
+
+@context_cli.command("revise")
+@click.argument("scope", type=click.Choice(["user", "project"]))
+@click.argument("prompt")
+@click.option("--model", default=None, help="Gemini model override")
+@click.option("--format", "output_format", type=click.Choice(["text", "json"]), default="text")
+def revise(scope, prompt, model, output_format):
+    """
+    Revise context file using Gemini.
+
+    SCOPE: 'user' or 'project' (cannot revise both at once).
+
+    PROMPT: Instructions for how to modify the context file.
+    """
+    result = context_sdk.revise_context(scope, prompt, model)
+
+    if output_format == "json":
+        rprint(json.dumps(result, indent=2))
+        return
+
+    if result.get("success"):
+        rprint(f"[green]Success![/green] {result['message']}")
+        rprint(f"[dim]Backup: {result['backup']}[/dim]")
+    else:
+        rprint(f"[red]Error:[/red] {result.get('error', 'Unknown error')}")
+        raise SystemExit(1)
+
+
+# Subgroup for file-names management (Gemini-specific setting)
+@context_cli.group(name="file-names")
+def file_names():
+    """Manage context.fileName setting (Gemini-specific)."""
+    pass
+
+
+@file_names.command("list")
+def list_file_names():
+    """List configured context file names."""
+    path, files = settings_sdk.get_context_files()
+    rprint(f"[bold]Config:[/bold] {path}")
+    if not files:
+        rprint("[yellow]No context files configured.[/yellow]")
+        return
+    table = Table(show_header=True, header_style="bold cyan")
+    table.add_column("File Name")
+    for f in sorted(files):
+        table.add_row(f)
+    rprint(table)
+
+
+@file_names.command("add")
+@click.argument("filename")
+def add_file_name(filename):
+    """Add a context file name."""
+    path = settings_sdk.add_context_file(filename)
+    rprint(f"[green]Added[/green] '{filename}' to {path}")
+
+
+@file_names.command("remove")
+@click.argument("filename")
+def remove_file_name(filename):
+    """Remove a context file name."""
+    path, removed = settings_sdk.remove_context_file(filename)
+    if removed:
+        rprint(f"[green]Removed[/green] '{filename}' from {path}")
+    else:
+        rprint(f"[red]File '{filename}' not found in {path}[/red]")