nastech-app 1.0.0

package/sources/components/markdown/parseMarkdownSpans.ts

@@ -0,0 +1,88 @@
+import type { MarkdownSpan } from "./parseMarkdown";
+
+// Updated pattern to handle nested markdown and asterisks
+const pattern = /(\*\*(.*?)(?:\*\*|$))|(\*(.*?)(?:\*|$))|(\[([^\]]+)\](?:\(([^)]+)\))?)|(`(.*?)(?:`|$))/g;
+
+function pushTextWithAutoLinks(spans: MarkdownSpan[], text: string, styles: MarkdownSpan['styles']) {
+    const urlPattern = /https?:\/\/[^\s<]+/g;
+    let lastIndex = 0;
+    let match: RegExpExecArray | null;
+
+    while ((match = urlPattern.exec(text)) !== null) {
+        const plainText = text.slice(lastIndex, match.index);
+        if (plainText) {
+            spans.push({ styles, text: plainText, url: null });
+        }
+
+        let url = match[0];
+        let trailing = '';
+        while (/[),.;:!?]$/.test(url)) {
+            trailing = url.slice(-1) + trailing;
+            url = url.slice(0, -1);
+        }
+
+        if (url) {
+            spans.push({ styles, text: url, url });
+        }
+        if (trailing) {
+            spans.push({ styles, text: trailing, url: null });
+        }
+
+        lastIndex = match.index + match[0].length;
+    }
+
+    if (lastIndex < text.length) {
+        spans.push({ styles, text: text.slice(lastIndex), url: null });
+    }
+}
+
+export function parseMarkdownSpans(markdown: string, header: boolean) {
+    const spans: MarkdownSpan[] = [];
+    let lastIndex = 0;
+    let match: RegExpExecArray | null;
+    pattern.lastIndex = 0;
+
+    while ((match = pattern.exec(markdown)) !== null) {
+        // Capture the text between the end of the last match and the start of this match as plain text
+        const plainText = markdown.slice(lastIndex, match.index);
+        if (plainText) {
+            pushTextWithAutoLinks(spans, plainText, []);
+        }
+
+        if (match[1]) {
+            // Bold
+            if (header) {
+                pushTextWithAutoLinks(spans, match[2], []);
+            } else {
+                pushTextWithAutoLinks(spans, match[2], ['bold']);
+            }
+        } else if (match[3]) {
+            // Italic
+            if (header) {
+                pushTextWithAutoLinks(spans, match[4], []);
+            } else {
+                pushTextWithAutoLinks(spans, match[4], ['italic']);
+            }
+        } else if (match[5]) {
+            // Link - handle incomplete links (no URL part)
+            if (match[7]) {
+                spans.push({ styles: [], text: match[6], url: match[7] });
+            } else {
+                // If no URL part, treat as plain text with brackets
+                pushTextWithAutoLinks(spans, `[${match[6]}]`, []);
+            }
+        } else if (match[8]) {
+            // Inline code
+            spans.push({ styles: ['code'], text: match[9], url: null });
+        }
+
+        lastIndex = pattern.lastIndex;
+    }
+
+    // If there's any text remaining after the last match, treat it as plain
+    if (lastIndex < markdown.length) {
+        pushTextWithAutoLinks(spans, markdown.slice(lastIndex), []);
+    }
+
+    return spans;
+}

