AI Skill Index

This page is the stable documentation map for the installable cohesive-code skill. It indexes the concepts, files, commands, and pages an agent should read before acting in a Cohesive Code workspace; the skill itself lives at skills/cohesive-code/SKILL.md in the repository.

Detection

A Cohesive Code workspace usually has:

• ccode.yaml at or near the project root
• a ccode_path directory, defaulting to ccode
• generated support files under <ccode_path>/.ccode/lib/
• optional accelerator state under <hidden_path>/accelerators/

If ccode.yaml exists, read it before editing files.

Source of truth order

Use this order when references disagree:

1. The generated local Context type at <ccode_path>/.ccode/lib/context.ts
2. The current CLI implementation and command output
3. This documentation
4. Older README examples

Required reads by task

For initialization:

• Getting Started
• Project Layout
• Configuration
• Wrapper & Versions

For authoring a process:

• Processes
• Templates
• Runtime API
• Minimal Process

For OpenAPI generation:

• OpenAPI Workflows
• OpenAPI Docs
• External schema reference: OAI/OpenAPI Specification
• Runtime API

For database schema generation:

• Database Workflows
• Database Inspection
• Database Schema
• Runtime API

For accelerated artifacts:

• Accelerators
• Accelerator States
• Accelerated Artifact
• CLI

Agent operating rules

• Treat ccode.yaml as the workspace contract.
• Keep source files, templates, specs, and instructions under ccode_path.
• Do not hand-edit .ccode/build/.
• Do not edit .ccode/lib/ in an application workspace; rerun ccode init to refresh it.
• Run the exact process you changed when validation is possible.
• Use ctx.generate(...) only for files that should be regenerated.
• Use ctx.accelerate(...) for files that may need human or agent adjustment.
• Inspect unresolved accelerator work with ccode list accelerated --for-agent.
• Fetch one adjustment bundle with ccode get accelerated <scopeId>:<artifactId> --instructions --for-agent.

Command index

ccode init [path] --version <version>
ccode run <process>
ccode adjust <scopeId>:<artifactId>
ccode list accelerated [scopeId]
ccode list accelerated [scopeId] --include-resolved
ccode list instructions
ccode list instructions --include-resolved
ccode get accelerated <scopeId>:<artifactId>
ccode get accelerated <scopeId>:<artifactId> --instructions
ccode get instruction <path>

Add --for-agent to list and get commands when the caller needs machine-readable JSON.

Runtime API index

ctx.println(message)
ctx.setScope(scopeName)
ctx.scope()
ctx.renderTemplate(templatePath, data)
ctx.generate(templatePath, filePath, data)
ctx.accelerate(id, templatePath, data, instructionsPath?)
ctx.parseJSONFromBytes(jsonBytes)
ctx.parseJSONFromString(jsonString)
ctx.parseJSONFromFile(filePath)
ctx.parseOpenAPIFromBytes(specBytes)
ctx.parseOpenAPIFromString(spec)
ctx.parseOpenAPIFromFile(filePath)
ctx.inspectDatabase(connectionURL)
ctx.inspectDatabase(connectionURL, { expectedEngine })
OpenAPI.isReference(value)
OpenAPI.parseReference(reference)
OpenAPI.Path.toColon(path, options?)
OpenAPI.Path.toSquareBrackets(path, options?)
OpenAPI.Path.toAngleBrackets(path, options?)
OpenAPI.Path.toDollar(path, options?)
Strings.camelCase(value, initialisms?)
Strings.pascalCase(value, initialisms?)
Strings.snakeCase(value)
Strings.kebabCase(value)
Strings.constantCase(value)
Strings.dotCase(value)
Strings.pathCase(value)
Strings.titleCase(value, initialisms?)
Strings.sentenceCase(value, initialisms?)
Strings.upperFirst(value)
Strings.lowerFirst(value)
Strings.normalizeSpace(value)
Go.toExportedIdentifier(value, initialisms?)
Go.toUnexportedIdentifier(value, initialisms?)
Go.toPackageName(value)
TypeScript.toTypeIdentifier(value, initialisms?)
TypeScript.toValueIdentifier(value, initialisms?)

Import OpenAPI from @ccode/openapi, Strings from @ccode/string, Go from @ccode/go, and TypeScript from @ccode/typescript. Templates provide equivalent string, Go naming, TypeScript naming, and OpenAPI path filters; see Templates.