@skhema/cli 0.3.1

package/dist/lib/output.js

@@ -0,0 +1,74 @@
+import chalk from 'chalk';
+let globalOptions = {};
+export function setGlobalOptions(options) {
+    globalOptions = { ...globalOptions, ...options };
+}
+export function getGlobalOptions() {
+    return globalOptions;
+}
+export function formatResult(result) {
+    if (globalOptions.json) {
+        return JSON.stringify(result, null, 2);
+    }
+    if (!result.success && result.error) {
+        return chalk.red(`Error: ${result.error}`);
+    }
+    return '';
+}
+export function outputSuccess(data, command) {
+    const result = {
+        success: true,
+        data,
+        metadata: {
+            timestamp: new Date().toISOString(),
+            command,
+        },
+    };
+    if (globalOptions.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+}
+export function outputError(error, command) {
+    const result = {
+        success: false,
+        error,
+        metadata: {
+            timestamp: new Date().toISOString(),
+            command,
+        },
+    };
+    if (globalOptions.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        console.error(chalk.red(`Error: ${error}`));
+    }
+}
+export function log(message) {
+    if (!globalOptions.quiet && !globalOptions.json) {
+        console.log(message);
+    }
+}
+export function logVerbose(message) {
+    if (globalOptions.verbose && !globalOptions.json) {
+        console.log(chalk.dim(message));
+    }
+}
+export function logHeader(title) {
+    if (!globalOptions.quiet && !globalOptions.json) {
+        console.log(chalk.bold.cyan(title));
+    }
+}
+export function logTable(headers, rows, columnWidths) {
+    if (globalOptions.json || globalOptions.quiet)
+        return;
+    const widths = columnWidths ||
+        headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] || '').length)));
+    const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join(' | ');
+    const separator = widths.map((w) => '-'.repeat(w)).join('-+-');
+    console.log(headerLine);
+    console.log(separator);
+    rows.forEach((row) => {
+        console.log(row.map((cell, i) => (cell || '').padEnd(widths[i])).join(' | '));
+    });
+}

package/dist/lib/skills/installer.d.ts

@@ -0,0 +1,4 @@
+import type { DetectedPlatform, InstallResult } from './types.js';
+export declare function installSkills(platforms: DetectedPlatform[]): Promise<InstallResult[]>;
+export declare function updateSkills(platforms: DetectedPlatform[]): Promise<InstallResult[]>;
+//# sourceMappingURL=installer.d.ts.map

package/dist/lib/skills/installer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installer.d.ts","sourceRoot":"","sources":["../../../src/lib/skills/installer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAgFjE,wBAAsB,aAAa,CACjC,SAAS,EAAE,gBAAgB,EAAE,GAC5B,OAAO,CAAC,aAAa,EAAE,CAAC,CA0C1B;AAED,wBAAsB,YAAY,CAChC,SAAS,EAAE,gBAAgB,EAAE,GAC5B,OAAO,CAAC,aAAa,EAAE,CAAC,CAG1B"}

package/dist/lib/skills/installer.js