package/sources/components/modelModeOptions.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, it } from 'vitest';
+import {
+    getAvailableModels,
+    getAvailablePermissionModes,
+    getCodexModelModes,
+    getClaudePermissionModes,
+    getDefaultEffortKey,
+    getDefaultModelKey,
+    getDefaultPermissionModeKey,
+    mapMetadataOptions,
+    resolveCurrentOption,
+} from './modelModeOptions';
+
+const translate = (key: string) => `tr:${key}`;
+
+describe('modelModeOptions', () => {
+    it('maps metadata option shape into mode options', () => {
+        expect(mapMetadataOptions([
+            { code: 'm1', value: 'Model One', description: 'Primary model' },
+            { code: 'm2', value: 'Model Two' },
+        ])).toEqual([
+            { key: 'm1', name: 'Model One', description: 'Primary model' },
+            { key: 'm2', name: 'Model Two', description: null },
+        ]);
+    });
+
+    it('builds claude permission fallbacks with translated names', () => {
+        const modes = getClaudePermissionModes(translate);
+        expect(modes.map((mode) => mode.key)).toEqual(['default', 'plan', 'dontAsk', 'acceptEdits', 'bypassPermissions']);
+        expect(modes[0].name).toBe('tr:agentInput.permissionMode.default');
+    });
+
+    it('builds codex model fallbacks', () => {
+        const models = getCodexModelModes();
+        expect(models.map((model) => model.key)).toEqual([
+            'default',
+            'gpt-5.5',
+            'gpt-5.4',
+            'gpt-5.3-codex',
+            'gpt-5.2-codex',
+            'gpt-5.1-codex-max',
+            'gpt-5.2',
+            'gpt-5.1-codex-mini',
+        ]);
+        expect(models[0].name).toBe('default model');
+        expect(models[1].name).toBe('gpt-5.5');
+    });
+
+    it('uses code defaults for agent defaults', () => {
+        expect(getDefaultPermissionModeKey('claude')).toBe('bypassPermissions');
+        expect(getDefaultModelKey('claude')).toBe('opus');
+        expect(getDefaultEffortKey('claude')).toBe('medium');
+        expect(getDefaultPermissionModeKey('codex')).toBe('yolo');
+        expect(getDefaultModelKey('codex')).toBe('gpt-5.5');
+        expect(getDefaultEffortKey('codex')).toBe('medium');
+    });
+
+    it('prefers metadata models over hardcoded fallbacks', () => {
+        const models = getAvailableModels('gemini', {
+            models: [
+                { code: 'custom-gemini', value: 'Gemini Custom', description: 'From metadata' },
+            ],
+        } as any, translate);
+
+        expect(models).toEqual([
+            { key: 'custom-gemini', name: 'Gemini Custom', description: 'From metadata' },
+        ]);
+    });
+
+    it('adds codex default model option when metadata models are present', () => {
+        const models = getAvailableModels('codex', {
+            models: [
+                { code: 'gpt-5.4', value: 'gpt-5.4', description: 'Latest' },
+            ],
+        } as any, translate);
+
+        expect(models).toEqual([
+            { key: 'default', name: 'default model', description: null },
+            { key: 'gpt-5.4', name: 'gpt-5.4', description: 'Latest' },
+        ]);
+    });
+
+    it('keeps codex permission modes hardcoded even when metadata modes exist', () => {
+        const modes = getAvailablePermissionModes('codex', {
+            operatingModes: [{ code: 'metadata-only', value: 'Metadata Mode', description: null }],
+        } as any, translate);
+
+        expect(modes.map((mode) => mode.key)).toEqual(['default', 'read-only', 'safe-yolo', 'yolo']);
+    });
+
+    it('applies hacks to metadata-provided operating modes', () => {
+        const modes = getAvailablePermissionModes('gemini', {
+            operatingModes: [
+                { code: 'build', value: 'build, build', description: 'Do build steps' },
+                { code: 'plan', value: 'plan/plan', description: 'Plan first' },
+            ],
+        } as any, translate);
+
+        expect(modes).toEqual([
+            { key: 'build', name: 'Build', description: 'Do build steps' },
+            { key: 'plan', name: 'Plan', description: 'Plan first' },
+        ]);
+    });
+
+    it('resolves the first matching preferred key', () => {
+        const options = [
+            { key: 'a', name: 'A' },
+            { key: 'b', name: 'B' },
+        ];
+
+        expect(resolveCurrentOption(options, ['missing', 'b', 'a'])).toEqual({ key: 'b', name: 'B' });
+        expect(resolveCurrentOption(options, ['missing'])).toBeNull();
+    });
+});

package/sources/components/modelModeOptions.ts

