vibe-coding-master 0.0.8 → 0.0.10

package/dist/backend/services/message-service.js

@@ -3,6 +3,7 @@ import { randomUUID } from "node:crypto";
 import { ROLE_NAMES } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
+import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { renderManualStagePrompt, renderMessageEnvelope } from "../templates/message-envelope.js";
 const PM_ROLE = "project-manager";
 const PM_TO_ROLE_TYPES = new Set(["task", "question", "review-request", "revise", "cancel"]);
@@ -12,7 +13,7 @@ export function createMessageService(deps) {
     const id = deps.id ?? (() => `msg_${randomUUID()}`);
     return {
         listMessages(input) {
-            return readLatestMessages(deps.fs, getMessagesPath(input.repoRoot, input.stateRoot, input.taskSlug));
+            return readLatestMessages(deps.fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
         },
         async sendMessage(input) {
             await deps.taskService.loadTask(input.repoRoot, input.taskSlug);
@@ -56,7 +57,7 @@ export function createMessageService(deps) {
                 deliveredAt: timestamp,
                 failureReason: undefined
             };
-            deps.runtime.write(session.id, `${renderMessageEnvelope(delivered)}\r`);
+            await submitTerminalInput(deps.runtime, session.id, renderMessageEnvelope(delivered));
             await appendMessageSnapshot(deps.fs, input, delivered);
             return { message: delivered, delivered: true, requiresUserApproval: false };
         },
@@ -95,7 +96,7 @@ export function createMessageService(deps) {
             return rejected;
         },
         async getOrchestrationState(input) {
-            const statePath = getOrchestrationStatePath(input.repoRoot, input.stateRoot, input.taskSlug);
+            const statePath = getOrchestrationStatePath(getStateRepoRoot(input), input.stateRoot, input.taskSlug);
             if (!(await deps.fs.pathExists(statePath))) {
                 return {
                     taskSlug: input.taskSlug,
@@ -114,7 +115,7 @@ export function createMessageService(deps) {
                 paused: input.paused ?? current.paused,
                 updatedAt: now()
             };
-            await deps.fs.writeJsonAtomic(getOrchestrationStatePath(input.repoRoot, input.stateRoot, input.taskSlug), next);
+            await deps.fs.writeJsonAtomic(getOrchestrationStatePath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), next);
             return next;
         }
     };
@@ -183,7 +184,7 @@ ${artifactRefs}
 `;
 }
 async function getMessageOrThrow(fs, input) {
-    const messages = await readLatestMessages(fs, getMessagesPath(input.repoRoot, input.stateRoot, input.taskSlug));
+    const messages = await readLatestMessages(fs, getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug));
     const message = messages.find((candidate) => candidate.id === input.messageId);
     if (!message) {
         throw new VcmError({
@@ -207,7 +208,7 @@ async function readLatestMessages(fs, messagesPath) {
     return [...latest.values()].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
 }
 async function appendMessageSnapshot(fs, input, message) {
-    await fs.appendText(getMessagesPath(input.repoRoot, input.stateRoot, input.taskSlug), `${JSON.stringify(message)}\n`);
+    await fs.appendText(getMessagesPath(getStateRepoRoot(input), input.stateRoot, input.taskSlug), `${JSON.stringify(message)}\n`);
 }
 function getMessagesPath(repoRoot, stateRoot, taskSlug) {
     return path.join(repoRoot, stateRoot, "messages", `${taskSlug}.jsonl`);
@@ -215,3 +216,6 @@ function getMessagesPath(repoRoot, stateRoot, taskSlug) {
 function getOrchestrationStatePath(repoRoot, stateRoot, taskSlug) {
     return path.join(repoRoot, stateRoot, "orchestration", `${taskSlug}.json`);
 }
+function getStateRepoRoot(input) {
+    return input.stateRepoRoot ?? input.repoRoot;
+}

package/dist/backend/services/project-service.js

@@ -3,20 +3,8 @@ import { ROLE_NAMES } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 const DEFAULT_HANDOFF_ROOT = ".ai/handoffs";
 const DEFAULT_STATE_ROOT = ".ai/vcm";
-const LEGACY_STATE_ROOT = ".vcm";
 export function createProjectService(deps) {
     let currentProject = null;
-    async function migrateLegacyStateRoot(repoRoot) {
-        if (!deps.fs.copyDir) {
-            return;
-        }
-        const legacyStateRoot = path.join(repoRoot, LEGACY_STATE_ROOT);
-        const currentStateRoot = path.join(repoRoot, DEFAULT_STATE_ROOT);
-        if (!(await deps.fs.pathExists(legacyStateRoot)) || await deps.fs.pathExists(currentStateRoot)) {
-            return;
-        }
-        await deps.fs.copyDir(legacyStateRoot, currentStateRoot);
-    }
     return {
         async connectProject(input) {
             const requestedPath = input.repoPath.trim();
@@ -43,9 +31,6 @@ export function createProjectService(deps) {
             const config = await this.loadConfig(repoRoot);
             await deps.fs.ensureDir(path.join(repoRoot, config.handoffRoot));
             await deps.fs.ensureDir(path.join(repoRoot, config.stateRoot, "tasks"));
-            await deps.fs.ensureDir(path.join(repoRoot, config.stateRoot, "sessions"));
-            await deps.fs.ensureDir(path.join(repoRoot, config.stateRoot, "messages"));
-            await deps.fs.ensureDir(path.join(repoRoot, config.stateRoot, "orchestration"));
             await deps.fs.ensureDir(path.join(repoRoot, config.stateRoot, "worktrees"));
             await this.saveConfig(config, true);
             const warnings = [];
@@ -86,16 +71,9 @@ export function createProjectService(deps) {
             return deps.appSettings.getRecentRepositoryPaths();
         },
         async loadConfig(repoRoot) {
-            const configPath = this.getConfigPath(repoRoot);
-            if (await deps.fs.pathExists(configPath)) {
-                return normalizeProjectConfig(await deps.fs.readJson(configPath), repoRoot);
-            }
-            const legacyConfigPath = path.join(repoRoot, LEGACY_STATE_ROOT, "config.json");
-            if (await deps.fs.pathExists(legacyConfigPath)) {
-                const migratedConfig = normalizeProjectConfig(await deps.fs.readJson(legacyConfigPath), repoRoot);
-                await migrateLegacyStateRoot(repoRoot);
-                await this.saveConfig(migratedConfig, true);
-                return migratedConfig;
+            const appConfig = await deps.appSettings.loadProjectConfig(repoRoot);
+            if (appConfig) {
+                return normalizeProjectConfig(appConfig, repoRoot);
             }
             return buildDefaultProjectConfig(repoRoot);
         },
@@ -105,10 +83,10 @@ export function createProjectService(deps) {
             if (!force && await deps.fs.pathExists(configPath)) {
                 return;
             }
-            await deps.fs.writeJsonAtomic(configPath, normalizedConfig);
+            await deps.appSettings.saveProjectConfig(normalizedConfig);
         },
         getConfigPath(repoRoot) {
-            return path.join(repoRoot, DEFAULT_STATE_ROOT, "config.json");
+            return deps.appSettings.getProjectConfigPath(repoRoot);
         }
     };
 }

package/dist/backend/services/session-service.js

@@ -16,7 +16,7 @@ export function createSessionService(deps) {
         const task = await deps.taskService.loadTask(repoRoot, taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         const paths = deps.artifactService.getHandoffPaths(taskRepoRoot, task.handoffDir);
-        const persisted = await loadPersistedRoleRecord(deps.fs, repoRoot, config.stateRoot, taskSlug, role);
+        const persisted = await loadPersistedRoleRecord(deps.fs, taskRepoRoot, config.stateRoot, taskSlug, role);
         const permissionMode = input.permissionMode ?? persisted?.permissionMode ?? "default";
         const claudeSessionId = launchMode === "resume"
             ? persisted?.claudeSessionId
@@ -73,7 +73,7 @@ export function createSessionService(deps) {
             exitCode: runtimeSession.exitCode
         };
         deps.registry.upsert(record);
-        await persistTaskSession(deps.fs, repoRoot, config.stateRoot, record);
+        await persistTaskSession(deps.fs, taskRepoRoot, config.stateRoot, record);
         await deps.taskService.updateTaskStatus(repoRoot, taskSlug, "running");
         return record;
     }
@@ -103,7 +103,8 @@ export function createSessionService(deps) {
             };
             deps.registry.upsert(updated);
             const config = await deps.projectService.loadConfig(repoRoot);
-            await persistTaskSession(deps.fs, repoRoot, config.stateRoot, updated);
+            const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+            await persistTaskSession(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
             return updated;
         },
         async restartRoleSession(repoRoot, taskSlug, role, input = {}) {
@@ -119,8 +120,10 @@ export function createSessionService(deps) {
         },
         async getRoleSession(repoRoot, taskSlug, role) {
             const config = await deps.projectService.loadConfig(repoRoot);
+            const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+            const taskRepoRoot = getTaskRuntimeRepoRoot(task);
             const record = deps.registry.getByRole(taskSlug, role)
-                ?? await loadPersistedRoleRecord(deps.fs, repoRoot, config.stateRoot, taskSlug, role);
+                ?? await loadPersistedRoleRecord(deps.fs, taskRepoRoot, config.stateRoot, taskSlug, role);
             if (!record) {
                 return undefined;
             }

package/dist/backend/services/task-service.js

@@ -8,8 +8,13 @@ export function createTaskService(deps) {
             assertValidTaskSlug(input.taskSlug);
             const config = await deps.projectService.loadConfig(repoRoot);
             const taskPath = getTaskPath(repoRoot, config.stateRoot, input.taskSlug);
-            const branch = `feature/${input.taskSlug}`;
-            const worktreePath = getTaskWorktreePath(repoRoot, config.stateRoot, input.taskSlug);
+            const shouldCreateWorktree = input.createWorktree !== false;
+            const taskBranch = shouldCreateWorktree
+                ? `feature/${input.taskSlug}`
+                : await deps.git.getCurrentBranch(repoRoot);
+            const worktreePath = shouldCreateWorktree
+                ? getTaskWorktreePath(repoRoot, config.stateRoot, input.taskSlug)
+                : undefined;
             if (await deps.fs.pathExists(taskPath)) {
                 throw new VcmError({
                     code: "TASK_EXISTS",
@@ -17,23 +22,7 @@ export function createTaskService(deps) {
                     statusCode: 409
                 });
             }
-            if (await deps.git.branchExists(repoRoot, branch)) {
-                throw new VcmError({
-                    code: "TASK_BRANCH_EXISTS",
-                    message: `Task branch already exists: ${branch}`,
-                    statusCode: 409,
-                    hint: "Choose a different task name or clean up the existing branch."
-                });
-            }
-            if (await deps.fs.pathExists(worktreePath)) {
-                throw new VcmError({
-                    code: "TASK_WORKTREE_EXISTS",
-                    message: `Task worktree already exists: ${worktreePath}`,
-                    statusCode: 409,
-                    hint: "Choose a different task name or clean up the existing worktree."
-                });
-            }
-            if (!(await deps.git.isIgnored(repoRoot, `${config.stateRoot}/config.json`))) {
+            if (!(await deps.git.isIgnored(repoRoot, `${config.stateRoot}/tasks/.probe`))) {
                 throw new VcmError({
                     code: "VCM_STATE_NOT_IGNORED",
                     message: `${config.stateRoot}/ is not ignored by Git.`,
@@ -41,23 +30,42 @@ export function createTaskService(deps) {
                     hint: "Apply VCM Harness first so .gitignore contains the VCM managed block."
                 });
             }
-            const baseStatus = await deps.git.getStatusPorcelain(repoRoot);
-            if (baseStatus.trim()) {
-                throw new VcmError({
-                    code: "BASE_REPO_DIRTY",
-                    message: "The connected repository has uncommitted changes.",
-                    statusCode: 409,
-                    hint: "Commit, stash, or discard base repository changes before creating a task worktree."
+            if (shouldCreateWorktree && worktreePath) {
+                if (await deps.git.branchExists(repoRoot, taskBranch)) {
+                    throw new VcmError({
+                        code: "TASK_BRANCH_EXISTS",
+                        message: `Task branch already exists: ${taskBranch}`,
+                        statusCode: 409,
+                        hint: "Choose a different task name or clean up the existing branch."
+                    });
+                }
+                if (await deps.fs.pathExists(worktreePath)) {
+                    throw new VcmError({
+                        code: "TASK_WORKTREE_EXISTS",
+                        message: `Task worktree already exists: ${worktreePath}`,
+                        statusCode: 409,
+                        hint: "Choose a different task name or clean up the existing worktree."
+                    });
+                }
+                const baseStatus = await deps.git.getStatusPorcelain(repoRoot);
+                if (baseStatus.trim()) {
+                    throw new VcmError({
+                        code: "BASE_REPO_DIRTY",
+                        message: "The connected repository has uncommitted changes.",
+                        statusCode: 409,
+                        hint: "Commit, stash, or discard base repository changes before creating a task worktree."
+                    });
+                }
+                await deps.fs.ensureDir(path.dirname(worktreePath));
+                await deps.git.createWorktree({
+                    repoRoot,
+                    branch: taskBranch,
+                    worktreePath,
+                    baseRef: "HEAD"
                 });
             }
-            await deps.fs.ensureDir(path.dirname(worktreePath));
-            await deps.git.createWorktree({
-                repoRoot,
-                branch,
-                worktreePath,
-                baseRef: "HEAD"
-            });
             const timestamp = now();
+            const taskRepoRoot = worktreePath ?? repoRoot;
             const task = {
                 version: 1,
                 taskSlug: input.taskSlug,
@@ -66,19 +74,20 @@ export function createTaskService(deps) {
                 updatedAt: timestamp,
                 repoRoot,
                 worktreePath,
-                branch,
+                branch: taskBranch,
                 handoffDir: path.posix.join(config.handoffRoot, input.taskSlug),
                 status: "created",
                 specPath: input.specPath,
                 cleanupStatus: "active"
             };
+            await ensureTaskRuntimeStateDirs(deps.fs, taskRepoRoot, config.stateRoot);
             await deps.artifactService.ensureHandoffStructure({
-                repoRoot: worktreePath,
+                repoRoot: taskRepoRoot,
                 taskSlug: input.taskSlug,
                 handoffDir: task.handoffDir
             });
             await deps.artifactService.createArtifactTemplates({
-                repoRoot: worktreePath,
+                repoRoot: taskRepoRoot,
                 taskSlug: input.taskSlug,
                 handoffDir: task.handoffDir
             });
@@ -136,30 +145,23 @@ export function createTaskService(deps) {
             }
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await this.loadTask(repoRoot, taskSlug);
+            const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+            const statePaths = getTaskStatePaths(repoRoot, taskRepoRoot, config.stateRoot, taskSlug);
             const removedStatePaths = [];
             const cleanedAt = now();
             if (task.worktreePath) {
                 assertTaskWorktreePath(repoRoot, config.stateRoot, task.worktreePath);
-                const status = await deps.git.getStatusPorcelain(task.worktreePath);
-                if (status.trim() && !options.force) {
-                    throw new VcmError({
-                        code: "TASK_WORKTREE_DIRTY",
-                        message: `Task worktree has uncommitted changes: ${task.worktreePath}`,
-                        statusCode: 409,
-                        hint: "Commit, stash, or discard the task worktree changes before cleanup, or retry with force."
-                    });
-                }
-                await deps.git.removeWorktree(repoRoot, task.worktreePath, { force: options.force });
-            }
-            for (const statePath of getTaskStatePaths(repoRoot, config.stateRoot, taskSlug)) {
-                await deps.fs.removePath(statePath, { force: true });
-                removedStatePaths.push(statePath);
+                await deps.git.removeWorktree(repoRoot, task.worktreePath, { force: options.force ?? true });
             }
             let deletedBranch;
-            if (options.deleteBranch) {
-                await deps.git.deleteBranch(repoRoot, task.branch, { force: options.forceDeleteBranch });
+            if (task.worktreePath && (options.deleteBranch ?? true)) {
+                await deps.git.deleteBranch(repoRoot, task.branch, { force: options.forceDeleteBranch ?? true });
                 deletedBranch = task.branch;
             }
+            for (const statePath of statePaths) {
+                await deps.fs.removePath(statePath, { recursive: true, force: true });
+                removedStatePaths.push(statePath);
+            }
             return {
                 taskSlug,
                 removedWorktreePath: task.worktreePath,
@@ -179,12 +181,19 @@ function getTaskPath(repoRoot, stateRoot, taskSlug) {
 function getTaskWorktreePath(repoRoot, stateRoot, taskSlug) {
     return path.join(repoRoot, stateRoot, "worktrees", taskSlug);
 }
-function getTaskStatePaths(repoRoot, stateRoot, taskSlug) {
+async function ensureTaskRuntimeStateDirs(fs, taskRepoRoot, stateRoot) {
+    await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "sessions"));
+    await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "messages"));
+    await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "orchestration"));
+    await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "translation"));
+}
+function getTaskStatePaths(baseRepoRoot, taskRepoRoot, stateRoot, taskSlug) {
     return [
-        path.join(repoRoot, stateRoot, "tasks", `${taskSlug}.json`),
-        path.join(repoRoot, stateRoot, "sessions", `${taskSlug}.json`),
-        path.join(repoRoot, stateRoot, "messages", `${taskSlug}.jsonl`),
-        path.join(repoRoot, stateRoot, "orchestration", `${taskSlug}.json`)
+        path.join(baseRepoRoot, stateRoot, "tasks", `${taskSlug}.json`),
+        path.join(taskRepoRoot, stateRoot, "sessions", `${taskSlug}.json`),
+        path.join(taskRepoRoot, stateRoot, "messages", `${taskSlug}.jsonl`),
+        path.join(taskRepoRoot, stateRoot, "orchestration", `${taskSlug}.json`),
+        path.join(taskRepoRoot, stateRoot, "translation", taskSlug)
     ];
 }
 function assertTaskWorktreePath(repoRoot, stateRoot, worktreePath) {