codemaxxing 0.1.13 → 0.2.0

package/dist/utils/skills.d.ts

@@ -0,0 +1,60 @@
+import { type RegistrySkill } from "../skills/registry.js";
+export interface SkillMeta {
+    name: string;
+    description: string;
+    version: string;
+    author: string;
+    tags: string[];
+}
+/**
+ * List all installed skills by scanning ~/.codemaxxing/skills/
+ */
+export declare function listInstalledSkills(): SkillMeta[];
+/**
+ * Install a skill from the built-in registry
+ */
+export declare function installSkill(name: string): {
+    ok: boolean;
+    message: string;
+};
+/**
+ * Remove an installed skill
+ */
+export declare function removeSkill(name: string): {
+    ok: boolean;
+    message: string;
+};
+/**
+ * Get the prompt.md content for an installed skill
+ */
+export declare function getSkillPrompt(name: string): string | null;
+/**
+ * Get skills that should be active for the given project directory.
+ * If .codemaxxing/skills.json exists in the project, only those skills are active.
+ * Otherwise, all installed skills are active.
+ */
+export declare function getActiveSkills(cwd: string, sessionDisabled?: Set<string>): string[];
+/**
+ * Build the skill prompt blocks to inject into the system prompt
+ */
+export declare function buildSkillPrompts(cwd: string, sessionDisabled?: Set<string>): string;
+/**
+ * Create a scaffold for a new custom skill
+ */
+export declare function createSkillScaffold(name: string): {
+    ok: boolean;
+    message: string;
+    path?: string;
+};
+/**
+ * Search the built-in registry by name, tags, or description
+ */
+export declare function searchRegistry(query: string): RegistrySkill[];
+/**
+ * Return all skills from the built-in registry
+ */
+export declare function getRegistrySkills(): RegistrySkill[];
+/**
+ * Get the count of active skills
+ */
+export declare function getActiveSkillCount(cwd: string, sessionDisabled?: Set<string>): number;

package/dist/utils/skills.js

