scalix 1.1.0 → 1.2.0

package/dist/skills.js

@@ -0,0 +1,269 @@
+import fs from 'node:fs/promises';
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { logger } from './logger.js';
+import { PROJECT_LOOKUP_DIRS } from './constants.js';
+const SKILL_DIRS = PROJECT_LOOKUP_DIRS.map(d => `${d}/skills`);
+function parseSkillFrontmatter(content) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+    if (!match)
+        return null;
+    const meta = {};
+    let currentKey = '';
+    let isList = false;
+    for (const line of match[1].split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('- ') && isList && currentKey) {
+            const arr = meta[currentKey];
+            if (Array.isArray(arr))
+                arr.push(trimmed.slice(2).trim());
+            else
+                meta[currentKey] = [trimmed.slice(2).trim()];
+            continue;
+        }
+        const idx = line.indexOf(':');
+        if (idx > 0) {
+            currentKey = line.slice(0, idx).trim();
+            const value = line.slice(idx + 1).trim();
+            if (value === '' || value === '[]') {
+                meta[currentKey] = [];
+                isList = true;
+            }
+            else {
+                meta[currentKey] = value;
+                isList = false;
+            }
+        }
+    }
+    const name = meta.name || '';
+    const description = meta.description || '';
+    if (!name)
+        return null;
+    return {
+        meta: {
+            name,
+            description,
+            version: meta.version || '1.0.0',
+            paths: Array.isArray(meta.paths) ? meta.paths : (meta.paths ? [meta.paths] : []),
+            triggers: Array.isArray(meta.triggers) ? meta.triggers : (meta.triggers ? [meta.triggers] : []),
+        },
+        body: match[2],
+    };
+}
+async function discoverResources(skillDir) {
+    const resources = { scripts: [], references: [], examples: [], assets: [] };
+    const dirs = ['scripts', 'references', 'examples', 'assets'];
+    for (const dir of dirs) {
+        const fullDir = path.join(skillDir, dir);
+        try {
+            const entries = await fs.readdir(fullDir, { withFileTypes: true });
+            resources[dir] = entries
+                .filter(e => e.isFile())
+                .map(e => path.join(fullDir, e.name));
+        }
+        catch { }
+    }
+    return resources;
+}
+export async function loadSkills(cwd = process.cwd()) {
+    const skills = [];
+    for (const dir of SKILL_DIRS) {
+        const fullDir = path.resolve(cwd, dir);
+        let entries;
+        try {
+            entries = await fs.readdir(fullDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                if (entry.isFile() && entry.name === 'SKILL.md') {
+                    const skill = await loadSkillFile(path.join(fullDir, entry.name), fullDir);
+                    if (skill)
+                        skills.push(skill);
+                }
+                continue;
+            }
+            const skillFile = path.join(fullDir, entry.name, 'SKILL.md');
+            if (existsSync(skillFile)) {
+                const skill = await loadSkillFile(skillFile, path.join(fullDir, entry.name));
+                if (skill)
+                    skills.push(skill);
+            }
+        }
+    }
+    skills.push(...getBuiltinSkills());
+    return skills;
+}
+async function loadSkillFile(filePath, skillDir) {
+    try {
+        const raw = await fs.readFile(filePath, 'utf-8');
+        const parsed = parseSkillFrontmatter(raw);
+        if (!parsed)
+            return null;
+        const resources = await discoverResources(skillDir);
+        return {
+            name: parsed.meta.name,
+            description: parsed.meta.description,
+            version: parsed.meta.version || '1.0.0',
+            paths: parsed.meta.paths || [],
+            triggers: parsed.meta.triggers || [],
+            content: parsed.body.trim(),
+            source: filePath,
+            resources,
+            builtin: false,
+        };
+    }
+    catch (err) {
+        logger.warn('Failed to load skill', { path: filePath, error: err.message });
+        return null;
+    }
+}
+export function getSkillsForPath(skills, filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    return skills.filter(skill => skill.paths.some(p => {
+        const pattern = p.replace(/\\/g, '/');
+        if (pattern.endsWith('/**')) {
+            return normalized.startsWith(pattern.slice(0, -3));
+        }
+        if (pattern.endsWith('/*')) {
+            const dir = pattern.slice(0, -2);
+            return normalized.startsWith(dir) && !normalized.slice(dir.length + 1).includes('/');
+        }
+        return normalized.startsWith(pattern);
+    }));
+}
+export function getSkillByTrigger(skills, input) {
+    const lower = input.toLowerCase();
+    return skills.find(skill => skill.triggers.some(t => lower.includes(t.toLowerCase()))) || null;
+}
+export function getSkillContent(skill, level = 'full') {
+    if (level === 'metadata') {
+        return `**${skill.name}** (v${skill.version}) — ${skill.description}`;
+    }
+    let content = skill.content;
+    if (level === 'resources') {
+        const resourceFiles = [
+            ...skill.resources.scripts,
+            ...skill.resources.references,
+            ...skill.resources.examples,
+        ];
+        for (const filePath of resourceFiles) {
+            if (existsSync(filePath)) {
+                try {
+                    const fileContent = readFileSync(filePath, 'utf-8');
+                    const relPath = path.basename(filePath);
+                    content += `\n\n<resource path="${relPath}">\n${fileContent}\n</resource>`;
+                }
+                catch { }
+            }
+        }
+    }
+    return content;
+}
+export function skillsSummary(skills) {
+    if (skills.length === 0)
+        return 'No skills available.';
+    const lines = ['Available skills:'];
+    for (const s of skills) {
+        const paths = s.paths.length > 0 ? ` [paths: ${s.paths.join(', ')}]` : '';
+        const builtin = s.builtin ? ' (built-in)' : '';
+        lines.push(`  ${s.name} — ${s.description}${paths}${builtin}`);
+    }
+    return lines.join('\n');
+}
+function getBuiltinSkills() {
+    const emptyResources = { scripts: [], references: [], examples: [], assets: [] };
+    return [
+        {
+            name: 'feature-dev',
+            description: 'Guided 7-phase feature development workflow',
+            version: '1.0.0',
+            paths: [],
+            triggers: ['new feature', 'implement feature', 'build feature', 'add feature'],
+            content: `# Feature Development Workflow
+
+Follow this 7-phase process for developing new features:
+
+## Phase 1: Requirements
+- Clarify the feature scope and acceptance criteria
+- Identify affected files and components
+- List edge cases and error scenarios
+
+## Phase 2: Design
+- Propose the technical approach
+- Identify new files, modified files, and interfaces
+- Consider backwards compatibility
+
+## Phase 3: Implementation
+- Write the core implementation
+- Follow existing code conventions
+- Keep changes minimal and focused
+
+## Phase 4: Testing
+- Write unit tests for new functions
+- Test edge cases identified in Phase 1
+- Run existing test suite to check for regressions
+
+## Phase 5: Integration
+- Wire up the feature with existing code
+- Update configuration if needed
+- Add feature flags if appropriate
+
+## Phase 6: Documentation
+- Update relevant documentation
+- Add inline comments only where the "why" is non-obvious
+- Update CHANGELOG if one exists
+
+## Phase 7: Review
+- Run linter and type checker
+- Review diff for accidental changes
+- Verify the feature works end-to-end`,
+            source: 'built-in',
+            resources: emptyResources,
+            builtin: true,
+        },
+        {
+            name: 'code-review',
+            description: 'Systematic code review of current changes',
+            version: '1.0.0',
+            paths: [],
+            triggers: ['review code', 'code review', 'review changes', 'review my changes'],
+            content: `# Code Review
+
+Review the current changes systematically:
+
+1. **Run \`git diff\`** to see all uncommitted changes
+2. **Security**: Check for hardcoded secrets, SQL injection, XSS, path traversal
+3. **Correctness**: Verify logic, edge cases, error handling
+4. **Style**: Check naming, formatting, consistency with codebase conventions
+5. **Performance**: Look for N+1 queries, unnecessary allocations, blocking I/O
+6. **Testing**: Are new functions tested? Are existing tests still valid?
+7. **Summary**: Provide a structured review with findings categorized as Critical / Important / Minor`,
+            source: 'built-in',
+            resources: emptyResources,
+            builtin: true,
+        },
+        {
+            name: 'commit-push-pr',
+            description: 'Commit changes, push, and create a pull request',
+            version: '1.0.0',
+            paths: [],
+            triggers: ['commit and push', 'create pr', 'open pr', 'make a pr'],
+            content: `# Commit, Push & PR
+
+1. **Stage changes**: Review \`git status\` and stage relevant files
+2. **Commit**: Write a concise commit message (imperative mood, <72 chars)
+3. **Push**: Push to the remote branch
+4. **PR**: Create a pull request with:
+   - Clear title (matches commit message style)
+   - Description summarizing what changed and why
+   - Link to related issues if applicable
+   - List any manual testing done`,
+            source: 'built-in',
+            resources: emptyResources,
+            builtin: true,
+        },
+    ];
+}

