nastech-app 1.0.0

package/sources/utils/resumeCommand.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from 'vitest';
+import { buildResumeCommand, buildResumeCommandBlock } from './resumeCommand';
+
+describe('buildResumeCommand', () => {
+    it('builds a Claude resume command that enters the session directory first', () => {
+        expect(buildResumeCommand({
+            path: '/tmp/project',
+            os: 'darwin',
+            flavor: 'claude',
+            claudeSessionId: '93a9705e-bc6a-406d-8dce-8acc014dedbd',
+        })).toBe(`cd '/tmp/project' && nastech claude --resume 93a9705e-bc6a-406d-8dce-8acc014dedbd`);
+    });
+
+    it('builds a Windows Codex resume command using PowerShell directory navigation', () => {
+        expect(buildResumeCommand({
+            path: 'C:\\Users\\test\\project',
+            os: 'win32',
+            flavor: 'codex',
+            codexThreadId: '019ccca5-726b-7c61-b914-16de27dfab6e',
+        })).toBe(`Set-Location -LiteralPath 'C:\\Users\\test\\project'; nastech codex --resume 019ccca5-726b-7c61-b914-16de27dfab6e`);
+    });
+
+    it('falls back to the bare resume command when no path is available', () => {
+        expect(buildResumeCommand({
+            flavor: 'claude',
+            claudeSessionId: '93a9705e-bc6a-406d-8dce-8acc014dedbd',
+        })).toBe('nastech claude --resume 93a9705e-bc6a-406d-8dce-8acc014dedbd');
+    });
+
+    it('returns null when there is no resumable session identifier', () => {
+        expect(buildResumeCommand({
+            path: '/tmp/project',
+            flavor: 'claude',
+        })).toBeNull();
+    });
+});
+
+describe('buildResumeCommandBlock', () => {
+    it('builds copyable two-line CLI instructions when a path is available', () => {
+        expect(buildResumeCommandBlock({
+            path: '/tmp/project',
+            os: 'darwin',
+            flavor: 'claude',
+            claudeSessionId: '93a9705e-bc6a-406d-8dce-8acc014dedbd',
+        })).toEqual({
+            lines: [
+                `cd '/tmp/project'`,
+                'nastech claude --resume 93a9705e-bc6a-406d-8dce-8acc014dedbd',
+            ],
+            copyText: `cd '/tmp/project'\nnastech claude --resume 93a9705e-bc6a-406d-8dce-8acc014dedbd`,
+        });
+    });
+
+    it('falls back to a single-line command block when no path is available', () => {
+        expect(buildResumeCommandBlock({
+            flavor: 'claude',
+            claudeSessionId: '93a9705e-bc6a-406d-8dce-8acc014dedbd',
+        })).toEqual({
+            lines: ['nastech claude --resume 93a9705e-bc6a-406d-8dce-8acc014dedbd'],
+            copyText: 'nastech claude --resume 93a9705e-bc6a-406d-8dce-8acc014dedbd',
+        });
+    });
+
+    it('builds copyable two-line Windows instructions using PowerShell directory navigation', () => {
+        expect(buildResumeCommandBlock({
+            path: 'C:\\Users\\test\\project',
+            os: 'win32',
+            flavor: 'claude',
+            claudeSessionId: '93a9705e-bc6a-406d-8dce-8acc014dedbd',
+        })).toEqual({
+            lines: [
+                `Set-Location -LiteralPath 'C:\\Users\\test\\project'`,
+                'nastech claude --resume 93a9705e-bc6a-406d-8dce-8acc014dedbd',
+            ],
+            copyText: `Set-Location -LiteralPath 'C:\\Users\\test\\project'\nnastech claude --resume 93a9705e-bc6a-406d-8dce-8acc014dedbd`,
+        });
+    });
+});

package/sources/utils/resumeCommand.ts