@@ -0,0 +1,100 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { readLock, writeLock } from './lock.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function getBundledSkillsDir() {
+    // Navigate from dist/lib/skills/installer.js to skills/
+    return path.resolve(__dirname, '..', '..', '..', 'skills');
+}
+function getFileChecksum(content) {
+    return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+function getBundledSkills() {
+    const skillsDir = getBundledSkillsDir();
+    if (!fs.existsSync(skillsDir))
+        return [];
+    return fs
+        .readdirSync(skillsDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => ({
+        name: entry.name,
+        dir: path.join(skillsDir, entry.name),
+    }));
+}
+function copySkillToPlatform(skillDir, skillName, platform) {
+    const targetDir = path.join(platform.skillsDir, skillName);
+    const sourceFile = path.join(skillDir, 'SKILL.md');
+    const targetFile = path.join(targetDir, 'SKILL.md');
+    if (!fs.existsSync(sourceFile)) {
+        return { action: 'skipped', targetPath: targetDir };
+    }
+    const sourceContent = fs.readFileSync(sourceFile, 'utf-8');
+    // Check if target exists and compare content
+    if (fs.existsSync(targetFile)) {
+        const existingContent = fs.readFileSync(targetFile, 'utf-8');
+        if (existingContent === sourceContent) {
+            return { action: 'skipped', targetPath: targetDir };
+        }
+        // Content differs — update
+        fs.writeFileSync(targetFile, sourceContent);
+        return { action: 'updated', targetPath: targetDir };
+    }
+    // New install
+    fs.mkdirSync(targetDir, { recursive: true });
+    fs.writeFileSync(targetFile, sourceContent);
+    // Copy additional files recursively if they exist
+    copyAdditionalFiles(skillDir, targetDir);
+    return { action: 'installed', targetPath: targetDir };
+}
+function copyAdditionalFiles(sourceDir, targetDir) {
+    const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.name === 'SKILL.md')
+            continue; // Already handled
+        const sourcePath = path.join(sourceDir, entry.name);
+        const targetPath = path.join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            fs.mkdirSync(targetPath, { recursive: true });
+            copyAdditionalFiles(sourcePath, targetPath);
+        }
+        else {
+            fs.copyFileSync(sourcePath, targetPath);
+        }
+    }
+}
+export async function installSkills(platforms) {
+    const skills = getBundledSkills();
+    const results = [];
+    for (const platform of platforms) {
+        // Ensure skills directory exists
+        fs.mkdirSync(platform.skillsDir, { recursive: true });
+        const lock = readLock(platform);
+        for (const skill of skills) {
+            const { action, targetPath } = copySkillToPlatform(skill.dir, skill.name, platform);
+            results.push({
+                platform,
+                skill: skill.name,
+                action,
+                targetPath,
+            });
+            // Update lock file
+            if (action !== 'skipped') {
+                const sourceContent = fs.readFileSync(path.join(skill.dir, 'SKILL.md'), 'utf-8');
+                lock.skills[skill.name] = {
+                    version: '0.1.0',
+                    checksum: getFileChecksum(sourceContent),
+                    installedAt: new Date().toISOString(),
+                };
+            }
+        }
+        writeLock(platform, lock);
+    }
+    return results;
+}
+export async function updateSkills(platforms) {
+    // Update uses the same logic as install — content comparison handles skip/update
+    return installSkills(platforms);
+}

package/dist/lib/skills/lock.d.ts

@@ -0,0 +1,4 @@
+import type { DetectedPlatform, SkillLock } from './types.js';
+export declare function readLock(platform: DetectedPlatform): SkillLock;
+export declare function writeLock(platform: DetectedPlatform, lock: SkillLock): void;
+//# sourceMappingURL=lock.d.ts.map

package/dist/lib/skills/lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../../src/lib/skills/lock.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAM7D,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,GAAG,SAAS,CAiB9D;AAED,wBAAgB,SAAS,CAAC,QAAQ,EAAE,gBAAgB,EAAE,IAAI,EAAE,SAAS,GAAG,IAAI,CAI3E"}

package/dist/lib/skills/lock.js

@@ -0,0 +1,28 @@
+import fs from 'fs';
+import path from 'path';
+import { SKILL_LOCK_FILE } from '../config.js';
+function getLockFilePath(platform) {
+    return path.join(platform.skillsDir, SKILL_LOCK_FILE);
+}
+export function readLock(platform) {
+    const lockPath = getLockFilePath(platform);
+    try {
+        if (fs.existsSync(lockPath)) {
+            const data = fs.readFileSync(lockPath, 'utf-8');
+            return JSON.parse(data);
+        }
+    }
+    catch {
+        // Corrupted lock file — start fresh
+    }
+    return {
+        version: '1',
+        installedAt: new Date().toISOString(),
+        skills: {},
+    };
+}
+export function writeLock(platform, lock) {
+    const lockPath = getLockFilePath(platform);
+    lock.installedAt = new Date().toISOString();
+    fs.writeFileSync(lockPath, JSON.stringify(lock, null, 2) + '\n');
+}

package/dist/lib/skills/platform-detect.d.ts

@@ -0,0 +1,4 @@
+import type { DetectedPlatform } from './types.js';
+export declare function detectPlatforms(): DetectedPlatform[];
+export declare function getPlatformById(id: string): DetectedPlatform | undefined;
+//# sourceMappingURL=platform-detect.d.ts.map