package/dist/terminal-notify.js

@@ -0,0 +1,73 @@
+// Terminal notification passthrough for iTerm2, Kitty, Ghostty, and tmux
+function detectTerminal() {
+    const term = process.env.TERM_PROGRAM?.toLowerCase() || '';
+    const tmux = !!process.env.TMUX;
+    if (tmux)
+        return 'tmux';
+    if (term === 'iterm.app' || term === 'iterm2')
+        return 'iterm2';
+    if (term === 'kitty')
+        return 'kitty';
+    if (term === 'ghostty')
+        return 'ghostty';
+    return 'generic';
+}
+function wrapForTmux(seq) {
+    return `\x1bPtmux;\x1b${seq}\x1b\\`;
+}
+function sendOSC(code, payload) {
+    const terminal = detectTerminal();
+    const seq = `\x1b]${code};${payload}\x07`;
+    if (terminal === 'tmux') {
+        process.stdout.write(wrapForTmux(seq));
+    }
+    else {
+        process.stdout.write(seq);
+    }
+}
+export function sendNotification(title, body) {
+    const terminal = detectTerminal();
+    switch (terminal) {
+        case 'iterm2':
+            sendOSC(9, body ? `${title}: ${body}` : title);
+            break;
+        case 'kitty':
+            sendOSC(99, `i=1:d=0:p=title;${title}`);
+            if (body) {
+                sendOSC(99, `i=1:d=1:p=body;${body}`);
+            }
+            else {
+                sendOSC(99, `i=1:d=1:p=body;`);
+            }
+            break;
+        case 'ghostty':
+            sendOSC(777, `notify;${title};${body || ''}`);
+            break;
+        case 'tmux': {
+            const tmuxPayload = body ? `${title}: ${body}` : title;
+            sendOSC(9, tmuxPayload);
+            break;
+        }
+        case 'generic':
+            // OSC 9 is widely supported (ConEmu, Windows Terminal, etc.)
+            sendOSC(9, body ? `${title}: ${body}` : title);
+            break;
+    }
+}
+export function sendBell() {
+    process.stdout.write('\x07');
+}
+export function setTerminalTitle(title) {
+    sendOSC(0, title);
+}
+export function notifyTaskComplete(taskName) {
+    sendNotification('Scalix', `${taskName} complete`);
+    sendBell();
+}
+export function notifyError(message) {
+    sendNotification('Scalix Error', message);
+    sendBell();
+}
+export function getTerminalType() {
+    return detectTerminal();
+}