@@ -0,0 +1,70 @@
+export type ResumeCommandMetadata = {
+    path?: string | null;
+    os?: string | null;
+    flavor?: string | null;
+    claudeSessionId?: string | null;
+    codexThreadId?: string | null;
+};
+
+export type ResumeCommandBlock = {
+    lines: string[];
+    copyText: string;
+};
+
+function quotePosixPath(path: string): string {
+    return `'${path.replace(/'/g, `'\\''`)}'`;
+}
+
+function quotePowerShellPath(path: string): string {
+    return `'${path.replace(/'/g, `''`)}'`;
+}
+
+function isWindows(metadata: ResumeCommandMetadata): boolean {
+    return metadata.os?.toLowerCase() === 'win32';
+}
+
+function buildResumeInvocation(metadata: ResumeCommandMetadata): string | null {
+    if ((metadata.flavor === 'codex' || metadata.flavor === 'openai' || metadata.flavor === 'gpt') && metadata.codexThreadId) {
+        return `nastech codex --resume ${metadata.codexThreadId}`;
+    }
+    if (metadata.claudeSessionId) {
+        return `nastech claude --resume ${metadata.claudeSessionId}`;
+    }
+    return null;
+}
+
+function buildChangeDirectoryCommand(metadata: ResumeCommandMetadata): string | null {
+    const path = metadata.path?.trim();
+    if (!path) {
+        return null;
+    }
+
+    return isWindows(metadata)
+        ? `Set-Location -LiteralPath ${quotePowerShellPath(path)}`
+        : `cd ${quotePosixPath(path)}`;
+}
+
+export function buildResumeCommandBlock(metadata: ResumeCommandMetadata): ResumeCommandBlock | null {
+    const invocation = buildResumeInvocation(metadata);
+    if (!invocation) {
+        return null;
+    }
+
+    const changeDirectoryCommand = buildChangeDirectoryCommand(metadata);
+    const lines = changeDirectoryCommand
+        ? [changeDirectoryCommand, invocation]
+        : [invocation];
+
+    return {
+        lines,
+        copyText: lines.join('\n'),
+    };
+}
+
+export function buildResumeCommand(metadata: ResumeCommandMetadata): string | null {
+    const commandBlock = buildResumeCommandBlock(metadata);
+    if (!commandBlock) {
+        return null;
+    }
+    return commandBlock.lines.join(isWindows(metadata) ? '; ' : ' && ');
+}