@@ -0,0 +1,203 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, rmSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { REGISTRY } from "../skills/registry.js";
+const SKILLS_DIR = join(homedir(), ".codemaxxing", "skills");
+/**
+ * Ensure the skills directory exists
+ */
+function ensureSkillsDir() {
+    if (!existsSync(SKILLS_DIR)) {
+        mkdirSync(SKILLS_DIR, { recursive: true });
+    }
+}
+/**
+ * List all installed skills by scanning ~/.codemaxxing/skills/
+ */
+export function listInstalledSkills() {
+    ensureSkillsDir();
+    const skills = [];
+    try {
+        const entries = readdirSync(SKILLS_DIR, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const metaPath = join(SKILLS_DIR, entry.name, "skill.json");
+            if (!existsSync(metaPath))
+                continue;
+            try {
+                const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+                skills.push({
+                    name: meta.name ?? entry.name,
+                    description: meta.description ?? "",
+                    version: meta.version ?? "0.0.0",
+                    author: meta.author ?? "unknown",
+                    tags: meta.tags ?? [],
+                });
+            }
+            catch {
+                // skip malformed skill.json
+            }
+        }
+    }
+    catch {
+        // directory doesn't exist or can't be read
+    }
+    return skills;
+}
+/**
+ * Install a skill from the built-in registry
+ */
+export function installSkill(name) {
+    const skill = REGISTRY.find((s) => s.name === name);
+    if (!skill) {
+        return { ok: false, message: `Skill "${name}" not found in registry` };
+    }
+    ensureSkillsDir();
+    const skillDir = join(SKILLS_DIR, name);
+    if (existsSync(skillDir)) {
+        return { ok: false, message: `Skill "${name}" is already installed` };
+    }
+    mkdirSync(skillDir, { recursive: true });
+    mkdirSync(join(skillDir, "examples"), { recursive: true });
+    // Write skill.json
+    const meta = {
+        name: skill.name,
+        description: skill.description,
+        version: skill.version,
+        author: skill.author,
+        tags: skill.tags,
+    };
+    writeFileSync(join(skillDir, "skill.json"), JSON.stringify(meta, null, 2));
+    // Write prompt.md
+    writeFileSync(join(skillDir, "prompt.md"), skill.prompt);
+    return { ok: true, message: `Installed skill: ${skill.name}` };
+}
+/**
+ * Remove an installed skill
+ */
+export function removeSkill(name) {
+    const skillDir = join(SKILLS_DIR, name);
+    if (!existsSync(skillDir)) {
+        return { ok: false, message: `Skill "${name}" is not installed` };
+    }
+    rmSync(skillDir, { recursive: true, force: true });
+    return { ok: true, message: `Removed skill: ${name}` };
+}
+/**
+ * Get the prompt.md content for an installed skill
+ */
+export function getSkillPrompt(name) {
+    const promptPath = join(SKILLS_DIR, name, "prompt.md");
+    if (!existsSync(promptPath))
+        return null;
+    return readFileSync(promptPath, "utf-8");
+}
+/**
+ * Get examples from a skill's examples/ directory
+ */
+function getSkillExamples(name) {
+    const examplesDir = join(SKILLS_DIR, name, "examples");
+    if (!existsSync(examplesDir))
+        return [];
+    try {
+        return readdirSync(examplesDir)
+            .filter((f) => f.endsWith(".md"))
+            .map((f) => readFileSync(join(examplesDir, f), "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get skills that should be active for the given project directory.
+ * If .codemaxxing/skills.json exists in the project, only those skills are active.
+ * Otherwise, all installed skills are active.
+ */
+export function getActiveSkills(cwd, sessionDisabled = new Set()) {
+    const installed = listInstalledSkills().map((s) => s.name);
+    let active;
+    const projectConfig = join(cwd, ".codemaxxing", "skills.json");
+    if (existsSync(projectConfig)) {
+        try {
+            const config = JSON.parse(readFileSync(projectConfig, "utf-8"));
+            const projectSkills = config.skills ?? [];
+            // Only include project skills that are actually installed
+            active = projectSkills.filter((s) => installed.includes(s));
+        }
+        catch {
+            active = installed;
+        }
+    }
+    else {
+        active = installed;
+    }
+    // Filter out session-disabled skills
+    return active.filter((s) => !sessionDisabled.has(s));
+}
+/**
+ * Build the skill prompt blocks to inject into the system prompt
+ */
+export function buildSkillPrompts(cwd, sessionDisabled = new Set()) {
+    const activeSkills = getActiveSkills(cwd, sessionDisabled);
+    if (activeSkills.length === 0)
+        return "";
+    const blocks = [];
+    for (const name of activeSkills) {
+        const prompt = getSkillPrompt(name);
+        if (!prompt)
+            continue;
+        blocks.push(`\n--- Skill: ${name} ---`);
+        blocks.push(prompt.trim());
+        // Include examples if any
+        const examples = getSkillExamples(name);
+        for (const example of examples) {
+            blocks.push(`\n### Example:\n${example.trim()}`);
+        }
+        blocks.push(`--- End Skill ---`);
+    }
+    return blocks.join("\n");
+}
+/**
+ * Create a scaffold for a new custom skill
+ */
+export function createSkillScaffold(name) {
+    ensureSkillsDir();
+    const skillDir = join(SKILLS_DIR, name);
+    if (existsSync(skillDir)) {
+        return { ok: false, message: `Skill "${name}" already exists` };
+    }
+    mkdirSync(skillDir, { recursive: true });
+    mkdirSync(join(skillDir, "examples"), { recursive: true });
+    const meta = {
+        name,
+        description: "A custom skill",
+        version: "1.0.0",
+        author: "you",
+        tags: [],
+    };
+    writeFileSync(join(skillDir, "skill.json"), JSON.stringify(meta, null, 2));
+    writeFileSync(join(skillDir, "prompt.md"), `# ${name}\n\nAdd your skill prompt here. This content will be injected into the system prompt.\n\n## Guidelines\n- Be specific and actionable\n- Include best practices\n- List anti-patterns to avoid\n`);
+    return { ok: true, message: `Created skill scaffold: ${name}`, path: skillDir };
+}
+/**
+ * Search the built-in registry by name, tags, or description
+ */
+export function searchRegistry(query) {
+    const q = query.toLowerCase();
+    return REGISTRY.filter((s) => s.name.toLowerCase().includes(q) ||
+        s.description.toLowerCase().includes(q) ||
+        s.tags.some((t) => t.toLowerCase().includes(q)));
+}
+/**
+ * Return all skills from the built-in registry
+ */
+export function getRegistrySkills() {
+    return REGISTRY;
+}
+/**
+ * Get the count of active skills
+ */
+export function getActiveSkillCount(cwd, sessionDisabled = new Set()) {
+    return getActiveSkills(cwd, sessionDisabled).length;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemaxxing",
-  "version": "0.1.13",
+  "version": "0.2.0",
   "description": "Open-source terminal coding agent. Connect any LLM. Max your code.",
   "main": "dist/index.js",
   "bin": {

package/src/agent.ts

@@ -8,6 +8,7 @@ import type {
 import { FILE_TOOLS, executeTool, generateDiff, getExistingContent } from "./tools/files.js";
 import { buildProjectContext, getSystemPrompt } from "./utils/context.js";
 import { isGitRepo, autoCommit } from "./utils/git.js";
+import { buildSkillPrompts, getActiveSkillCount } from "./utils/skills.js";
 import { createSession, saveMessage, updateTokenEstimate, updateSessionCost, loadMessages } from "./utils/sessions.js";
 import type { ProviderConfig } from "./config.js";
 
@@ -99,6 +100,7 @@ export class CodingAgent {
   private totalCost: number = 0;
   private systemPrompt: string = "";
   private compressionThreshold: number;
+  private sessionDisabledSkills: Set<string> = new Set();
 
   constructor(private options: AgentOptions) {
     this.providerType = options.provider.type || "openai";
@@ -128,7 +130,8 @@ export class CodingAgent {
    */
   async init(): Promise<void> {
     const context = await buildProjectContext(this.cwd);
-    this.systemPrompt = await getSystemPrompt(context);
+    const skillPrompts = buildSkillPrompts(this.cwd, this.sessionDisabledSkills);
+    this.systemPrompt = await getSystemPrompt(context, skillPrompts);
 
     this.messages = [
       { role: "system", content: this.systemPrompt },
@@ -689,6 +692,26 @@ export class CodingAgent {
     };
   }
 
+  disableSkill(name: string): void {
+    this.sessionDisabledSkills.add(name);
+  }
+
+  enableSkill(name: string): void {
+    this.sessionDisabledSkills.delete(name);
+  }
+
+  getSessionDisabledSkills(): Set<string> {
+    return this.sessionDisabledSkills;
+  }
+
+  getActiveSkillCount(): number {
+    return getActiveSkillCount(this.cwd, this.sessionDisabledSkills);
+  }
+
+  getCwd(): string {
+    return this.cwd;
+  }
+
   reset(): void {
     const systemMsg = this.messages[0];
     this.messages = [systemMsg];