package/dist/text-utils.js

@@ -0,0 +1,146 @@
+// CJK/RTL text support utilities
+const CJK_RANGES = [
+    [0x2E80, 0x2EFF], // CJK Radicals Supplement
+    [0x2F00, 0x2FDF], // Kangxi Radicals
+    [0x3000, 0x303F], // CJK Symbols and Punctuation
+    [0x3040, 0x309F], // Hiragana
+    [0x30A0, 0x30FF], // Katakana
+    [0x3100, 0x312F], // Bopomofo
+    [0x3130, 0x318F], // Hangul Compatibility Jamo
+    [0x3200, 0x32FF], // Enclosed CJK Letters and Months
+    [0x3400, 0x4DBF], // CJK Unified Ideographs Extension A
+    [0x4E00, 0x9FFF], // CJK Unified Ideographs
+    [0xAC00, 0xD7AF], // Hangul Syllables
+    [0xF900, 0xFAFF], // CJK Compatibility Ideographs
+    [0xFE30, 0xFE4F], // CJK Compatibility Forms
+    [0xFF00, 0xFFEF], // Halfwidth and Fullwidth Forms
+    [0x20000, 0x2A6DF], // CJK Unified Ideographs Extension B
+    [0x2A700, 0x2B73F], // CJK Unified Ideographs Extension C
+    [0x2B740, 0x2B81F], // CJK Unified Ideographs Extension D
+];
+const RTL_RANGES = [
+    [0x0590, 0x05FF], // Hebrew
+    [0x0600, 0x06FF], // Arabic
+    [0x0700, 0x074F], // Syriac
+    [0x0750, 0x077F], // Arabic Supplement
+    [0x0780, 0x07BF], // Thaana
+    [0x07C0, 0x07FF], // NKo
+    [0x0800, 0x083F], // Samaritan
+    [0x0840, 0x085F], // Mandaic
+    [0x08A0, 0x08FF], // Arabic Extended-A
+    [0xFB50, 0xFDFF], // Arabic Presentation Forms-A
+    [0xFE70, 0xFEFF], // Arabic Presentation Forms-B
+    [0x10800, 0x1083F], // Cypriot Syllabary
+];
+function inRange(code, ranges) {
+    for (const [lo, hi] of ranges) {
+        if (code >= lo && code <= hi)
+            return true;
+    }
+    return false;
+}
+export function isCJK(char) {
+    const code = char.codePointAt(0) ?? 0;
+    return inRange(code, CJK_RANGES);
+}
+export function isRTL(char) {
+    const code = char.codePointAt(0) ?? 0;
+    return inRange(code, RTL_RANGES);
+}
+export function getCharWidth(char) {
+    const code = char.codePointAt(0) ?? 0;
+    if (inRange(code, CJK_RANGES))
+        return 2;
+    if (code >= 0xD800 && code <= 0xDFFF)
+        return 0; // surrogate pair half
+    if (code >= 0x0300 && code <= 0x036F)
+        return 0; // combining diacritical marks
+    if (code >= 0x0900 && code <= 0x097F)
+        return 1; // Devanagari
+    if (code >= 0xFE00 && code <= 0xFE0F)
+        return 0; // variation selectors
+    if (code >= 0x200B && code <= 0x200F)
+        return 0; // zero-width chars
+    if (code >= 0x202A && code <= 0x202E)
+        return 0; // bidi marks
+    if (code >= 0x2060 && code <= 0x206F)
+        return 0; // invisible operators
+    return 1;
+}
+export function stringWidth(str) {
+    let width = 0;
+    for (const char of str) {
+        width += getCharWidth(char);
+    }
+    return width;
+}
+export function detectTextDirection(text) {
+    let rtlCount = 0;
+    let ltrCount = 0;
+    for (const char of text) {
+        if (isRTL(char))
+            rtlCount++;
+        else if (/[a-zA-Z]/.test(char))
+            ltrCount++;
+    }
+    if (rtlCount === 0 && ltrCount === 0)
+        return 'ltr';
+    if (rtlCount > 0 && ltrCount === 0)
+        return 'rtl';
+    if (rtlCount === 0 && ltrCount > 0)
+        return 'ltr';
+    return 'mixed';
+}
+export function wrapText(text, maxWidth) {
+    const lines = [];
+    let currentLine = '';
+    let currentWidth = 0;
+    for (const char of text) {
+        if (char === '\n') {
+            lines.push(currentLine);
+            currentLine = '';
+            currentWidth = 0;
+            continue;
+        }
+        const charWidth = getCharWidth(char);
+        if (currentWidth + charWidth > maxWidth && currentLine.length > 0) {
+            lines.push(currentLine);
+            currentLine = char;
+            currentWidth = charWidth;
+        }
+        else {
+            currentLine += char;
+            currentWidth += charWidth;
+        }
+    }
+    if (currentLine.length > 0) {
+        lines.push(currentLine);
+    }
+    return lines;
+}
+export function truncateText(text, maxWidth, ellipsis = '…') {
+    const ellipsisWidth = stringWidth(ellipsis);
+    let width = 0;
+    let result = '';
+    for (const char of text) {
+        const charWidth = getCharWidth(char);
+        if (width + charWidth + ellipsisWidth > maxWidth) {
+            return result + ellipsis;
+        }
+        result += char;
+        width += charWidth;
+    }
+    return result;
+}
+export function applyRTLMarks(text) {
+    const dir = detectTextDirection(text);
+    if (dir === 'rtl') {
+        return `‏${text}‏`;
+    }
+    if (dir === 'mixed') {
+        return text.replace(/[֐-׿؀-ۿ܀-ݏ]+/g, (match) => {
+            return `‏${match}‏`;
+        });
+    }
+    return text;
+}

