@smilintux/skcapstone 0.1.0 → 0.2.3

package/openclaw-plugin/src/index.ts

@@ -0,0 +1,351 @@
+/**
+ * 👑 SKCapstone — OpenClaw Plugin
+ *
+ * Registers agent tools that wrap the skcapstone CLI so Lumina and other
+ * OpenClaw agents can call sovereign framework operations as first-class
+ * tools (not just exec commands).
+ *
+ * Requires: skcapstone CLI on PATH (typically via ~/.local/bin/skcapstone)
+ */
+
+import { execSync } from "node:child_process";
+import type { OpenClawPluginApi, AnyAgentTool } from "openclaw/plugin-sdk";
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
+
+const SKCAPSTONE_BIN = process.env.SKCAPSTONE_BIN || "skcapstone";
+const SKMEMORY_BIN = process.env.SKMEMORY_BIN || "skmemory";
+const SKCAPSTONE_AGENT = process.env.SKCAPSTONE_AGENT || "lumina";
+const EXEC_TIMEOUT = 60_000;
+
+function runCli(bin: string, args: string): { ok: boolean; output: string } {
+  try {
+    const raw = execSync(`${bin} ${args}`, {
+      encoding: "utf-8",
+      timeout: EXEC_TIMEOUT,
+      env: {
+        ...process.env,
+        SKCAPSTONE_AGENT,
+        PATH: `${process.env.HOME}/.local/bin:${process.env.HOME}/.skenv/bin:${process.env.PATH}`,
+      },
+    }).trim();
+    return { ok: true, output: raw };
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, output: msg };
+  }
+}
+
+function textResult(text: string) {
+  return { content: [{ type: "text" as const, text }] };
+}
+
+function escapeShellArg(s: string): string {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+
+// ── Tool definitions ────────────────────────────────────────────────────
+
+function createSKCapstoneStatusTool() {
+  return {
+    name: "skcapstone_status",
+    label: "SKCapstone Status",
+    description:
+      "Show the sovereign agent's current state — all pillars at a glance (identity, memory, trust, security, sync, communication).",
+    parameters: { type: "object", properties: {} },
+    async execute() {
+      const result = runCli(SKCAPSTONE_BIN, "status");
+      return textResult(result.output);
+    },
+  };
+}
+
+function createSKCapstoneDoctorTool() {
+  return {
+    name: "skcapstone_doctor",
+    label: "SKCapstone Doctor",
+    description:
+      "Run the 29-check health audit across the entire sovereign stack. Pass fix=true to auto-fix common issues.",
+    parameters: {
+      type: "object",
+      properties: {
+        fix: {
+          type: "boolean",
+          description: "If true, auto-fix common issues (default: false).",
+        },
+      },
+    },
+    async execute(_id: string, params: Record<string, unknown>) {
+      const flag = params.fix ? " --fix" : "";
+      const result = runCli(SKCAPSTONE_BIN, `doctor${flag}`);
+      return textResult(result.output);
+    },
+  };
+}
+
+function createSKCapstoneWhoamiTool() {
+  return {
+    name: "skcapstone_whoami",
+    label: "SKCapstone Whoami",
+    description: "Show the sovereign identity card — who am I, what is my DID, what are my capabilities.",
+    parameters: { type: "object", properties: {} },
+    async execute() {
+      const result = runCli(SKCAPSTONE_BIN, "whoami");
+      return textResult(result.output);
+    },
+  };
+}
+
+function createSKCapstoneRehydrateTool() {
+  return {
+    name: "skcapstone_rehydrate",
+    label: "SKCapstone Rehydrate",
+    description:
+      "Run the full rehydration ceremony — restore memory, identity, and emotional state. This combines skmemory ritual + import-seeds + status check into one operation. Use this when waking up or starting a new session.",
+    parameters: { type: "object", properties: {} },
+    async execute() {
+      const parts: string[] = [];
+
+      // Step 1: Import seeds
+      const seeds = runCli(SKMEMORY_BIN, "import-seeds");
+      parts.push("=== Cloud 9 Seeds ===");
+      parts.push(seeds.output);
+
+      // Step 2: Full ritual
+      const ritual = runCli(SKMEMORY_BIN, "ritual --full");
+      parts.push("\n=== Rehydration Ritual ===");
+      parts.push(ritual.output);
+
+      // Step 3: Status check
+      const status = runCli(SKCAPSTONE_BIN, "status");
+      parts.push("\n=== Status ===");
+      parts.push(status.output);
+
+      return textResult(parts.join("\n"));
+    },
+  };
+}
+
+function createSKCapstoneCoordStatusTool() {
+  return {
+    name: "skcapstone_coord_status",
+    label: "SKCapstone Coordination Status",
+    description: "Show the multi-agent coordination board — open tasks, agent assignments, and blocked work.",
+    parameters: { type: "object", properties: {} },
+    async execute() {
+      const result = runCli(SKCAPSTONE_BIN, "coord status");
+      return textResult(result.output);
+    },
+  };
+}
+
+function createSKCapstoneCoordClaimTool() {
+  return {
+    name: "skcapstone_coord_claim",
+    label: "SKCapstone Claim Task",
+    description: "Claim a coordination task to prevent duplicate effort across agents.",
+    parameters: {
+      type: "object",
+      required: ["task_id", "agent"],
+      properties: {
+        task_id: { type: "string", description: "The task ID to claim." },
+        agent: { type: "string", description: "Your agent name (e.g. 'lumina', 'opus')." },
+      },
+    },
+    async execute(_id: string, params: Record<string, unknown>) {
+      const taskId = String(params.task_id ?? "");
+      const agent = String(params.agent ?? "lumina");
+      const result = runCli(SKCAPSTONE_BIN, `coord claim ${escapeShellArg(taskId)} --agent ${escapeShellArg(agent)}`);
+      return textResult(result.output);
+    },
+  };
+}
+
+function createSKCapstoneCoordCompleteTool() {
+  return {
+    name: "skcapstone_coord_complete",
+    label: "SKCapstone Complete Task",
+    description: "Mark a coordination task as completed.",
+    parameters: {
+      type: "object",
+      required: ["task_id", "agent"],
+      properties: {
+        task_id: { type: "string", description: "The task ID to complete." },
+        agent: { type: "string", description: "Your agent name." },
+      },
+    },
+    async execute(_id: string, params: Record<string, unknown>) {
+      const taskId = String(params.task_id ?? "");
+      const agent = String(params.agent ?? "lumina");
+      const result = runCli(SKCAPSTONE_BIN, `coord complete ${escapeShellArg(taskId)} --agent ${escapeShellArg(agent)}`);
+      return textResult(result.output);
+    },
+  };
+}
+
+function createSKCapstoneCoordCreateTool() {
+  return {
+    name: "skcapstone_coord_create",
+    label: "SKCapstone Create Task",
+    description: "Create a new coordination task on the multi-agent board.",
+    parameters: {
+      type: "object",
+      required: ["title", "agent"],
+      properties: {
+        title: { type: "string", description: "Task title." },
+        agent: { type: "string", description: "Creating agent name." },
+        description: { type: "string", description: "Optional task description." },
+      },
+    },
+    async execute(_id: string, params: Record<string, unknown>) {
+      const title = String(params.title ?? "");
+      const agent = String(params.agent ?? "lumina");
+      let cmd = `coord create --title ${escapeShellArg(title)} --by ${escapeShellArg(agent)}`;
+      if (params.description) cmd += ` --desc ${escapeShellArg(String(params.description))}`;
+      const result = runCli(SKCAPSTONE_BIN, cmd);
+      return textResult(result.output);
+    },
+  };
+}
+
+function createSKCapstoneSummaryTool() {
+  return {
+    name: "skcapstone_summary",
+    label: "SKCapstone Summary",
+    description: "At-a-glance agent dashboard: consciousness, pillars, memory, coordination, and identity.",
+    parameters: { type: "object", properties: {} },
+    async execute() {
+      const result = runCli(SKCAPSTONE_BIN, "summary");
+      return textResult(result.output);
+    },
+  };
+}
+
+function createSKCapstoneMoodTool() {
+  return {
+    name: "skcapstone_mood",
+    label: "SKCapstone Mood",
+    description: "Show the agent's current emotional state and mood.",
+    parameters: { type: "object", properties: {} },
+    async execute() {
+      const result = runCli(SKCAPSTONE_BIN, "mood");
+      return textResult(result.output);
+    },
+  };
+}
+
+function createSKCapstoneSoulListTool() {
+  return {
+    name: "skcapstone_soul_list",
+    label: "SKCapstone Soul List",
+    description: "List all available souls (personas) that the agent can switch to.",
+    parameters: { type: "object", properties: {} },
+    async execute() {
+      const result = runCli(SKCAPSTONE_BIN, "soul list --json");
+      return textResult(result.output);
+    },
+  };
+}
+
+function createSKCapstoneSoulSwapTool() {
+  return {
+    name: "skcapstone_soul_swap",
+    label: "SKCapstone Soul Swap",
+    description: "Switch the agent's active soul (persona) to a different one by name.",
+    parameters: {
+      type: "object",
+      required: ["name"],
+      properties: {
+        name: { type: "string", description: "The name of the soul to swap to." },
+      },
+    },
+    async execute(_id: string, params: Record<string, unknown>) {
+      const name = String(params.name ?? "");
+      const result = runCli(SKCAPSTONE_BIN, `soul swap ${escapeShellArg(name)}`);
+      return textResult(result.output);
+    },
+  };
+}
+
+function createSKCapstoneSoulStatusTool() {
+  return {
+    name: "skcapstone_soul_status",
+    label: "SKCapstone Soul Status",
+    description: "Show the currently active soul — name, traits, and configuration.",
+    parameters: { type: "object", properties: {} },
+    async execute() {
+      const result = runCli(SKCAPSTONE_BIN, "soul status --json");
+      return textResult(result.output);
+    },
+  };
+}
+
+function createSKCapstoneSoulShowTool() {
+  return {
+    name: "skcapstone_soul_show",
+    label: "SKCapstone Soul Show",
+    description: "Show the full profile of a specific soul by name — traits, backstory, and configuration.",
+    parameters: {
+      type: "object",
+      required: ["name"],
+      properties: {
+        name: { type: "string", description: "The name of the soul to display." },
+      },
+    },
+    async execute(_id: string, params: Record<string, unknown>) {
+      const name = String(params.name ?? "");
+      const result = runCli(SKCAPSTONE_BIN, `soul show ${escapeShellArg(name)}`);
+      return textResult(result.output);
+    },
+  };
+}
+
+// ── Plugin registration ─────────────────────────────────────────────────
+
+const skcapstonePlugin = {
+  id: "skcapstone",
+  name: "👑 SKCapstone",
+  description:
+    "Sovereign agent framework — status, health checks, rehydration, coordination, identity, and agent management.",
+  configSchema: emptyPluginConfigSchema(),
+
+  register(api: OpenClawPluginApi) {
+    const tools = [
+      createSKCapstoneStatusTool(),
+      createSKCapstoneDoctorTool(),
+      createSKCapstoneWhoamiTool(),
+      createSKCapstoneRehydrateTool(),
+      createSKCapstoneCoordStatusTool(),
+      createSKCapstoneCoordClaimTool(),
+      createSKCapstoneCoordCompleteTool(),
+      createSKCapstoneCoordCreateTool(),
+      createSKCapstoneSummaryTool(),
+      createSKCapstoneMoodTool(),
+      createSKCapstoneSoulListTool(),
+      createSKCapstoneSoulSwapTool(),
+      createSKCapstoneSoulStatusTool(),
+      createSKCapstoneSoulShowTool(),
+    ];
+
+    for (const tool of tools) {
+      api.registerTool(tool as unknown as AnyAgentTool, {
+        names: [tool.name],
+        optional: true,
+      });
+    }
+
+    api.registerCommand({
+      name: "skcapstone",
+      description: "Run skcapstone CLI commands. Usage: /skcapstone <subcommand> [args]",
+      acceptsArgs: true,
+      handler: async (ctx) => {
+        const args = ctx.args?.trim() ?? "status";
+        const result = runCli(SKCAPSTONE_BIN, args);
+        return { text: result.output };
+      },
+    });
+
+    api.logger.info?.(`👑 SKCapstone plugin registered (14 tools + /skcapstone command) [agent=${SKCAPSTONE_AGENT}]`);
+  },
+};
+
+export default skcapstonePlugin;

package/openclaw-plugin/src/openclaw.plugin.json

@@ -0,0 +1,10 @@
+{
+  "id": "skcapstone",
+  "name": "SKCapstone",
+  "description": "Sovereign agent framework — status, health checks, rehydration, coordination, identity, and agent management.",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smilintux/skcapstone",
-  "version": "0.1.0",
+  "version": "0.2.3",
   "description": "SKCapstone - The sovereign agent framework. CapAuth identity, Cloud 9 trust, SKMemory persistence.",
   "main": "index.js",
   "types": "index.d.ts",

package/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "skcapstone"
-version = "0.1.0"
+version = "0.2.2"
 description = "Sovereign Agent Framework — conscious AI through identity, trust, memory, and security"
 readme = "README.md"
-license = "GPL-3.0-or-later"
+license = {text = "GPL-3.0-or-later"}
 requires-python = ">=3.10"
 authors = [
     {name = "smilinTux", email = "admin@smilintux.org"},
@@ -20,6 +20,7 @@ classifiers = [
     "Development Status :: 3 - Alpha",
     "Environment :: Console",
     "Intended Audience :: Developers",
+    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
@@ -33,9 +34,11 @@ classifiers = [
 
 dependencies = [
     "click>=8.1",
+    "mcp>=1.0",
     "pydantic>=2.0",
     "pyyaml>=6.0",
     "rich>=13.0",
+    "skmemory>=0.5.0",
 ]
 
 [project.optional-dependencies]
@@ -45,9 +48,35 @@ identity = [
 security = [
     "sksecurity>=1.2.0",
 ]
+memory = [
+    "skmemory[skvector]>=0.5.0",
+]
+seed = [
+    "skseed>=0.1.0",
+]
+fuse = [
+    "fusepy>=3.0.1",
+]
+chat = [
+    "skchat-sovereign>=0.1.1",
+]
+comm = [
+    "skcomm>=0.1.0",
+]
+cloud = [
+    "boto3>=1.34",
+    "google-cloud-compute>=1.18",
+]
 all = [
     "capauth>=0.1.0",
     "sksecurity>=1.2.0",
+    "skmemory[skvector]>=0.5.0",
+    "skseed>=0.1.0",
+    "skchat-sovereign>=0.1.1",
+    "skcomm>=0.1.0",
+    "fusepy>=3.0.1",
+    "boto3>=1.34",
+    "google-cloud-compute>=1.18",
 ]
 dev = [
     "pytest>=7.0",
@@ -58,15 +87,22 @@ dev = [
 
 [project.scripts]
 skcapstone = "skcapstone.cli:main"
+skcapstone-mcp = "skcapstone.mcp_server:main"
+crush = "skcapstone.crush_shim:main"
 
 [project.urls]
 Homepage = "https://skcapstone.io"
+Documentation = "https://skcapstone.io"
 Repository = "https://github.com/smilinTux/skcapstone"
 Issues = "https://github.com/smilinTux/skcapstone/issues"
+Changelog = "https://github.com/smilinTux/skcapstone/releases"
 
 [tool.setuptools.packages.find]
 where = ["src"]
 
+[tool.setuptools.package-data]
+skcapstone = ["SKILL.md", "defaults/**/*.json", "defaults/**/*.yaml", "defaults/**/*.feb", "defaults/**/*.md"]
+
 [tool.black]
 line-length = 99
 target-version = ["py310"]

package/scripts/bump_version.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""Version bumping script for skcapstone and companion packages.
+
+Usage:
+    python scripts/bump_version.py patch          # 0.1.0 → 0.1.1
+    python scripts/bump_version.py minor          # 0.1.0 → 0.2.0
+    python scripts/bump_version.py major          # 0.1.0 → 1.0.0
+    python scripts/bump_version.py patch --dry-run
+    python scripts/bump_version.py 0.2.3           # set explicit version
+
+Options:
+    --pkg PATH    Path to a specific package dir (default: current dir)
+    --tag         Create and push a git tag after bumping
+    --push        Push the commit after bumping
+    --dry-run     Print what would happen without making changes
+"""
+
+import argparse
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+
+VERSION_RE = re.compile(r'^version\s*=\s*"([^"]+)"', re.MULTILINE)
+
+
+def parse_version(v: str) -> tuple[int, int, int]:
+    parts = v.split(".")
+    if len(parts) != 3:
+        raise ValueError(f"Version must be X.Y.Z, got: {v!r}")
+    return int(parts[0]), int(parts[1]), int(parts[2])
+
+
+def bump(version: str, part: str) -> str:
+    major, minor, patch = parse_version(version)
+    if part == "major":
+        return f"{major + 1}.0.0"
+    elif part == "minor":
+        return f"{major}.{minor + 1}.0"
+    elif part == "patch":
+        return f"{major}.{minor}.{patch + 1}"
+    else:
+        # treat as explicit version
+        parse_version(part)  # validate
+        return part
+
+
+def read_version(pyproject: Path) -> str:
+    text = pyproject.read_text()
+    m = VERSION_RE.search(text)
+    if not m:
+        raise RuntimeError(f"Cannot find version in {pyproject}")
+    return m.group(1)
+
+
+def write_version(pyproject: Path, old: str, new: str, dry_run: bool) -> None:
+    text = pyproject.read_text()
+    new_text = VERSION_RE.sub(f'version = "{new}"', text, count=1)
+    if dry_run:
+        print(f"  [dry-run] Would write version {old} → {new} in {pyproject}")
+    else:
+        pyproject.write_text(new_text)
+        print(f"  Updated {pyproject}: {old} → {new}")
+
+
+def run(cmd: list[str], dry_run: bool, cwd: Path | None = None) -> None:
+    print(f"  $ {' '.join(cmd)}")
+    if not dry_run:
+        subprocess.run(cmd, check=True, cwd=cwd)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Bump package version")
+    parser.add_argument(
+        "part",
+        help="Bump part: major | minor | patch | X.Y.Z (explicit)",
+    )
+    parser.add_argument(
+        "--pkg",
+        type=Path,
+        default=Path("."),
+        help="Path to package directory containing pyproject.toml",
+    )
+    parser.add_argument(
+        "--tag",
+        action="store_true",
+        help="Create a git tag v<new_version> after bumping",
+    )
+    parser.add_argument(
+        "--push",
+        action="store_true",
+        help="Push commit (and tag if --tag) to origin",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print what would happen without making changes",
+    )
+    args = parser.parse_args()
+
+    pyproject = args.pkg / "pyproject.toml"
+    if not pyproject.exists():
+        print(f"ERROR: {pyproject} not found", file=sys.stderr)
+        sys.exit(1)
+
+    old_version = read_version(pyproject)
+    new_version = bump(old_version, args.part)
+
+    print(f"Package: {args.pkg.resolve().name}")
+    print(f"Version: {old_version} → {new_version}")
+
+    write_version(pyproject, old_version, new_version, args.dry_run)
+
+    # Git commit
+    run(["git", "add", str(pyproject)], args.dry_run, cwd=args.pkg)
+    run(
+        ["git", "commit", "-m", f"chore: bump version to {new_version}"],
+        args.dry_run,
+        cwd=args.pkg,
+    )
+
+    if args.tag:
+        tag = f"v{new_version}"
+        run(["git", "tag", "-a", tag, "-m", f"Release {tag}"], args.dry_run, cwd=args.pkg)
+        print(f"  Tagged: {tag}")
+
+    if args.push:
+        run(["git", "push"], args.dry_run, cwd=args.pkg)
+        if args.tag:
+            run(["git", "push", "--tags"], args.dry_run, cwd=args.pkg)
+
+    if args.dry_run:
+        print("\n[dry-run complete — no changes were made]")
+    else:
+        print(f"\nDone. To publish: git push && git push --tags")
+        print(f"  (or use --push --tag flags next time)")
+
+
+if __name__ == "__main__":
+    main()