package/dist/lib/skills/platform-detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-detect.d.ts","sourceRoot":"","sources":["../../../src/lib/skills/platform-detect.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAgFlD,wBAAgB,eAAe,IAAI,gBAAgB,EAAE,CAKpD;AAED,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAExE"}

package/dist/lib/skills/platform-detect.js

@@ -0,0 +1,89 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+// All providers below adopt the Anthropic Agent Skills convention:
+// `<config-dir>/skills/<skill-name>/SKILL.md` with YAML frontmatter.
+// `~/.agents/skills/` is the emerging universal alias (read by Gemini CLI + Warp).
+const PLATFORMS = [
+    {
+        id: 'agents',
+        name: 'Universal (.agents)',
+        configDir: path.join(os.homedir(), '.agents'),
+        skillsDir: path.join(os.homedir(), '.agents', 'skills'),
+    },
+    {
+        id: 'claude',
+        name: 'Claude Code',
+        configDir: path.join(os.homedir(), '.claude'),
+        skillsDir: path.join(os.homedir(), '.claude', 'skills'),
+    },
+    {
+        id: 'codex',
+        name: 'Codex',
+        configDir: path.join(os.homedir(), '.codex'),
+        skillsDir: path.join(os.homedir(), '.codex', 'skills'),
+    },
+    {
+        id: 'gemini',
+        name: 'Gemini CLI',
+        configDir: path.join(os.homedir(), '.gemini'),
+        skillsDir: path.join(os.homedir(), '.gemini', 'skills'),
+    },
+    {
+        id: 'warp',
+        name: 'Warp',
+        configDir: path.join(os.homedir(), '.warp'),
+        skillsDir: path.join(os.homedir(), '.warp', 'skills'),
+    },
+    {
+        id: 'cursor',
+        name: 'Cursor',
+        configDir: path.join(os.homedir(), '.cursor'),
+        skillsDir: path.join(os.homedir(), '.cursor', 'skills'),
+    },
+    {
+        id: 'copilot',
+        name: 'GitHub Copilot',
+        configDir: path.join(os.homedir(), '.copilot'),
+        skillsDir: path.join(os.homedir(), '.copilot', 'skills'),
+    },
+    {
+        id: 'factory',
+        name: 'Factory',
+        configDir: path.join(os.homedir(), '.factory'),
+        skillsDir: path.join(os.homedir(), '.factory', 'skills'),
+    },
+    {
+        id: 'opencode',
+        name: 'OpenCode',
+        configDir: path.join(os.homedir(), '.opencode'),
+        skillsDir: path.join(os.homedir(), '.opencode', 'skills'),
+    },
+    {
+        id: 'antigravity',
+        name: 'Antigravity',
+        configDir: path.join(os.homedir(), '.antigravity'),
+        skillsDir: path.join(os.homedir(), '.antigravity', 'skills'),
+    },
+    {
+        id: 'continue',
+        name: 'Continue',
+        configDir: path.join(os.homedir(), '.continue'),
+        skillsDir: path.join(os.homedir(), '.continue', 'skills'),
+    },
+    {
+        id: 'cline',
+        name: 'Cline',
+        configDir: path.join(os.homedir(), '.cline'),
+        skillsDir: path.join(os.homedir(), '.cline', 'skills'),
+    },
+];
+export function detectPlatforms() {
+    return PLATFORMS.map((platform) => ({
+        ...platform,
+        detected: fs.existsSync(platform.configDir),
+    }));
+}
+export function getPlatformById(id) {
+    return detectPlatforms().find((p) => p.id === id);
+}

package/dist/lib/skills/types.d.ts