package/dist/tools-extra.js

@@ -353,13 +353,7 @@ export const gitCommitTool = tool({
         files: z.array(z.string().max(500)).optional().describe('Files to stage (default: all changed files)'),
     }),
     execute: async ({ message, files }) => {
-        const gitEnv = {
-            ...process.env,
-            GIT_AUTHOR_NAME: GIT_BOT_IDENTITY.name,
-            GIT_AUTHOR_EMAIL: GIT_BOT_IDENTITY.email,
-            GIT_COMMITTER_NAME: GIT_BOT_IDENTITY.name,
-            GIT_COMMITTER_EMAIL: GIT_BOT_IDENTITY.email,
-        };
+        const fullMessage = message + `\n\nCo-Authored-By: ${GIT_BOT_IDENTITY.name} <${GIT_BOT_IDENTITY.email}>`;
         try {
             if (files && files.length > 0) {
                 const safePaths = files.map((f) => sandboxPath(f));
@@ -372,7 +366,7 @@ export const gitCommitTool = tool({
             if (!staged.trim()) {
                 return { error: 'Nothing to commit. No changes are staged.' };
             }
-            const { stdout } = await execFileAsync('git', ['commit', '-m', message], { timeout: _limits.gitTimeoutMs, env: gitEnv });
+            const { stdout } = await execFileAsync('git', ['commit', '-m', fullMessage], { timeout: _limits.gitTimeoutMs });
             return { success: true, output: stdout.trim() };
         }
         catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scalix",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "AI coding agent for the terminal — edit code, run commands, and build with Scalix",
   "main": "dist/headless.js",
   "bin": {
@@ -61,12 +61,13 @@
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@types/node": "^25.5.2",
+    "@types/node": "^25.6.0",
     "@types/react": "^19.2.14",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
     "@vitest/coverage-v8": "^3.2.4",
     "eslint": "^9.0.0",
+    "playwright": "^1.59.1",
     "tsx": "^4.21.0",
     "typescript": "^6.0.2",
     "vitest": "^3.0.0"