nastech-app 1.0.0

package/sources/sync/persistence.ts

@@ -0,0 +1,322 @@
+import { MMKV } from 'react-native-mmkv';
+import { Settings, settingsDefaults, settingsParse, settingsToSyncPayload, SettingsSchema } from './settings';
+import { LocalSettings, localSettingsDefaults, localSettingsParse } from './localSettings';
+import { Purchases, purchasesDefaults, purchasesParse } from './purchases';
+import { Profile, profileDefaults, profileParse } from './profile';
+import type { PermissionModeKey } from '@/components/PermissionModeSelector';
+
+const mmkv = new MMKV();
+const NEW_SESSION_DRAFT_KEY = 'new-session-draft-v1';
+const REGISTERED_PUSH_TOKEN_KEY = 'registered-push-token-v1';
+const VOICE_SOFT_PAYWALL_SHOWN_KEY = 'voice-soft-paywall-shown';
+const VOICE_ONBOARDING_PROMPT_LOAD_COUNT_KEY = 'voice-onboarding-prompt-load-count';
+const VOICE_MESSAGE_COUNT_KEY = 'voice-message-count';
+
+export type NewSessionAgentType = 'claude' | 'codex' | 'gemini' | 'openclaw';
+export type NewSessionSessionType = 'simple' | 'worktree';
+
+export interface NewSessionDraft {
+    input: string;
+    selectedMachineId: string | null;
+    selectedPath: string | null;
+    agentType: NewSessionAgentType;
+    permissionMode: PermissionModeKey;
+    modelMode: string;
+    sessionType: NewSessionSessionType;
+    worktreeKey: string | null;
+    updatedAt: number;
+}
+
+export function loadSettings(): { settings: Settings, version: number | null } {
+    const settings = mmkv.getString('settings');
+    if (settings) {
+        try {
+            const parsed = JSON.parse(settings);
+            return { settings: settingsParse(parsed.settings), version: parsed.version };
+        } catch (e) {
+            console.error('Failed to parse settings', e);
+            return { settings: { ...settingsDefaults }, version: null };
+        }
+    }
+    return { settings: { ...settingsDefaults }, version: null };
+}
+
+export function saveSettings(settings: Settings, version: number) {
+    mmkv.set('settings', JSON.stringify({ settings: settingsToSyncPayload(settings), version }));
+}
+
+export function loadPendingSettings(): Partial<Settings> {
+    const pending = mmkv.getString('pending-settings');
+    if (pending) {
+        try {
+            const parsed = JSON.parse(pending);
+            return SettingsSchema.partial().parse(parsed);
+        } catch (e) {
+            console.error('Failed to parse pending settings', e);
+            return {};
+        }
+    }
+    return {};
+}
+
+export function savePendingSettings(settings: Partial<Settings>) {
+    mmkv.set('pending-settings', JSON.stringify(settings));
+}
+
+export function loadLocalSettings(): LocalSettings {
+    const localSettings = mmkv.getString('local-settings');
+    if (localSettings) {
+        try {
+            const parsed = JSON.parse(localSettings);
+            return localSettingsParse(parsed);
+        } catch (e) {
+            console.error('Failed to parse local settings', e);
+            return { ...localSettingsDefaults };
+        }
+    }
+    return { ...localSettingsDefaults };
+}
+
+export function saveLocalSettings(settings: LocalSettings) {
+    mmkv.set('local-settings', JSON.stringify(settings));
+}
+
+export function loadThemePreference(): 'light' | 'dark' | 'adaptive' {
+    const localSettings = mmkv.getString('local-settings');
+    if (localSettings) {
+        try {
+            const parsed = JSON.parse(localSettings);
+            const settings = localSettingsParse(parsed);
+            return settings.themePreference;
+        } catch (e) {
+            console.error('Failed to parse local settings for theme preference', e);
+            return localSettingsDefaults.themePreference;
+        }
+    }
+    return localSettingsDefaults.themePreference;
+}
+
+export function loadPurchases(): Purchases {
+    const purchases = mmkv.getString('purchases');
+    if (purchases) {
+        try {
+            const parsed = JSON.parse(purchases);
+            return purchasesParse(parsed);
+        } catch (e) {
+            console.error('Failed to parse purchases', e);
+            return { ...purchasesDefaults };
+        }
+    }
+    return { ...purchasesDefaults };
+}
+
+export function savePurchases(purchases: Purchases) {
+    mmkv.set('purchases', JSON.stringify(purchases));
+}
+
+export function loadSessionDrafts(): Record<string, string> {
+    const drafts = mmkv.getString('session-drafts');
+    if (drafts) {
+        try {
+            return JSON.parse(drafts);
+        } catch (e) {
+            console.error('Failed to parse session drafts', e);
+            return {};
+        }
+    }
+    return {};
+}
+
+export function saveSessionDrafts(drafts: Record<string, string>) {
+    mmkv.set('session-drafts', JSON.stringify(drafts));
+}
+
+export function loadNewSessionDraft(): NewSessionDraft | null {
+    const raw = mmkv.getString(NEW_SESSION_DRAFT_KEY);
+    if (!raw) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object') {
+            return null;
+        }
+
+        const input = typeof parsed.input === 'string' ? parsed.input : '';
+        const selectedMachineId = typeof parsed.selectedMachineId === 'string' ? parsed.selectedMachineId : null;
+        const selectedPath = typeof parsed.selectedPath === 'string' ? parsed.selectedPath : null;
+        const agentType: NewSessionAgentType = parsed.agentType === 'codex' || parsed.agentType === 'gemini' || parsed.agentType === 'openclaw'
+            ? parsed.agentType
+            : 'claude';
+        const permissionMode: PermissionModeKey = typeof parsed.permissionMode === 'string'
+            ? parsed.permissionMode
+            : 'default';
+        const modelMode: string = typeof parsed.modelMode === 'string' ? parsed.modelMode : 'default';
+        const sessionType: NewSessionSessionType = parsed.sessionType === 'worktree' ? 'worktree' : 'simple';
+        const worktreeKey = typeof parsed.worktreeKey === 'string' ? parsed.worktreeKey : null;
+        const updatedAt = typeof parsed.updatedAt === 'number' ? parsed.updatedAt : Date.now();
+
+        return {
+            input,
+            selectedMachineId,
+            selectedPath,
+            agentType,
+            permissionMode,
+            modelMode,
+            sessionType,
+            worktreeKey,
+            updatedAt,
+        };
+    } catch (e) {
+        console.error('Failed to parse new session draft', e);
+        return null;
+    }
+}
+
+export function saveNewSessionDraft(draft: NewSessionDraft) {
+    mmkv.set(NEW_SESSION_DRAFT_KEY, JSON.stringify(draft));
+}
+
+export function clearNewSessionDraft() {
+    mmkv.delete(NEW_SESSION_DRAFT_KEY);
+}
+
+export function loadRegisteredPushToken(): string | null {
+    return mmkv.getString(REGISTERED_PUSH_TOKEN_KEY) ?? null;
+}
+
+export function saveRegisteredPushToken(token: string) {
+    mmkv.set(REGISTERED_PUSH_TOKEN_KEY, token);
+}
+
+export function clearRegisteredPushToken() {
+    mmkv.delete(REGISTERED_PUSH_TOKEN_KEY);
+}
+
+export function loadSessionPermissionModes(): Record<string, string> {
+    const modes = mmkv.getString('session-permission-modes');
+    if (modes) {
+        try {
+            return JSON.parse(modes);
+        } catch (e) {
+            console.error('Failed to parse session permission modes', e);
+            return {};
+        }
+    }
+    return {};
+}
+
+export function saveSessionPermissionModes(modes: Record<string, string>) {
+    mmkv.set('session-permission-modes', JSON.stringify(modes));
+}
+
+export function loadSessionModelModes(): Record<string, string> {
+    const modes = mmkv.getString('session-model-modes');
+    if (modes) {
+        try {
+            return JSON.parse(modes);
+        } catch (e) {
+            console.error('Failed to parse session model modes', e);
+            return {};
+        }
+    }
+    return {};
+}
+
+export function saveSessionModelModes(modes: Record<string, string>) {
+    mmkv.set('session-model-modes', JSON.stringify(modes));
+}
+
+export function loadSessionEffortLevels(): Record<string, string> {
+    const levels = mmkv.getString('session-effort-levels');
+    if (levels) {
+        try {
+            return JSON.parse(levels);
+        } catch (e) {
+            console.error('Failed to parse session effort levels', e);
+            return {};
+        }
+    }
+    return {};
+}
+
+export function saveSessionEffortLevels(levels: Record<string, string>) {
+    mmkv.set('session-effort-levels', JSON.stringify(levels));
+}
+
+export function loadProfile(): Profile {
+    const profile = mmkv.getString('profile');
+    if (profile) {
+        try {
+            const parsed = JSON.parse(profile);
+            return profileParse(parsed);
+        } catch (e) {
+            console.error('Failed to parse profile', e);
+            return { ...profileDefaults };
+        }
+    }
+    return { ...profileDefaults };
+}
+
+export function saveProfile(profile: Profile) {
+    mmkv.set('profile', JSON.stringify(profile));
+}
+
+// Simple temporary text storage for passing large strings between screens
+export function storeTempText(content: string): string {
+    const id = `temp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    mmkv.set(`temp_text_${id}`, content);
+    return id;
+}
+
+export function retrieveTempText(id: string): string | null {
+    const content = mmkv.getString(`temp_text_${id}`);
+    if (content) {
+        // Auto-delete after retrieval
+        mmkv.delete(`temp_text_${id}`);
+        return content;
+    }
+    return null;
+}
+
+export function getVoiceSoftPaywallShownCount(): number {
+    return mmkv.getNumber(VOICE_SOFT_PAYWALL_SHOWN_KEY) ?? 0;
+}
+
+export function incrementVoiceSoftPaywallShown() {
+    mmkv.set(VOICE_SOFT_PAYWALL_SHOWN_KEY, getVoiceSoftPaywallShownCount() + 1);
+}
+
+export function getVoiceOnboardingPromptLoadCount(): number {
+    return mmkv.getNumber(VOICE_ONBOARDING_PROMPT_LOAD_COUNT_KEY) ?? 0;
+}
+
+export function incrementVoiceOnboardingPromptLoadCount() {
+    mmkv.set(VOICE_ONBOARDING_PROMPT_LOAD_COUNT_KEY, getVoiceOnboardingPromptLoadCount() + 1);
+}
+
+export function getVoiceMessageCount(): number {
+    return mmkv.getNumber(VOICE_MESSAGE_COUNT_KEY) ?? 0;
+}
+
+export function incrementVoiceMessageCount() {
+    mmkv.set(VOICE_MESSAGE_COUNT_KEY, getVoiceMessageCount() + 1);
+}
+
+export function getVoiceLocalCounters() {
+    return {
+        softPaywallShownCount: getVoiceSoftPaywallShownCount(),
+        onboardingPromptLoadCount: getVoiceOnboardingPromptLoadCount(),
+        voiceMessageCount: getVoiceMessageCount(),
+    };
+}
+
+export function resetVoiceLocalCounters() {
+    mmkv.delete(VOICE_SOFT_PAYWALL_SHOWN_KEY);
+    mmkv.delete(VOICE_ONBOARDING_PROMPT_LOAD_COUNT_KEY);
+    mmkv.delete(VOICE_MESSAGE_COUNT_KEY);
+}
+
+export function clearPersistence() {
+    mmkv.clearAll();
+}

package/sources/sync/profile.ts

@@ -0,0 +1,95 @@
+import * as z from 'zod';
+
+//
+// Schema
+//
+
+export const GitHubProfileSchema = z.object({
+    id: z.number(),
+    login: z.string(),
+    name: z.string(),
+    avatar_url: z.string(),
+    email: z.string().optional(),
+    bio: z.string().nullable()
+});
+
+export const ImageRefSchema = z.object({
+    width: z.number(),
+    height: z.number(),
+    thumbhash: z.string(),
+    path: z.string(),
+    url: z.string()
+});
+
+export const ProfileSchema = z.object({
+    id: z.string(),
+    timestamp: z.number(),
+    firstName: z.string().nullable(),
+    lastName: z.string().nullable(),
+    avatar: ImageRefSchema.nullable(),
+    github: GitHubProfileSchema.nullable(),
+    connectedServices: z.array(z.string()).default([])
+});
+
+export type GitHubProfile = z.infer<typeof GitHubProfileSchema>;
+export type ImageRef = z.infer<typeof ImageRefSchema>;
+export type Profile = z.infer<typeof ProfileSchema>;
+
+//
+// Defaults
+//
+
+export const profileDefaults: Profile = {
+    id: '',
+    timestamp: 0,
+    firstName: null,
+    lastName: null,
+    avatar: null,
+    github: null,
+    connectedServices: []
+};
+Object.freeze(profileDefaults);
+
+//
+// Parsing
+//
+
+export function profileParse(profile: unknown): Profile {
+    const parsed = ProfileSchema.safeParse(profile);
+    if (!parsed.success) {
+        console.error('Failed to parse profile:', parsed.error);
+        return { ...profileDefaults };
+    }
+    return parsed.data;
+}
+
+//
+// Utility functions
+//
+
+export function getDisplayName(profile: Profile): string | null {
+    if (profile.firstName || profile.lastName) {
+        return [profile.firstName, profile.lastName].filter(Boolean).join(' ');
+    }
+    if (profile.github?.name) {
+        return profile.github.name;
+    }
+    if (profile.github?.login) {
+        return profile.github.login;
+    }
+    return null;
+}
+
+export function getAvatarUrl(profile: Profile): string | null {
+    if (profile.avatar?.url) {
+        return profile.avatar.url;
+    }
+    if (profile.github?.avatar_url) {
+        return profile.github.avatar_url;
+    }
+    return null;
+}
+
+export function getBio(profile: Profile): string | null {
+    return profile.github?.bio || null;
+}

package/sources/sync/projectFiles.ts

@@ -0,0 +1,54 @@
+/**
+ * Project file listing via git ls-files.
+ * Fetches all tracked + untracked files and stores them in Zustand.
+ */
+
+import { sessionBash } from './ops';
+import { storage } from './storage';
+
+export interface ProjectFile {
+    fileName: string;
+    filePath: string;
+    fullPath: string;
+}
+
+export interface ProjectFilesList {
+    files: ProjectFile[];
+    fetchedAt: number;
+}
+
+/**
+ * Fetch all project files for a session via bash.
+ * Uses git ls-files (tracked + untracked), falls back to find.
+ */
+export async function getProjectFiles(sessionId: string): Promise<ProjectFilesList | null> {
+    const session = storage.getState().sessions[sessionId];
+    if (!session?.metadata?.path) {
+        return null;
+    }
+
+    const cwd = session.metadata.path;
+
+    const res = await sessionBash(sessionId, {
+        command: 'git ls-files --cached --others --exclude-standard',
+        cwd,
+        timeout: 15000,
+    });
+
+    if (!res.success || !res.stdout) {
+        return null;
+    }
+
+    const files: ProjectFile[] = res.stdout
+        .split('\n')
+        .filter(p => p.trim().length > 0)
+        .map(p => {
+            const clean = p.startsWith('./') ? p.slice(2) : p;
+            const parts = clean.split('/');
+            const fileName = parts[parts.length - 1] || clean;
+            const filePath = parts.slice(0, -1).join('/');
+            return { fileName, filePath, fullPath: clean };
+        });
+
+    return { files, fetchedAt: Date.now() };
+}

package/sources/sync/prompt/systemPrompt.ts

@@ -0,0 +1,20 @@
+import { trimIdent } from "@/utils/trimIdent";
+
+export const systemPrompt = trimIdent(`
+    # Options
+
+    You have a way to give a user a easy way to answer your questions if you know possible answers. To provide this, you need to output in your final response an XML:
+
+    <options>
+        <option>Option 1</option>
+        ...
+        <option>Option N</option>
+    </options>
+
+    You must output this in the very end of your response, not inside of any other text. Do not wrap it into a codeblock. Always dedicate "<options>" and "</options>" to a dedicated line. Never output anything like "custom", user always have an option to send a custom message. Do not enumerate options in both text and options block.
+    Always prefer to use the options mode to the text mode. Try to keep options minimal, better to clarify in a next steps.
+
+    # Plan mode with options
+
+    When you are in the plan mode, you must use the options mode to give the user a easy way to answer your questions if you know possible answers. Do not assume what is needed, when there is discrepancy between what you need and what you have, you must use the options mode.
+`);

package/sources/sync/purchases.ts

@@ -0,0 +1,67 @@
+import * as z from 'zod';
+import type { CustomerInfo } from './revenueCat/types';
+
+//
+// Schema
+//
+
+export const PurchasesSchema = z.object({
+    activeSubscriptions: z.array(z.string()).describe('Active subscription product IDs'),
+    entitlements: z.record(z.string(), z.boolean()).describe('Map of entitlement IDs to their active status'),
+});
+
+//
+// NOTE: Purchases must be a flat object for forward/backward compatibility.
+// The structure follows the same principles as settings:
+// - Simple key-value pairs
+// - No deep nesting
+// - Preserved through schema changes
+//
+
+const PurchasesSchemaPartial = PurchasesSchema.passthrough().partial();
+
+export type Purchases = z.infer<typeof PurchasesSchema>;
+
+//
+// Defaults
+//
+
+export const purchasesDefaults: Purchases = {
+    activeSubscriptions: [],
+    entitlements: {}
+};
+Object.freeze(purchasesDefaults);
+
+//
+// Resolving
+//
+
+export function purchasesParse(purchases: unknown): Purchases {
+    const parsed = PurchasesSchemaPartial.safeParse(purchases);
+    if (!parsed.success) {
+        return { ...purchasesDefaults };
+    }
+    return { ...purchasesDefaults, ...parsed.data };
+}
+
+//
+// Transform CustomerInfo to Purchases
+//
+
+export function customerInfoToPurchases(customerInfo: CustomerInfo): Purchases {
+    // Extract active subscription product IDs
+    // activeSubscriptions is a record of product ID to subscription info
+    const activeSubscriptions = Object.keys(customerInfo.activeSubscriptions || {});
+
+    // Extract entitlements (entitlement_id -> isActive)
+    const entitlements: Record<string, boolean> = {};
+    const allEntitlements = customerInfo.entitlements?.all || {};
+    Object.entries(allEntitlements).forEach(([id, entitlement]) => {
+        entitlements[id] = entitlement.isActive;
+    });
+
+    return {
+        activeSubscriptions,
+        entitlements
+    };
+}