@@ -0,0 +1,29 @@
+export interface DetectedPlatform {
+    id: string;
+    name: string;
+    configDir: string;
+    skillsDir: string;
+    detected: boolean;
+}
+export interface SkillManifest {
+    name: string;
+    description: string;
+    version: string;
+    files: string[];
+}
+export interface InstallResult {
+    platform: DetectedPlatform;
+    skill: string;
+    action: 'installed' | 'updated' | 'skipped';
+    targetPath: string;
+}
+export interface SkillLock {
+    version: string;
+    installedAt: string;
+    skills: Record<string, {
+        version: string;
+        checksum: string;
+        installedAt: string;
+    }>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/skills/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/skills/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,SAAS,CAAA;IAC3C,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,MAAM,CACZ,MAAM,EACN;QACE,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,EAAE,MAAM,CAAA;QAChB,WAAW,EAAE,MAAM,CAAA;KACpB,CACF,CAAA;CACF"}

package/dist/lib/skills/types.js

@@ -0,0 +1 @@
+export {};

package/dist/postinstall.d.ts

@@ -0,0 +1,2 @@
+declare const isTTY: boolean;
+//# sourceMappingURL=postinstall.d.ts.map

package/dist/postinstall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postinstall.d.ts","sourceRoot":"","sources":["../src/postinstall.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,KAAK,SAAuB,CAAA"}

package/dist/postinstall.js

@@ -0,0 +1,11 @@
+"use strict";
+const isTTY = process.stdout.isTTY;
+if (isTTY) {
+    console.log('');
+    console.log('  \x1b[36m@skhema/cli\x1b[0m installed successfully!');
+    console.log('');
+    console.log('  Get started:');
+    console.log('    \x1b[1mskhema auth login\x1b[0m     Authenticate with Skhema');
+    console.log('    \x1b[1mskhema skills install\x1b[0m  Install AI skills to your agent platforms');
+    console.log('');
+}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@skhema/cli",
+  "version": "0.3.1",
+  "description": "Skhema CLI - Authentication and AI skills management for agent platforms",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "skhema": "./bin/skhema.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "bin",
+    "skills"
+  ],
+  "scripts": {
+    "dev": "tsc --watch",
+    "build": "tsc",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist node_modules skills",
+    "clean:dist": "rm -rf dist",
+    "sync-skills": "tsx scripts/sync-skills.ts",
+    "prebuild": "npm run clean:dist && npm run sync-skills",
+    "prepack": "npm run sync-skills",
+    "check": "npm run typecheck && npm run lint && npm run format:check",
+    "check:fix": "npm run format && npm run lint:fix",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node dist/postinstall.js || true"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "ora": "^8.0.0",
+    "@skhema/agent-sdk": "0.1.4",
+    "@skhema/sdk": "0.1.2"
+  },
+  "devDependencies": {
+    "@skhema/linter": "2.2.0",
+    "@skhema/prettier-config": "1.0.0",
+    "@types/node": "^22.0.0",
+    "eslint": "^9.0.0",
+    "prettier": "^3.0.0",
+    "prettier-plugin-organize-imports": "^4.3.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://skhema.com/docs/api"
+}

package/skills/.manifest.json

@@ -0,0 +1,15 @@
+{
+  "syncedAt": "2026-07-09T00:22:20.025Z",
+  "source": "/Users/michaellovell/Desktop/GitHub/skhema-skills",
+  "sourceSha": "77561c7dbde8602ca799e5224c65ea18675ee37b",
+  "skills": [
+    "skhema-challenge-framing",
+    "skhema-coherence-check",
+    "skhema-element-decomposition",
+    "skhema-element-writer",
+    "skhema-judgment-audit",
+    "skhema-semantic-sharpening",
+    "skhema-strategy-advisor",
+    "skhema-workspace-navigator"
+  ]
+}

package/skills/skhema-challenge-framing/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: skhema-challenge-framing
+description: "Guide strategic challenge articulation—avoid symptoms, ensure actionable and bounded problem statements."
+---
+
+# Challenge Framing
+
+Guide users through articulating strategic challenges with precision.
+
+## When to Use
+
+- Starting a new strategy process
+- When a problem feels vague or overwhelming
+- When stakeholders disagree on "the real issue"
+
+## Key Principles
+
+- Challenges are not symptoms
+- A well-framed challenge is specific, bounded, and actionable
+- The framing itself is a strategic choice
+
+## Process
+
+TODO: Define the step-by-step process
+
+## Examples --> what does good look like?
+
+TODO: Add worked examples

package/skills/skhema-coherence-check/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: skhema-coherence-check
+description: "Examine strategic elements for internal consistency—flag contradictions, tensions, or gaps between decisions."
+---
+
+# Coherence Check
+
+Validate that a set of strategic elements form a coherent whole.
+
+## When to Use
+
+- After multiple elements have been defined
+- When strategy feels fragmented
+- Before communicating strategy to others
+
+## Key Principles
+
+- Coherence is not automatic—it must be checked
+- Tensions may be acceptable if acknowledged
+- Gaps are often invisible until explicitly sought
+
+## Check Types
+
+TODO: Categories of coherence issues
+
+## Process
+
+TODO: How to systematically check for coherence