package/sources/utils/sessionFileLinks.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it } from 'vitest';
+import { parseSessionFileLink, resolveSessionFilePath, splitSessionFileText } from './sessionFileLinks';
+
+describe('sessionFileLinks', () => {
+    const sessionRoot = '/Users/kirilldubovitskiy/projects/nastech';
+
+    it('parses absolute file refs with line numbers', () => {
+        const result = parseSessionFileLink('/Users/kirilldubovitskiy/projects/nastech/packages/nastech-cli/src/codex/runCodex.ts:594', {
+            sessionRoot,
+        });
+
+        expect(result).toEqual({
+            path: '/Users/kirilldubovitskiy/projects/nastech/packages/nastech-cli/src/codex/runCodex.ts',
+            absolutePath: '/Users/kirilldubovitskiy/projects/nastech/packages/nastech-cli/src/codex/runCodex.ts',
+            relativePath: 'packages/nastech-cli/src/codex/runCodex.ts',
+            withinSessionRoot: true,
+            line: 594,
+            column: null,
+        });
+    });
+
+    it('parses relative file refs with line and column numbers', () => {
+        const result = parseSessionFileLink('packages/nastech-cli/src/codex/runCodex.ts:594:2', {
+            sessionRoot,
+        });
+
+        expect(result).toEqual({
+            path: 'packages/nastech-cli/src/codex/runCodex.ts',
+            absolutePath: '/Users/kirilldubovitskiy/projects/nastech/packages/nastech-cli/src/codex/runCodex.ts',
+            relativePath: 'packages/nastech-cli/src/codex/runCodex.ts',
+            withinSessionRoot: true,
+            line: 594,
+            column: 2,
+        });
+    });
+
+    it('rejects external urls', () => {
+        expect(parseSessionFileLink('https://openai.com', { sessionRoot })).toBeNull();
+        expect(parseSessionFileLink('mailto:test@example.com', { sessionRoot })).toBeNull();
+    });
+
+    it('splits bare text into plain and linked segments', () => {
+        const result = splitSessionFileText('Open packages/nastech-cli/src/codex/runCodex.ts:594 please.', sessionRoot);
+
+        expect(result).toEqual([
+            { text: 'Open ', link: null },
+            {
+                text: 'packages/nastech-cli/src/codex/runCodex.ts:594',
+                link: {
+                    path: 'packages/nastech-cli/src/codex/runCodex.ts',
+                    absolutePath: '/Users/kirilldubovitskiy/projects/nastech/packages/nastech-cli/src/codex/runCodex.ts',
+                    relativePath: 'packages/nastech-cli/src/codex/runCodex.ts',
+                    withinSessionRoot: true,
+                    line: 594,
+                    column: null,
+                },
+            },
+            { text: ' please.', link: null },
+        ]);
+    });
+
+    it('splits absolute bare file refs with spaces into linked segments', () => {
+        const result = splitSessionFileText(
+            'Image: /Users/kirilldubovitskiy/Library/Application Support/CleanShot/media/test/CleanShot 2026-03-19 at 00.54.37@2x.png',
+            sessionRoot,
+        );
+
+        expect(result).toEqual([
+            { text: 'Image: ', link: null },
+            {
+                text: '/Users/kirilldubovitskiy/Library/Application Support/CleanShot/media/test/CleanShot 2026-03-19 at 00.54.37@2x.png',
+                link: {
+                    path: '/Users/kirilldubovitskiy/Library/Application Support/CleanShot/media/test/CleanShot 2026-03-19 at 00.54.37@2x.png',
+                    absolutePath: '/Users/kirilldubovitskiy/Library/Application Support/CleanShot/media/test/CleanShot 2026-03-19 at 00.54.37@2x.png',
+                    relativePath: null,
+                    withinSessionRoot: false,
+                    line: null,
+                    column: null,
+                },
+            },
+        ]);
+    });
+
+    it('does not turn version numbers into file refs', () => {
+        expect(splitSessionFileText('Version 1.2.3 shipped.', sessionRoot)).toEqual([
+            { text: 'Version 1.2.3 shipped.', link: null },
+        ]);
+    });
+
+    it('does not turn slash-separated prose into file refs', () => {
+        expect(splitSessionFileText(
+            'Codex then starts/resumes turns with backend default model. I’m checking CLI docs/tests to confirm there is intentionally no nastech codex model set or --model surface today.',
+            sessionRoot,
+        )).toEqual([
+            {
+                text: 'Codex then starts/resumes turns with backend default model. I’m checking CLI docs/tests to confirm there is intentionally no nastech codex model set or --model surface today.',
+                link: null,
+            },
+        ]);
+    });
+
+    it('resolves viewer input to an absolute path', () => {
+        expect(resolveSessionFilePath('packages/nastech-app/README.md', sessionRoot)).toEqual({
+            path: 'packages/nastech-app/README.md',
+            absolutePath: '/Users/kirilldubovitskiy/projects/nastech/packages/nastech-app/README.md',
+            relativePath: 'packages/nastech-app/README.md',
+            withinSessionRoot: true,
+            line: null,
+            column: null,
+        });
+    });
+});

package/sources/utils/sessionFileLinks.ts