@@ -0,0 +1,257 @@
+import type { Metadata } from '@/sync/storageTypes';
+import { hackModes } from '@/sync/modeHacks';
+import { getCodeAgentDefaults } from '@/sync/agentDefaults';
+
+export type ModeOption = {
+    key: string;
+    name: string;
+    description?: string | null;
+};
+
+export type PermissionMode = ModeOption;
+export type ModelMode = ModeOption;
+
+export type EffortLevel = ModeOption;
+export type PermissionModeKey = string;
+export type ModelModeKey = string;
+
+export type AgentFlavor = 'claude' | 'codex' | 'gemini' | string | null | undefined;
+
+type Translate = (key: any) => string;
+
+type MetadataOption = {
+    code: string;
+    value: string;
+    description?: string | null;
+};
+
+const GEMINI_MODEL_FALLBACKS: ModelMode[] = [
+    { key: 'gemini-3.1-pro-preview', name: 'gemini 3.1 pro', description: 'latest & most capable' },
+    { key: 'gemini-3-flash-preview', name: 'gemini 3 flash', description: 'latest & fast' },
+    { key: 'gemini-3.1-flash-lite-preview', name: 'gemini 3.1 flash lite', description: 'latest & fastest' },
+    { key: 'gemini-2.5-pro', name: 'gemini 2.5 pro', description: 'most capable' },
+    { key: 'gemini-2.5-flash', name: 'gemini 2.5 flash', description: 'fast & efficient' },
+    { key: 'gemini-2.5-flash-lite', name: 'gemini 2.5 flash lite', description: 'fastest' },
+];
+
+export function mapMetadataOptions(options?: MetadataOption[] | null): ModeOption[] {
+    if (!options || options.length === 0) {
+        return [];
+    }
+
+    return options.map((option) => ({
+        key: option.code,
+        name: option.value,
+        description: option.description ?? null,
+    }));
+}
+
+export function getClaudePermissionModes(translate: Translate): PermissionMode[] {
+    return [
+        { key: 'default', name: translate('agentInput.permissionMode.default'), description: null },
+        { key: 'plan', name: translate('agentInput.permissionMode.plan'), description: null },
+        { key: 'dontAsk', name: translate('agentInput.permissionMode.dontAsk'), description: null },
+        { key: 'acceptEdits', name: translate('agentInput.permissionMode.acceptEdits'), description: null },
+        { key: 'bypassPermissions', name: translate('agentInput.permissionMode.bypassPermissions'), description: null },
+    ];
+}
+
+export function getCodexPermissionModes(translate: Translate): PermissionMode[] {
+    return [
+        { key: 'default', name: translate('agentInput.codexPermissionMode.default'), description: null },
+        { key: 'read-only', name: translate('agentInput.codexPermissionMode.readOnly'), description: null },
+        { key: 'safe-yolo', name: translate('agentInput.codexPermissionMode.safeYolo'), description: null },
+        { key: 'yolo', name: translate('agentInput.codexPermissionMode.yolo'), description: null },
+    ];
+}
+
+export function getGeminiPermissionModes(translate: Translate): PermissionMode[] {
+    return [
+        { key: 'default', name: translate('agentInput.geminiPermissionMode.default'), description: null },
+        { key: 'auto_edit', name: translate('agentInput.geminiPermissionMode.autoEdit'), description: null },
+        { key: 'yolo', name: translate('agentInput.geminiPermissionMode.yolo'), description: null },
+        { key: 'plan', name: translate('agentInput.geminiPermissionMode.plan'), description: null },
+    ];
+}
+
+export function getClaudeModelModes(): ModelMode[] {
+    return [
+        { key: 'default', name: 'default model', description: null },
+        { key: 'opus', name: 'opus 4.7', description: null },
+        { key: 'sonnet', name: 'sonnet 4.6', description: null },
+        { key: 'haiku', name: 'haiku 4.5', description: null },
+    ];
+}
+
+export function getCodexModelModes(): ModelMode[] {
+    return [
+        { key: 'default', name: 'default model', description: null },
+        { key: 'gpt-5.5', name: 'gpt-5.5', description: null },
+        { key: 'gpt-5.4', name: 'gpt-5.4', description: null },
+        { key: 'gpt-5.3-codex', name: 'gpt-5.3-codex', description: null },
+        { key: 'gpt-5.2-codex', name: 'gpt-5.2-codex', description: null },
+        { key: 'gpt-5.1-codex-max', name: 'gpt-5.1-codex-max', description: null },
+        { key: 'gpt-5.2', name: 'gpt-5.2', description: null },
+        { key: 'gpt-5.1-codex-mini', name: 'gpt-5.1-codex-mini', description: null },
+    ];
+}
+
+export function getGeminiModelModes(): ModelMode[] {
+    return GEMINI_MODEL_FALLBACKS;
+}
+
+export function getOpenClawPermissionModes(translate: Translate): PermissionMode[] {
+    return [
+        { key: 'default', name: translate('agentInput.permissionMode.default'), description: null },
+        { key: 'bypassPermissions', name: translate('agentInput.permissionMode.bypassPermissions'), description: null },
+    ];
+}
+
+export function getHardcodedPermissionModes(flavor: AgentFlavor, translate: Translate): PermissionMode[] {
+    if (flavor === 'codex') {
+        return getCodexPermissionModes(translate);
+    }
+    if (flavor === 'gemini') {
+        return getGeminiPermissionModes(translate);
+    }
+    if (flavor === 'openclaw') {
+        return getOpenClawPermissionModes(translate);
+    }
+    return getClaudePermissionModes(translate);
+}
+
+export function getOpenClawModelModes(): ModelMode[] {
+    return [
+        { key: 'default', name: 'default model', description: null },
+    ];
+}
+
+export function getHardcodedModelModes(flavor: AgentFlavor, _translate: Translate): ModelMode[] {
+    if (flavor === 'codex') {
+        return getCodexModelModes();
+    }
+    if (flavor === 'gemini') {
+        return getGeminiModelModes();
+    }
+    if (flavor === 'openclaw') {
+        return getOpenClawModelModes();
+    }
+    return getClaudeModelModes();
+}
+
+export function getAvailableModels(
+    flavor: AgentFlavor,
+    metadata: Metadata | null | undefined,
+    translate: Translate,
+): ModelMode[] {
+    const metadataModels = mapMetadataOptions(metadata?.models);
+    if (metadataModels.length > 0) {
+        if (flavor === 'codex' && !metadataModels.some((model) => model.key === 'default')) {
+            return [{ key: 'default', name: 'default model', description: null }, ...metadataModels];
+        }
+        return metadataModels;
+    }
+    return getHardcodedModelModes(flavor, translate);
+}
+
+export function getAvailablePermissionModes(
+    flavor: AgentFlavor,
+    metadata: Metadata | null | undefined,
+    translate: Translate,
+): PermissionMode[] {
+    if (flavor === 'claude' || flavor === 'codex' || flavor === 'openclaw') {
+        return hackModes(getHardcodedPermissionModes(flavor, translate));
+    }
+
+    const metadataModes = mapMetadataOptions(metadata?.operatingModes);
+    if (metadataModes.length > 0) {
+        return hackModes(metadataModes);
+    }
+
+    return hackModes(getHardcodedPermissionModes(flavor, translate));
+}
+
+export function findOptionByKey<T extends ModeOption>(options: T[], key: string | null | undefined): T | null {
+    if (!key) {
+        return null;
+    }
+    return options.find((option) => option.key === key) ?? null;
+}
+
+export function resolveCurrentOption<T extends ModeOption>(
+    options: T[],
+    preferredKeys: Array<string | null | undefined>,
+): T | null {
+    for (const key of preferredKeys) {
+        const option = findOptionByKey(options, key);
+        if (option) {
+            return option;
+        }
+    }
+    return null;
+}
+
+export function getDefaultModelKey(flavor: AgentFlavor): string {
+    return getCodeAgentDefaults(flavor).modelMode;
+}
+
+export function getDefaultPermissionModeKey(flavor: AgentFlavor): string {
+    return getCodeAgentDefaults(flavor).permissionMode;
+}
+
+// Effort levels per agent type
+
+export function getClaudeEffortLevels(): EffortLevel[] {
+    return [
+        { key: 'low', name: 'low' },
+        { key: 'medium', name: 'medium' },
+        { key: 'high', name: 'high' },
+        { key: 'max', name: 'max' },
+    ];
+}
+
+export function getCodexEffortLevels(): EffortLevel[] {
+    return [
+        { key: 'low', name: 'low' },
+        { key: 'medium', name: 'medium' },
+        { key: 'high', name: 'high' },
+        { key: 'xhigh', name: 'xhigh' },
+    ];
+}
+
+export function getHardcodedEffortLevels(flavor: AgentFlavor): EffortLevel[] {
+    if (flavor === 'claude') return getClaudeEffortLevels();
+    if (flavor === 'codex') return getCodexEffortLevels();
+    return [];
+}
+
+export function getDefaultEffortKey(flavor: AgentFlavor): string | null {
+    return getCodeAgentDefaults(flavor).effortLevel;
+}
+
+// Per-model effort: returns effort levels for a specific model, or empty if the model has no effort
+export function getEffortLevelsForModel(flavor: AgentFlavor, _modelKey: string): EffortLevel[] {
+    // Claude and Codex expose effort/thought levels regardless of which
+    // specific model is picked — the same low/medium/high/max scale applies
+    // to the whole flavor (mirrors how Codex already worked, which the user
+    // asked Claude to match).
+    if (flavor === 'claude') {
+        return getClaudeEffortLevels();
+    }
+    if (flavor === 'codex') {
+        return getCodexEffortLevels();
+    }
+    return [];
+}
+
+// Default effort for a model — highest the model allows
+export function getDefaultEffortKeyForModel(flavor: AgentFlavor, modelKey: string): string | null {
+    const levels = getEffortLevelsForModel(flavor, modelKey);
+    if (levels.length === 0) return null;
+    return getCodeAgentDefaults(flavor).effortLevel ?? levels[levels.length - 1].key;
+}
+
+export function getSupportsWorktree(flavor: AgentFlavor): boolean {
+    if (flavor === 'openclaw') return false;
+    return true;
+}