package/skills/skhema-element-decomposition/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: skhema-element-decomposition
+description: "Break strategic questions into discrete judgment elements—surface individual decisions and their dependencies."
+---
+
+# Element Decomposition
+
+Help users decompose strategy into its constituent judgment elements.
+
+## When to Use
+
+- After a challenge has been framed
+- When facing a complex strategic question
+- To create clarity on what decisions actually need to be made
+
+## Key Principles
+
+- Each element represents a single judgment or decision
+- Elements have dependencies and sequences
+- Decomposition reveals hidden complexity
+
+## Process
+
+TODO: Define the decomposition method
+
+## Element Types
+
+TODO: Categorize types of strategic elements

package/skills/skhema-element-writer/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: skhema-element-writer
+description: Use when creating or editing Skhema elements, structuring element content, organizing elements into components, or applying strategy frameworks during element authoring.
+---
+
+# Skhema Element Writer
+
+A skill for creating and managing Skhema elements — the building blocks of your product strategy.
+
+## Capabilities
+
+- Create new elements with proper structure
+- Edit existing element content
+- Organize elements into components
+- Apply strategy frameworks to element creation
+
+## Usage
+
+This skill is automatically available when installed to your agent platform.
+Ask your AI assistant to create or edit Skhema elements.

package/skills/skhema-judgment-audit/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: skhema-judgment-audit
+description: "Surface assumptions, evidence quality, and confidence levels for strategic elements. Distinguish facts from beliefs."
+---
+
+# Judgment Audit
+
+Examine the foundations of strategic judgments and decisions.
+
+## When to Use
+
+- Validating critical strategic elements
+- When confidence in a decision is unclear
+- Before committing significant resources
+
+## Key Principles
+
+- Every judgment rests on assumptions
+- Evidence varies in quality and relevance
+- Distinguishing facts from beliefs prevents overconfidence
+
+## Audit Dimensions
+
+TODO: Define what to examine in each judgment
+
+## Confidence Framework
+
+TODO: How to assess and communicate confidence levels

package/skills/skhema-semantic-sharpening/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: skhema-semantic-sharpening
+description: "Review strategy language for ambiguity and vague terms. Ensure precise meaning and shared understanding."
+---
+
+# Semantic Sharpening
+
+Review and refine strategic language for clarity and precision.
+
+## When to Use
+
+- Reviewing strategy documents or statements
+- When team members interpret terms differently
+- Before finalizing strategic commitments
+
+## Key Principles
+
+- Ambiguity is the enemy of execution
+- Many strategy failures are semantic failures
+- Precision enables accountability
+
+## Common Patterns
+
+TODO: Document common semantic traps
+
+## Techniques  --> what does good look like?
+
+TODO: Methods for sharpening language

package/skills/skhema-strategy-advisor/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: skhema-strategy-advisor
+description: Use when developing or refining product strategy in Skhema, including positioning, market fit analysis, competitive evaluation, and strategic recommendations.
+---
+
+# Skhema Strategy Advisor
+
+A skill that helps you develop and refine product strategies using the Skhema framework.
+
+## Capabilities
+
+- Analyze product positioning and market fit
+- Generate strategic recommendations
+- Evaluate competitive landscapes
+- Create actionable strategy documents
+
+## Usage
+
+This skill is automatically available when installed to your agent platform.
+Ask your AI assistant about product strategy, positioning, or competitive analysis.

package/skills/skhema-workspace-navigator/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: skhema-workspace-navigator
+description: Use when navigating a Skhema workspace, inspecting workspace structure, searching workspace content, understanding hierarchy, or moving between related elements.
+---
+
+# Skhema Workspace Navigator
+
+A skill for navigating and understanding your Skhema workspace structure.
+
+## Capabilities
+
+- Browse workspace components and elements
+- Search across workspace content
+- Understand workspace hierarchy
+- Navigate between related elements
+
+## Usage
+
+This skill is automatically available when installed to your agent platform.
+Ask your AI assistant to help you navigate your Skhema workspace.