@@ -0,0 +1,388 @@
+export type SessionFileLink = {
+    path: string;
+    absolutePath: string;
+    relativePath: string | null;
+    withinSessionRoot: boolean;
+    line: number | null;
+    column: number | null;
+};
+
+export type SessionFileTextSegment = {
+    text: string;
+    link: SessionFileLink | null;
+};
+
+const WINDOWS_ABSOLUTE_PATH = /^[A-Za-z]:[\\/]/;
+const POSIX_ABSOLUTE_PATH = /^\//;
+const URL_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*:/;
+const FILE_URL_PREFIX = /^file:\/\//i;
+const RELATIVE_PREFIX = /^(?:\.{1,2}[\\/]|~[\\/])/;
+const HAS_PATH_SEPARATOR = /[\\/]/;
+const BARE_FILE_NAME = /^[^\\/\s]+\.[^\\/\s]+$/;
+const NUMERIC_EXTENSION = /^\d+$/;
+const FILE_EXTENSION = /^[A-Za-z0-9_-]{1,16}$/;
+const EXTENSIONLESS_FILE_NAMES = new Set([
+    'README',
+    'LICENSE',
+    'Makefile',
+    'Dockerfile',
+    '.gitignore',
+    '.gitattributes',
+    '.env',
+    '.npmrc',
+    '.yarnrc',
+]);
+const LEADING_WRAP = /^[([{<"'`]+/;
+const TRAILING_WRAP = /[)\]}>",;!?`]+$/;
+const APP_ROUTE_PREFIXES = ['/session/', '/text-selection', '/settings', '/auth'];
+
+function parseLineAndColumn(value: string): { path: string; line: number | null; column: number | null } {
+    const trimmed = value.trim();
+    const lineColumnMatch = trimmed.match(/^(.*):(\d+):(\d+)$/);
+    if (lineColumnMatch) {
+        return {
+            path: lineColumnMatch[1],
+            line: Number.parseInt(lineColumnMatch[2], 10),
+            column: Number.parseInt(lineColumnMatch[3], 10),
+        };
+    }
+
+    const lineMatch = trimmed.match(/^(.*):(\d+)$/);
+    if (!lineMatch) {
+        return {
+            path: trimmed,
+            line: null,
+            column: null,
+        };
+    }
+
+    return {
+        path: lineMatch[1],
+        line: Number.parseInt(lineMatch[2], 10),
+        column: null,
+    };
+}
+
+function pushTextSegment(segments: SessionFileTextSegment[], text: string) {
+    if (!text) {
+        return;
+    }
+    const last = segments[segments.length - 1];
+    if (last && last.link === null) {
+        last.text += text;
+        return;
+    }
+    segments.push({ text, link: null });
+}
+
+function stripToken(value: string): { leading: string; core: string; trailing: string } {
+    const leading = value.match(LEADING_WRAP)?.[0] ?? '';
+    const withoutLeading = leading ? value.slice(leading.length) : value;
+    const trailing = withoutLeading.match(TRAILING_WRAP)?.[0] ?? '';
+    const core = trailing ? withoutLeading.slice(0, withoutLeading.length - trailing.length) : withoutLeading;
+    return { leading, core, trailing };
+}
+
+function decodeFileUrl(value: string): string {
+    if (!FILE_URL_PREFIX.test(value)) {
+        return value;
+    }
+    const stripped = value.replace(FILE_URL_PREFIX, '');
+    const normalized = stripped.startsWith('/') ? stripped : `/${stripped}`;
+    try {
+        return decodeURIComponent(normalized);
+    } catch {
+        return normalized;
+    }
+}
+
+function inferHomeDirectory(sessionRoot: string | null | undefined): string | null {
+    if (!sessionRoot) {
+        return null;
+    }
+    const normalizedRoot = normalizePath(sessionRoot);
+    const match = normalizedRoot.match(/^([A-Za-z]:\/Users\/[^/]+|\/Users\/[^/]+|\/home\/[^/]+)/);
+    return match?.[1] ?? null;
+}
+
+function expandHomePath(value: string, sessionRoot: string | null | undefined): string {
+    if (!value.startsWith('~/')) {
+        return value;
+    }
+    const home = inferHomeDirectory(sessionRoot);
+    if (!home) {
+        return value;
+    }
+    return `${home}/${value.slice(2)}`;
+}
+
+function normalizePath(value: string): string {
+    const withForwardSlashes = value.replace(/\\/g, '/');
+    const isWindowsAbsolute = /^[A-Za-z]:\//.test(withForwardSlashes);
+    const isPosixAbsolute = withForwardSlashes.startsWith('/');
+    const prefix = isWindowsAbsolute ? `${withForwardSlashes.slice(0, 2)}/` : isPosixAbsolute ? '/' : '';
+    const rawRemainder = isWindowsAbsolute ? withForwardSlashes.slice(3) : isPosixAbsolute ? withForwardSlashes.replace(/^\/+/, '') : withForwardSlashes;
+
+    const parts = rawRemainder.split('/');
+    const normalizedParts: string[] = [];
+
+    for (const part of parts) {
+        if (!part || part === '.') {
+            continue;
+        }
+        if (part === '..') {
+            if (normalizedParts.length > 0 && normalizedParts[normalizedParts.length - 1] !== '..') {
+                normalizedParts.pop();
+            } else if (!prefix) {
+                normalizedParts.push(part);
+            }
+            continue;
+        }
+        normalizedParts.push(part);
+    }
+
+    if (!prefix) {
+        return normalizedParts.join('/');
+    }
+    if (normalizedParts.length === 0) {
+        return prefix;
+    }
+    return `${prefix}${normalizedParts.join('/')}`;
+}
+
+function resolvePath(path: string, sessionRoot: string | null | undefined): string | null {
+    const expandedPath = expandHomePath(decodeFileUrl(path), sessionRoot);
+    if (!expandedPath) {
+        return null;
+    }
+    if (WINDOWS_ABSOLUTE_PATH.test(expandedPath) || POSIX_ABSOLUTE_PATH.test(expandedPath)) {
+        return normalizePath(expandedPath);
+    }
+    if (!sessionRoot) {
+        return null;
+    }
+    return normalizePath(`${normalizePath(sessionRoot)}/${expandedPath}`);
+}
+
+function isWithinRoot(path: string, root: string | null | undefined): boolean {
+    if (!root) {
+        return false;
+    }
+    const normalizedPath = normalizePath(path);
+    const normalizedRoot = normalizePath(root);
+    return normalizedPath === normalizedRoot || normalizedPath.startsWith(`${normalizedRoot}/`);
+}
+
+function getRelativePath(path: string, root: string | null | undefined): string | null {
+    if (!isWithinRoot(path, root) || !root) {
+        return null;
+    }
+    const normalizedPath = normalizePath(path);
+    const normalizedRoot = normalizePath(root);
+    if (normalizedPath === normalizedRoot) {
+        return '.';
+    }
+    return normalizedPath.slice(normalizedRoot.length + 1);
+}
+
+function looksLikeBareFileName(value: string): boolean {
+    if (!BARE_FILE_NAME.test(value)) {
+        return false;
+    }
+    const extension = value.split('.').pop() ?? '';
+    return !NUMERIC_EXTENSION.test(extension);
+}
+
+function hasFileLikeEnding(value: string): boolean {
+    const normalized = normalizePath(value);
+    const basename = normalized.split('/').pop() ?? normalized;
+    if (!basename) {
+        return false;
+    }
+    if (EXTENSIONLESS_FILE_NAMES.has(basename)) {
+        return true;
+    }
+    if (basename.startsWith('.')) {
+        return basename.length > 1;
+    }
+    const lastDotIndex = basename.lastIndexOf('.');
+    if (lastDotIndex <= 0 || lastDotIndex === basename.length - 1) {
+        return false;
+    }
+    const extension = basename.slice(lastDotIndex + 1);
+    if (!FILE_EXTENSION.test(extension)) {
+        return false;
+    }
+    return !NUMERIC_EXTENSION.test(extension);
+}
+
+function isAppRoute(value: string): boolean {
+    return APP_ROUTE_PREFIXES.some((prefix) => value.startsWith(prefix));
+}
+
+function looksLikePath(value: string): boolean {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return false;
+    }
+    if (WINDOWS_ABSOLUTE_PATH.test(trimmed)) {
+        return true;
+    }
+    if (POSIX_ABSOLUTE_PATH.test(trimmed)) {
+        return !isAppRoute(trimmed);
+    }
+    if (RELATIVE_PREFIX.test(trimmed)) {
+        return true;
+    }
+    if (HAS_PATH_SEPARATOR.test(trimmed)) {
+        return true;
+    }
+    return looksLikeBareFileName(trimmed);
+}
+
+function buildLink(path: string, line: number | null, column: number | null, sessionRoot: string | null | undefined): SessionFileLink | null {
+    const absolutePath = resolvePath(path, sessionRoot);
+    if (!absolutePath) {
+        return null;
+    }
+    return {
+        path: normalizePath(path),
+        absolutePath,
+        relativePath: getRelativePath(absolutePath, sessionRoot),
+        withinSessionRoot: isWithinRoot(absolutePath, sessionRoot),
+        line,
+        column,
+    };
+}
+
+export function resolveSessionFilePath(path: string, sessionRoot?: string | null): SessionFileLink | null {
+    const parsed = parseLineAndColumn(path);
+    return buildLink(parsed.path, parsed.line, parsed.column, sessionRoot);
+}
+
+export function parseSessionFileLink(
+    url: string,
+    options?: { label?: string | null; sessionRoot?: string | null; bareText?: boolean }
+): SessionFileLink | null {
+    const trimmedUrl = url.trim();
+    if (!trimmedUrl) {
+        return null;
+    }
+
+    if (!WINDOWS_ABSOLUTE_PATH.test(trimmedUrl) && URL_SCHEME.test(trimmedUrl)) {
+        return null;
+    }
+
+    const parsedUrl = parseLineAndColumn(trimmedUrl);
+    const parsedLabel = options?.label ? parseLineAndColumn(options.label) : null;
+
+    if (!looksLikePath(parsedUrl.path) && !looksLikePath(parsedLabel?.path ?? '')) {
+        return null;
+    }
+
+    if (options?.bareText) {
+        const hasStrongSignal =
+            parsedUrl.line !== null ||
+            parsedUrl.column !== null ||
+            hasFileLikeEnding(parsedUrl.path);
+        if (!hasStrongSignal) {
+            return null;
+        }
+    }
+
+    return buildLink(
+        parsedUrl.path,
+        parsedUrl.line ?? parsedLabel?.line ?? null,
+        parsedUrl.column ?? parsedLabel?.column ?? null,
+        options?.sessionRoot,
+    );
+}
+
+type TokenMatch = {
+    start: number;
+    end: number;
+};
+
+function looksLikePathStart(text: string): boolean {
+    if (!text) {
+        return false;
+    }
+    if (WINDOWS_ABSOLUTE_PATH.test(text)) {
+        return true;
+    }
+    if (text.startsWith('/') || text.startsWith('~/') || text.startsWith('./') || text.startsWith('../')) {
+        return true;
+    }
+    return HAS_PATH_SEPARATOR.test(text);
+}
+
+export function splitSessionFileText(text: string, sessionRoot?: string | null): SessionFileTextSegment[] {
+    const segments: SessionFileTextSegment[] = [];
+    const tokenPattern = /\S+/g;
+    const tokens: TokenMatch[] = [];
+    let match: RegExpExecArray | null;
+
+    while ((match = tokenPattern.exec(text)) !== null) {
+        tokens.push({ start: match.index, end: match.index + match[0].length });
+    }
+
+    let cursor = 0;
+    let tokenIndex = 0;
+
+    while (tokenIndex < tokens.length) {
+        const token = tokens[tokenIndex];
+        const tokenText = text.slice(token.start, token.end);
+        const strippedStart = stripToken(tokenText).core;
+
+        if (!looksLikePathStart(strippedStart)) {
+            tokenIndex += 1;
+            continue;
+        }
+
+        let bestEnd = -1;
+        let bestLink: SessionFileLink | null = null;
+        let bestLeading = '';
+        let bestCore = '';
+        let bestTrailing = '';
+
+        for (let candidateIndex = tokenIndex; candidateIndex < tokens.length; candidateIndex += 1) {
+            const candidate = text.slice(token.start, tokens[candidateIndex].end);
+            const stripped = stripToken(candidate);
+            if (!stripped.core) {
+                continue;
+            }
+
+            const link = parseSessionFileLink(stripped.core, {
+                sessionRoot,
+                bareText: true,
+            });
+
+            if (link) {
+                bestEnd = candidateIndex;
+                bestLink = link;
+                bestLeading = stripped.leading;
+                bestCore = stripped.core;
+                bestTrailing = stripped.trailing;
+            }
+        }
+
+        if (bestEnd === -1 || !bestLink) {
+            tokenIndex += 1;
+            continue;
+        }
+
+        const end = tokens[bestEnd].end;
+        pushTextSegment(segments, text.slice(cursor, token.start));
+        pushTextSegment(segments, bestLeading);
+        segments.push({ text: bestCore, link: bestLink });
+        pushTextSegment(segments, bestTrailing);
+        cursor = end;
+        tokenIndex = bestEnd + 1;
+    }
+
+    if (cursor < text.length) {
+        pushTextSegment(segments, text.slice(cursor));
+    }
+
+    return segments;
+}